Add files using upload-large-folder tool

parse/train/Byx91R4twB/Byx91R4twB.md

@@ -0,0 +1,388 @@
+# ADVERSARIAL VIDEO GENERATION ON COMPLEX DATASETS
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Generative models of natural images have progressed towards high fidelity samples by the strong leveraging of scale. We attempt to carry this success to the field of video modeling by showing that large Generative Adversarial Networks trained on the complex Kinetics-600 dataset are able to produce video samples of substantially higher complexity and fidelity than previous work. Our proposed model, Dual Video Discriminator GAN (DVD-GAN), scales to longer and higher resolution videos by leveraging a computationally efficient decomposition of its discriminator. We evaluate on the related tasks of video synthesis and video prediction, and achieve new state-of-the-art Fréchet Inception Distance for prediction for Kinetics600, as well as state-of-the-art Inception Score for synthesis on the UCF-101 dataset, alongside establishing a strong baseline for synthesis on Kinetics-600.
+
+# 1 INTRODUCTION
+
+![](images/adc877926138740958977e4f86b2fcca873d05c1b6527e19d41a8b97e5d1037c.jpg)  
+Figure 1: Selected frames from videos generated by a DVD-GAN trained on Kinetics-600 at $2 5 6 \times 2 5 6$ , $1 2 8 \times 1 2 8$ , and $6 4 \times 6 4$ resolutions (top to bottom).
+
+Modern deep generative models can produce realistic natural images when trained on high-resolution and diverse datasets (Brock et al., 2019; Karras et al., 2018; Kingma & Dhariwal, 2018; Menick & Kalchbrenner, 2019; Razavi et al., 2019). Generation of natural video is an obvious further challenge for generative modeling, but one that is plagued by increased data complexity and computational requirements. For this reason, much prior work on video generation has revolved around relatively simple datasets, or tasks where strong temporal conditioning information is available.
+
+We focus on the tasks of video synthesis and video prediction (defined in Section 2.1), and aim to extend the strong results of generative image models to the video domain. Building upon the state-of-the-art BigGAN architecture (Brock et al., 2019), we introduce an efficient spatio-temporal decomposition of the discriminator which allows us to train on Kinetics-600 – a complex dataset of natural videos an order of magnitude larger than other commonly used datasets. The resulting model, Dual Video Discriminator GAN (DVD-GAN), is able to generate temporally coherent, high-resolution videos of relatively high fidelity (Figure 1).
+
+![](images/a2dfb8515504437c7e53d843cc7ee19db4164b306149b5ece9aabdf44ecdcd57.jpg)  
+Figure 2: Generated video samples with interesting behavior. In raster-scan order: a) On-screen generated text with further lines appearing.. b) Zooming in on an object. c) Colored detail from a pen being left on paper. d) A generated camera change and return.
+
+Our contributions are as follows:
+
+• We propose DVD-GAN – a scalable generative model of natural video which produces high-quality samples at resolutions up to $2 5 6 \times 2 5 6$ and lengths up to 48 frames. • We achieve state of the art for video synthesis on UCF-101 and prediction on Kinetics-600. • We establish class-conditional video synthesis on Kinetics-600 as a new benchmark for generative video modeling, and report DVD-GAN results as a strong baseline.
+
+# 2 BACKGROUND
+
+# 2.1 VIDEO SYNTHESIS AND PREDICTION
+
+The exact formulation of the video generation task can differ in the type of conditioning signal provided. At one extreme lies unconditional video synthesis where the task is to generate any video following the training distribution. Another extreme is occupied by strongly-conditioned models, including generation conditioned on another video for content transfer (Bansal et al., 2018; Zhou et al., 2019), per-frame segmentation masks (Wang et al., 2018a), or pose information (Walker et al., 2017; Villegas et al., 2017b; Yang et al., 2018). In the middle ground there are tasks which are more structured than unconditional generation, and yet are more challenging from a modeling perspective than strongly-conditional generation (which gets a lot of information about the generated video through its input). The objective of class-conditional video synthesis is to generate a video of a given category (e.g., “riding a bike”) while future video prediction is concerned with generation of continuing video given initial frames. These problems differ in several aspects, but share a common requirement of needing to generate realistic temporal dynamics, and in this work we focus on these two problems.
+
+# 2.2 GENERATIVE ADVERSARIAL NETWORKS
+
+Generative Adversarial Networks (GANs) (Goodfellow et al., 2014) are a class of generative models defined by a minimax game between a Discriminator $\mathcal { D }$ and a Generator $\mathcal { G }$ . The original objective was proposed by Goodfellow et al. (2014), and many improvements have since been suggested, mostly targeting improved training stability (Arjovsky et al., 2017; Zhang et al., 2018; Brock et al., 2019; Gulrajani et al., 2017; Miyato et al., 2018). We use the hinge formulation of the objective (Lim & Ye, 2017; Brock et al., 2019) which is optimized by gradient descent $\overset { \cdot } { \rho }$ is the elementwise ReLU function):
+
+$$
+\mathcal D \colon \operatorname* { m i n } _ { \mathcal D } \underset { x \sim d a t a ( x ) } { \mathbb { E } } \left[ \rho ( 1 - \mathcal D ( x ) ) \right] + \underset { z \sim p ( z ) } { \mathbb { E } } \left[ \rho ( 1 + \mathcal D ( \mathcal { G } ( z ) ) ) \right] , \quad \mathcal G \colon \operatorname* { m a x } _ { \mathcal G } \underset { z \sim p ( z ) } { \mathbb { E } } \left[ \mathcal D ( \mathcal { G } ( z ) ) \right] .
+$$
+
+GANs have well-known limitations including a tendency towards limited diversity in generated samples (a phenomenon known as mode collapse) and the difficulty of quantitative evaluation due
+
+to the lack of an explicit likelihood measure over the data. Despite these downsides, GANs have produced some of the highest fidelity samples across many visual domains (Karras et al., 2018; Brock et al., 2019).
+
+# 2.3 KINETICS-600
+
+Kinetics is a large dataset of 10-second high-resolution YouTube clips (Kay et al., 2017; DeepMind, 2018) originally created for the task of human action recognition. We use the second iteration of the dataset, Kinetics-600 (Carreira et al., 2018), which consists of 600 classes with at least 600 videos per class for a total of around 500,000 videos.1 Kinetics videos are diverse and unconstrained, which allows us to train large models without being concerned with the overfitting that occurs on small datasets with fixed objects interacting in specified ways (Ebert et al., 2017; Blank et al., 2005). Among prior work, the closest dataset (in terms of subject and complexity) which is consistently used is UCF-101 (Soomro et al., 2012). We focus on Kinetics-600 because of its larger size (almost $5 0 \mathrm { x }$ more videos than UCF-101) and its increased diversity (600 instead of 101 classes – not to mention increased intra-class diversity). Nevertheless for comparison with prior art we train on UCF-101 and achieve a state-of-the-art Inception Score there. Kinetics contains many artifacts expected from YouTube, including cuts (as in Figure 2d), title screens and visual effects. Except when specifically described, we choose frames with stride 2 (meaning we skip every other frame). This allows us to generate videos with more complexity without incurring higher computational cost.
+
+To the best of our knowledge we are the first to consider generative modelling of the entirety of the Kinetics video dataset2, although a small subset of Kinetics consisting of 4,000 selected and stabilized videos (via a SIFT $^ +$ RANSAC procedure) has been used in at least two prior papers (Li et al., 2018; Balaji et al., 2018). Due to the heavy pre-processing and stabilization present, as well as the sizable reduction in dataset size (two orders of magnitude) we do not consider these datasets comparable to the full Kinetics-600 dataset.
+
+# 2.4 EVALUATION METRICS
+
+Designing metrics for measuring the quality of generative models (GANs in particular) is an active area of research (Sajjadi et al., 2018; Barratt & Sharma, 2018). In this work we report the two most commonly used metrics, Inception Score (IS) (Salimans et al. (2016)) and Fréchet Inception Distance (FID) (Heusel et al., 2017). The standard instantiation of these metrics is intended for generative image models, and uses an Inception model (Szegedy et al., 2016) for image classification or feature extraction. For videos, we use the publicly available Inflated 3D Convnet (I3D) network trained on Kinetics-600 (Carreira & Zisserman, 2017). Our Fréchet Inception Distance is therefore very similar to the Fréchet Video Distance (FVD) (Unterthiner et al., 2018), although our implementation is different and more aligned with the original FID metric.3 More details are in Appendix A.4.
+
+# 3 DUAL VIDEO DISCRIMINATOR GAN
+
+Our primary contribution is Dual Video Discriminator GAN (DVD-GAN), a generative video model of complex human actions built upon the state-of-the-art BigGAN architecture (Brock et al., 2019) while introducing scalable, video-specific generator and discriminator architectures. An overview of the DVD-GAN architecture is given in Figure 3 and a detailed description is in Appendix A.2. Unlike some of the prior work, our generator contains no explicit priors for foreground, background or motion (optical flow); instead, we rely on a high-capacity neural network to learn this in a data-driven manner. While DVD-GAN contains sequential components (RNNs), it is not autoregressive in time or in space. In other words, the pixels of each frame do not directly depend on other pixels in the video, as would be the case for auto-regressive models or models generating one frame at a time.
+
+Generating long and high resolution videos is a heavy computational challenge: individual samples from Kinetics-600 (just 10 seconds long) contain upwards of 16 million pixels which need to be generated in a consistent fashion. This is a particular challenge to the discriminator. For example, a generated video might contain an object which leaves the field of view and incorrectly returns with a different color. Here, the ability to determine this video is generated is only possible by comparing two different spatial locations across two (potentially distant) frames. Given a video with length $T$ , height $H$ , and width $W$ , discriminators that process the entire video would have to process all $H \times W \times T$ pixels – limiting the size of the model and the size of the videos being generated.
+
+![](images/c630e03b69f5632cb0f1b4fcdd5e6cbe2329d6a917d9c2f34800c987129c3f4f.jpg)  
+ResNet Block Figure 3: Simplified architecture diagram of $\mathcal { G }$ (left) and $\mathcal { D } _ { S } / \mathcal { D } _ { T }$ Block (right). More details in A.2.
+
+# 3.1 DUAL DISCRIMINATORS
+
+DVD-GAN tackles this scale problem by using two discriminators: a Spatial Discriminator $\mathcal { D } _ { S }$ and a Temporal Discriminator $\mathcal { D } _ { T }$ . $\mathcal { D } _ { S }$ critiques single frame content and structure by randomly sampling $k$ full-resolution frames and judging them individually. We use $k = 8$ and discuss this choice in Section 4.3. $\mathcal { D } _ { S }$ ’s final score is the sum of the per-frame scores. The temporal discriminator $\mathcal { D } _ { T }$ must provide $\mathcal { G }$ with the learning signal to generate movement (something not evaluated by $\mathcal { D } _ { S }$ ). To make the model scalable, we apply a spatial downsampling function $\phi ( \cdot )$ to the whole video and feed its output to $\mathcal { D } _ { T }$ . We choose $\phi$ to be $2 \times 2$ average pooling, and discuss alternatives in Section 4.3. This results in an architecture where the discriminators do not process the entire video’s worth of pixels, $\mathcal { D } _ { S }$ processes only resolution, this $k \times H \times W$ pixels and umber of p $\mathcal { D } _ { T }$ only  to pr $T \times \frac { H } { 2 } \times \frac { W } { 2 }$ . For a 48 frame video ato from 786432 to 327680: $1 2 8 \times 1 2 8$   
+a $5 8 \%$ reduction. Despite this decomposition, the discriminator objective is still able to penalize almost all inconsistencies which would be penalized by a discriminator judging the entire video. $\mathcal { D } _ { T }$ judges any temporal discrepancies across the entire length of the video, and $\mathcal { D } _ { S }$ can judge any high resolution details. The only detail the DVD-GAN discriminator objective is unable to reflect is the temporal evolution of pixels within a $2 \times 2$ window. We have however not noticed this affecting the generated samples in practice. DVD-GAN’s $\mathcal { D } _ { S }$ is similar to the per-frame discriminator $\mathcal { D } _ { I }$ in MoCoGAN (Tulyakov et al., 2018). However MoCoGAN’s analog of $\mathcal { D } _ { T }$ looks at full resolution videos, whereas $\mathcal { D } _ { S }$ is the only source of learning signal for high-resolution details in DVD-GAN. For this reason, $\mathcal { D } _ { S }$ is essential when $\phi$ is not the identity, unlike in MoCoGAN where the additional per-frame discriminator is less crucial.
+
+# 3.2 RELATED WORK
+
+Generative video modeling is a widely explored problem which includes work on VAEs (Babaeizadeh et al., 2018; Denton & Fergus, 2018; Lee et al., 2018; Hsieh et al., 2018) and recurrent models (Wang et al., 2018b; Finn et al., 2016; Wang et al., 2018c; Byeon et al., 2018), auto-regressive models (Ranzato et al., 2014; Srivastava et al., 2015; Kalchbrenner et al., 2017; Weissenborn et al., 2019), normalizing flows (Kumar et al., 2019), and GANs (Mathieu et al., 2015; Vondrick et al., 2016; Saito et al., 2017; Saito & Saito, 2018). Much prior work considers decompositions which model the texture and spatial consistency of objects separately from their temporal dynamics. One approach is to split $\mathcal { G }$ into foreground and background models (Vondrick et al., 2016; Spampinato et al., 2018), while another considers explicit or implicit optical flow or motion in either $\mathcal { G }$ or $\mathcal { D }$ (Saito et al., 2017; Ohnishi et al., 2018). Other methods decompose the generator (or encoder) to treat concepts like pose, content and motion separately from one another (Denton et al., 2017; Villegas et al., 2017a). Similar to DVD-GAN, MoCoGAN (Tulyakov et al., 2018) discriminates individual frames in addition to a discriminator which operates on fixed-length $K$ -frame slices of the whole video (where $K < T$ ). Though this potentially reduces the number of pixels to discriminate to $( H \times W ) + ( K \times H \times W )$ , Tulyakov et al. (2018) describes discriminating sliding windows, which increases the total number of pixels. Other models follow this approach by discriminating groups of frames (Xie et al., 2018; Sun et al., 2018; Balaji et al., 2018).
+
+![](images/4f9ff19b1e94ddb46e0d5406dc6163bf997b04b74c8e7e25c020f5ada2cc9adf.jpg)  
+Figure 4: Each row is the first frame of 15 videos from a random class, all from the same checkpoint. The classes are: cooking scallops, changing wheel (not on bike), calculating, dribbling basketball.
+
+![](images/5108ab2cac78a011bdcfb9ec2f0d5b527d89d5f08bdbbf3f3f367b127993cbdd.jpg)  
+Figure 5: All 48 frames (in raster-scan order) from a $6 4 \times 6 4$ sample from watermelon cutting class.
+
+TGANv2 (Saito & Saito, 2018) proposes “adaptive batch reduction” for efficient training, an operation which randomly samples subsets of videos within a batch and temporal subwindows within each video. This operation is applied throughout TGANv2’s $\mathcal { G }$ , with heads projecting intermediate feature maps directly to pixel space before applying batch reduction, and corresponding discriminators evaluating these lower resolution intermediate outputs. An effect of this choice is that TGANv2 discriminators only evaluate full-length videos at very low resolution. We show in Figure 6 that a similar reduction in DVD-GAN’s resolution when judging full videos leads to a loss in performance. We expect further reduction (towards the resolution at which TGANv2 evaluates the entire length of video) to lead to further degradation of DVD-GAN’s quality. Furthermore, this method is not easily adapted towards models with large batch sizes divided across a number of accelerators, with only a small batch size per replica.
+
+# 4 EXPERIMENTS AND ANALYSIS
+
+A detailed description of our training setup is in Appendix A.3. Each DVD-GAN was trained on TPU pods (Google, 2018) using between 32 and 512 replicas with an Adam (Kingma & Ba, 2014) optimizer. Video Synthesis models are trained for around 300,000 learning steps, whilst Video Prediction models are trained for up to 1,000,000 steps. Most models took between 12 and 96 hours to train.
+
+# 4.1 VIDEO SYNTHESIS
+
+Our primary results concern the problem of Video Synthesis. We provide our results for the UCF-101 and Kinetics-600 datasets. With Kinetics-600 emerging as a new benchmark for generative video modelling, our results establish a strong baseline for future work.
+
+# 4.1.1 KINETICS-600 RESULTS
+
+Table 1: FID/IS for DVD-GAN on Kinetics-600 Video Synthesis. We present the scores of the model taken at the point in training when the best FID was attained. The "No Truncation" columns contain the scores obtained without the truncation trick. The "With Truncation" columns contain the scores obtained at the truncation level which results in the best Inception Score.   
+
+<table><tr><td>(#Frames /Resolution)</td><td colspan="2">No Truncation FID (↓) IS (↑)</td><td colspan="2">With Truncation FID (↓) IS (↑)</td></tr><tr><td>12/64 × 64</td><td>0.85</td><td>53.81</td><td>7.13</td><td>187.23</td></tr><tr><td>12/128 × 128</td><td>1.16</td><td>77.45</td><td>13.04</td><td>246.18</td></tr><tr><td>12/256 × 256</td><td>2.05</td><td>62.78</td><td>10.17</td><td>162.44</td></tr><tr><td>48/64 × 64</td><td>13.75</td><td>104.09</td><td>47.86</td><td>264.12</td></tr><tr><td>48/128 × 128</td><td>28.44</td><td>81.41</td><td>45.79</td><td>188.32</td></tr></table>
+
+In Table 1 we show the main result of this paper: benchmarks for Class-Conditional Video Synthesis on Kinetics-600. In this regime, we train a single DVD-GAN on all classes of Kinetics-600, supplying per-sample class information to both $\mathcal { G }$ and $\mathcal { D }$ . We consider a range of resolutions and video lengths, and measure Inception Score and Fréchet Inception Distance (FID) for each (as described in Section 2.4). We further measure each model along a truncation curve, which we carry out by calculating FID and IS statistics while varying the standard deviation of the latent vectors between 0 and 1. There is no prior work with which to quantitatively compare these results (for comparative experiments see Section 4.1.2 and Section 4.2.1), but we believe these samples to show a level of fidelity not yet achieved in datasets as complex as Kinetics-600 (see samples from each row in Appendix D.1). Because all videos are resized for the I3D network (to $2 2 4 \times 2 2 4 )$ ), it is meaningful to compare metrics across equal length videos at different resolutions. Neither IS nor FID are comparable across videos of different lengths, and should be treated as separate metrics.
+
+Generating longer and larger videos is a more challenging modeling problem, which is conveyed by the metrics (in particular, comparing 12-frame videos across $6 4 \times 6 4$ , $1 2 8 \times 1 2 8$ and $2 5 6 \times 2 5 6$ resolutions). Nevertheless, DVD-GAN is able to generate plausible videos at all resolutions and with length spanning up to 4 seconds (48 frames). As can be seen in Appendix D.1, smaller videos display high quality textures, object composition and movement. At higher resolutions, generating coherent objects becomes more difficult (movement consists of a much larger number of pixels), but high-level details of the generated scenes are still extremely coherent, and textures (even complicated ones like a forest backdrop in Figure 1a) are generated well. It is further worth noting that the 48-frame models do not see more high resolution frames than the 12-frame model (due to the fixed choice of $k = 8$ described in Section 3.1), yet nevertheless learn to generate high resolution images.
+
+# 4.1.2 VIDEO SYNTHESIS ON UCF-101
+
+We further verify our results by testing the same model on UCF-101 (Soomro et al., 2012), a smaller dataset of 13,320 videos of human actions across 101 classes that has previously been used for video synthesis and prediction (Saito et al., 2017; Saito & Saito, 2018; Tulyakov et al., 2018). Our model produces samples with an IS of 27.38, significantly outperforming the state of the art (see Table 2 for quantitative comparison and Appendix B.1 for more details).
+
+Table 2: IS on UCF-101 without class conditioning.   
+
+<table><tr><td>Method</td><td>IS (↑)</td></tr><tr><td>VGAN (Vondrick et al., 2016)</td><td>8.31 ± .09</td></tr><tr><td>TGAN (Saito et al., 2017)</td><td>11.85 ± .07</td></tr><tr><td>MoCoGAN (Tulyakov et al., 2018)</td><td>12.42 ± .03</td></tr><tr><td>ProgressiveVGAN (Acharya et al., 2018)</td><td>14.56 ± .05</td></tr><tr><td>TGANv2 (Saito &amp; Saito,2018)</td><td>24.34 ± .35</td></tr><tr><td>DVD-GAN (ours)</td><td>27.38 ± 0.53</td></tr></table>
+
+Table 3: FVD on BAIR.   
+
+<table><tr><td>Method</td><td>FVD (↓)</td></tr><tr><td>SVP-FP CDNA</td><td>315.5</td></tr><tr><td>SV2P</td><td>296.5 262.5</td></tr><tr><td>SAVP</td><td>116.4</td></tr><tr><td>DVD-GAN-FP (ours)</td><td>109.8</td></tr><tr><td>Video Transformer</td><td>94±2</td></tr></table>
+
+Table 4: DVD-GAN-FP’s FVD scores on Video Prediction for 16 frames of Kinetics-600 without frame skipping. The final row represents a Video Synthesis model generating 16 frames.   
+
+<table><tr><td>Method</td><td>Training Set FVD (↓)</td><td>Test Set FVD (↓)</td></tr><tr><td>Video Transformer (Weissenborn et al.,2019)</td><td></td><td>170±5</td></tr><tr><td>DVD-GAN-FP</td><td>68.66 ± 0.78</td><td>69.15 ± 1.16</td></tr><tr><td>DVD-GAN</td><td>32.3 ± 0.82</td><td>31.1 ± 0.56</td></tr></table>
+
+# 4.2 FUTURE VIDEO PREDICTION
+
+Future Video Prediction is the problem of generating a sequence of frames which directly follow from one (or a number) of initial conditioning frames. Both this and video synthesis require $\mathcal { G }$ to learn to produce realistic scenes and temporal dynamics, however video prediction further requires $\mathcal { G }$ to analyze the conditioning frames and discover elements in the scene which will evolve over time. In this section, we use the Fréchet Video Distance exactly as Unterthiner et al. (2018): using the logits of an I3D network trained on Kinetics-400 as features. This allows for direct comparison to prior work. Our model, DVD-GAN-FP (Frame Prediction), is slightly modified to facilitate the changed problem, and details of these changes are given in Appendix A.5.
+
+# 4.2.1 FRAME-CONDITIONAL KINETICS
+
+For direct comparison with concurrent work on autoregressive video models (Weissenborn et al., 2019) we consider the generation of 11 frames of Kinetics-600 at $6 4 \times 6 4$ resolution conditioned on 5 frames, where the videos for training are not taken with any frame skipping. We show results for all these cases in Table 4. Our frame-conditional model DVD-GAN- ${ \pmb F } { \pmb P }$ outperforms the prior work on frame-conditional prediction for Kinetics. The final row labeled DVD-GAN corresponds to 16-frame class-conditional Video Synthesis samples, generated without frame conditioning and without frame skipping. The FVD of this video synthesis model is notably better.
+
+On the one hand, we hypothesize that the synthesis model has an easier generative task: it can choose to generate (relatively) simple samples for each class, rather than be forced to continue frames taken from videos which are class outliers, or contain more complicated details. On the other hand, a certain portion of the FID/FVD metric undoubtedly comes from the distribution of objects and backgrounds present in the dataset, and so it seems that the prediction model should have a handicap in the metric by being given the ground truth distribution of backgrounds and objects with which to continue videos. The synthesis model’s improved performance on this task seems to indicate that the advantage of being able to select videos to generate is greater than the advantage of having a ground truth distribution of starting frames. This result is un-intuitive, as the frame conditional model has access to strictly more information about the data distribution it is trying to recover compared to the synthesis model (despite the fact that the two models are being trained by an identical objective). This experiment favors the synthesis model for FVD, but we highlight that other models or other metrics might produce the opposite ordering.
+
+![](images/329ac23a7eb4e35037e2a45da62a239de0af7a5ed97b9145e0822c627cb65e8d.jpg)  
+Figure 6: The effect of $\phi$ in $\mathcal { D } _ { T }$ (left two) and $k$ in $\mathcal { D } _ { S }$ (right two). FID is similar for any choice of $\phi$ , while IS declines as downsampling increases. Increasing $k$ improves both with diminishing returns.
+
+# 4.2.2 BAIR ROBOT PUSHING
+
+We further test future video prediction on the single-class BAIR Robot Pushing Dataset (Ebert et al., 2017), a dataset of stationary videos of a robot arm moving around a set of changing objects. In order for direct comparison with previous results reported in Unterthiner et al. (2018), we consider generating 15 frames conditioned on a single starting frame. Like on prediction with Kinetics, we report FVD exactly as in Unterthiner et al. (2018), with ground truth statistics and conditioning frames taken from the 256-video dev set. Results are reported in Table 3. Scores are taken from Unterthiner et al. (2018). DVD-GAN-FP outperforms all prior adversarial models trained on this dataset, but performs slightly worse than Video Transformer, a concurrently developed autoregressive model Weissenborn et al. (2019). Samples from DVD-GAN-FP on BAIR are given in Figure 9.
+
+# 4.3 DUAL DISCRIMINATOR INPUT
+
+We analyze several choices for $k$ (the number of frames per sample in the input to $\mathcal { D } _ { S }$ ) and $\phi$ (the downsampling function for $\mathcal { D } _ { T }$ ). We expect setting $\phi$ to the identity or $k = T$ to result in the best model, but we are interested in the maximally compressive $k$ and $\phi$ that reduce discriminator input size (and the amount of computation), while still producing a high quality generator. For $\phi$ , we consider: $2 \times 2$ and $4 \times 4$ average pooling, the identity (no downsampling), as well as a $\phi$ which takes a random half-sized crop of the input video (as in Saito & Saito (2018)). Results can be seen in Figure 6. For each ablation, we train three identical DVD-GANs with different random initializations on 12-frame clips of Kinetics-600 at $6 4 \times 6 4$ resolution for 100,000 steps. We report mean and standard deviation (via the error bars) across each group for the whole training period. For $k$ , we consider 1, 2, 8 and 10 frames. We see diminishing effect as $k$ increases, so settle on $k = 8$ . We note the substantially reduced IS of $4 \times 4$ downsampling as opposed to $2 \times 2$ , and further note that taking half-sized crops (which results in the same number of pixels input to $\mathcal { D } _ { T }$ as $2 \times 2$ pooling) is also notably worse.
+
+# 5 CONCLUSION
+
+We approached the challenging problem of modeling natural video by introducing a GAN capable of capturing the complexity of a large video dataset. We showed that on UCF-101 and frame-conditional Kinetics-600 it quantitatively achieves the new state of the art, alongside qualitatively producing video synthesis samples with high complexity and diversity. We further wish to emphasize the benefit of training generative models on large and complex video datasets, such as Kinetics-600, and envisage the strong baselines we established on this dataset with DVD-GAN will be used as a reference point by the generative modeling community moving forward. While much remains to be done before realistic videos can be consistently generated in an unconstrained setting, we believe DVD-GAN is a step in that direction.
+
+# REFERENCES
+
+Dinesh Acharya, Zhiwu Huang, Danda Pani Paudel, and Luc Van Gool. Towards high resolution video generation with progressive growing of sliced Wasserstein GANs. arXiv:1810.02419, 2018.
+
+Martin Arjovsky, Soumith Chintala, and Léon Bottou. Wasserstein GAN. arXiv:1701.07875, 2017.
+
+Mohammad Babaeizadeh, Chelsea Finn, Dumitru Erhan, Roy H Campbell, and Sergey Levine. Stochastic variational video prediction. ICLR, 2018.
+
+Yogesh Balaji, Martin Renqiang Min, Bing Bai, Rama Chellappa, and Hans Peter Graf. Tfgan: Improving conditioning for text-to-video synthesis. 2018.
+
+Nicolas Ballas, Li Yao, Chris Pal, and Aaron Courville. Delving deeper into convolutional networks for learning video representations. arXiv:1511.06432, 2015.
+
+Aayush Bansal, Shugao Ma, Deva Ramanan, and Yaser Sheikh. Recycle-GAN: Unsupervised video retargeting. In ECCV, September 2018.
+
+Shane Barratt and Rishi Sharma. A note on the Inception Score. arXiv:1801.01973, 2018.
+
+Moshe Blank, Lena Gorelick, Eli Shechtman, Michal Irani, and Ronen Basri. Actions as space-time shapes. In ICCV, 2005.
+
+Andrew Brock, Jeff Donahue, and Karen Simonyan. Large scale GAN training for high fidelity natural image synthesis. ICLR, 2019.
+
+Wonmin Byeon, Qin Wang, Rupesh Kumar Srivastava, and Petros Koumoutsakos. Contextvp: Fully context-aware video prediction. In Proceedings of the European Conference on Computer Vision (ECCV), pp. 753–769, 2018.
+
+Joao Carreira and Andrew Zisserman. Quo vadis, action recognition? A new model and the Kinetics dataset. In ICCV, 2017.
+
+Joao Carreira, Eric Noland, Andras Banki-Horvath, Chloe Hillier, and Andrew Zisserman. A short note about Kinetics-600. arXiv:1808.01340, 2018.
+
+Harm De Vries, Florian Strub, Jérémie Mary, Hugo Larochelle, Olivier Pietquin, and Aaron C Courville. Modulating early visual processing by language. In NeurIPS, 2017.
+
+DeepMind, 2018. Kinetics. https://deepmind.com/research/open-source/ open-source-datasets/kinetics/. Accessed: 2019.
+
+Emily Denton and Rob Fergus. Stochastic video generation with a learned prior. ICML, 2018.
+
+Emily L Denton et al. Unsupervised learning of disentangled representations from video. In Advances in neural information processing systems, pp. 4414–4423, 2017.
+
+Vincent Dumoulin, Jonathon Shlens, and Manjunath Kudlur. A learned representation for artistic style. In ICLR, 2017.
+
+Frederik Ebert, Chelsea Finn, Alex X Lee, and Sergey Levine. Self-supervised visual planning with temporal skip connections. arXiv:1710.05268, 2017.
+
+Chelsea Finn, Ian Goodfellow, and Sergey Levine. Unsupervised learning for physical interaction through video prediction. In Advances in neural information processing systems, pp. 64–72, 2016.
+
+Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In NeurIPS, 2014.
+
+Google, 2018. Cloud tpu. https://cloud.google.com/tpu/. Accessed: 2019.
+
+Google, 2019. Fvd. https://github.com/google-research/google-research/ tree/master/frechet_video_distance. Accessed: 2019.
+
+Ishaan Gulrajani, Faruk Ahmed, Martin Arjovsky, Vincent Dumoulin, and Aaron C Courville. Improved training of Wasserstein GANs. In NeurIPS, 2017.
+
+Martin Heusel, Hubert Ramsauer, Thomas Unterthiner, Bernhard Nessler, and Sepp Hochreiter. GANs trained by a two time-scale update rule converge to a local nash equilibrium. In NeurIPS, 2017.
+
+Jun-Ting Hsieh, Bingbin Liu, De-An Huang, Li Fei-Fei, and Juan Carlos Niebles. Learning to decompose and disentangle representations for video prediction. In NeurIPS. 2018.
+
+Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. arXiv:1502.03167, 2015.
+
+Nal Kalchbrenner, Aäron van den Oord, Karen Simonyan, Ivo Danihelka, Oriol Vinyals, Alex Graves, and Koray Kavukcuoglu. Video pixel networks. In ICML, 2017.
+
+Tero Karras, Samuli Laine, and Timo Aila. A style-based generator architecture for generative adversarial networks. arXiv:1812.04948, 2018.
+
+Will Kay, Joao Carreira, Karen Simonyan, Brian Zhang, Chloe Hillier, Sudheendra Vijayanarasimhan, Fabio Viola, Tim Green, Trevor Back, Paul Natsev, Mustafa Suleyman, and Andrew Zisserman. The Kinetics human action video dataset. arXiv:1705.06950, 2017.
+
+Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv:1412.6980, 2014.
+
+Durk P Kingma and Prafulla Dhariwal. Glow: Generative flow with invertible 1x1 convolutions. In NeurIPS, 2018.
+
+Manoj Kumar, Mohammad Babaeizadeh, Dumitru Erhan, Chelsea Finn, Sergey Levine, Laurent Dinh, and Durk Kingma. VideoFlow: A flow-based generative model for video. arXiv:1903.01434, 2019.
+
+Alex X Lee, Richard Zhang, Frederik Ebert, Pieter Abbeel, Chelsea Finn, and Sergey Levine. Stochastic adversarial video prediction. arXiv:1804.01523, 2018.
+
+Jimmy Lei Ba, Jamie Ryan Kiros, and Geoffrey E Hinton. Layer normalization. arXiv:1607.06450, 2016.
+
+Yitong Li, Martin Renqiang Min, Dinghan Shen, David Carlson, and Lawrence Carin. Video generation from text. In Thirty-Second AAAI Conference on Artificial Intelligence, 2018.
+
+Jae Hyun Lim and Jong Chul Ye. Geometric GAN. arXiv:1705.02894, 2017.
+
+Michael Mathieu, Camille Couprie, and Yann LeCun. Deep multi-scale video prediction beyond mean square error. arXiv:1511.05440, 2015.
+
+Jacob Menick and Nal Kalchbrenner. Generating high fidelity images with subscale pixel networks and multidimensional upscaling. In ICLR, 2019.
+
+Takeru Miyato and Masanori Koyama. cGANs with projection discriminator. arXiv:1802.05637, 2018.
+
+Takeru Miyato, Toshiki Kataoka, Masanori Koyama, and Yuichi Yoshida. Spectral normalization for generative adversarial networks. arXiv:1802.05957, 2018.
+
+Katsunori Ohnishi, Shohei Yamamoto, Yoshitaka Ushiku, and Tatsuya Harada. Hierarchical video generation from orthogonal information: Optical flow and texture. In AAAI, 2018.
+
+Marc’Aurelio Ranzato, Arthur Szlam, Joan Bruna, Michaël Mathieu, Ronan Collobert, and Sumit Chopra. Video (language) modeling: a baseline for generative models of natural videos. arXiv:1412.6604, 2014.
+
+Ali Razavi, Aaron van den Oord, and Oriol Vinyals. Generating diverse high-fidelity images with VQ-VAE-2. arXiv preprint arXiv:1906.00446, 2019.
+
+Masaki Saito and Shunta Saito. TGANv2: Efficient training of large models for video generation with multiple subsampling layers. arXiv:1811.09245, 2018.
+
+Masaki Saito, Eiichi Matsumoto, and Shunta Saito. Temporal generative adversarial nets with singular value clipping. In ICCV, 2017.
+
+Mehdi SM Sajjadi, Olivier Bachem, Mario Lucic, Olivier Bousquet, and Sylvain Gelly. Assessing generative models via precision and recall. In NeurIPS, 2018.
+
+Tim Salimans, Ian Goodfellow, Wojciech Zaremba, Vicki Cheung, Alec Radford, and Xi Chen. Improved techniques for training GANs. In NeurIPS, 2016.
+
+Andrew M Saxe, James L McClelland, and Surya Ganguli. Exact solutions to the nonlinear dynamics of learning in deep linear neural networks. arXiv:1312.6120, 2013.
+
+Khurram Soomro, Amir Roshan Zamir, and Mubarak Shah. UCF101: A dataset of 101 human actions classes from videos in the wild. arXiv:1212.0402, 2012.
+
+Concetto Spampinato, Sergio Palazzo, P D’Oro, Francesca Murabito, Daniela Giordano, and M Shah. VOS-GAN: Adversarial learning of visual-temporal dynamics for unsupervised dense prediction in videos. arXiv:1803.09092, 2018.
+
+Nitish Srivastava, Elman Mansimov, and Ruslan Salakhutdinov. Unsupervised learning of video representations using LSTMs. In ICML, 2015.
+
+Ximeng Sun, Huijuan Xu, and Kate Saenko. A two-stream variational adversarial network for video generation. arXiv:1812.01037, 2018.
+
+Ilya Sutskever, James Martens, and Geoffrey E Hinton. Generating text with recurrent neural networks. In ICML, 2011.
+
+Christian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jonathon Shlens, and Zbigniew Wojna. Rethinking the Inception architecture for computer vision. In CVPR, 2016.
+
+Seiya Tokui, Kenta Oono, Shohei Hido, and Justin Clayton. Chainer: a next-generation open source framework for deep learning. In Workshop on Systems for ML and Open Source Software at NeurIPS, 2015.
+
+Du Tran, Lubomir Bourdev, Rob Fergus, Lorenzo Torresani, and Manohar Paluri. Learning spatiotemporal features with 3D convolutional networks. In ICCV, 2015.
+
+Sergey Tulyakov, Ming-Yu Liu, Xiaodong Yang, and Jan Kautz. MoCoGAN: Decomposing motion and content for video generation. In CVPR, 2018.
+
+Dmitry Ulyanov, Andrea Vedaldi, and Victor Lempitsky. Instance normalization: The missing ingredient for fast stylization. arXiv:1607.08022, 2016.
+
+Thomas Unterthiner, Sjoerd van Steenkiste, Karol Kurach, Raphael Marinier, Marcin Michalski, and Sylvain Gelly. Towards accurate generative models of video: A new metric & challenges. arXiv:1812.01717, 2018.
+
+Ruben Villegas, Jimei Yang, Seunghoon Hong, Xunyu Lin, and Honglak Lee. Decomposing motion and content for natural video sequence prediction. arXiv preprint arXiv:1706.08033, 2017a.
+
+Ruben Villegas, Jimei Yang, Yuliang Zou, Sungryull Sohn, Xunyu Lin, and Honglak Lee. Learning to generate long-term future via hierarchical prediction. In ICML, 2017b.
+
+Carl Vondrick, Hamed Pirsiavash, and Antonio Torralba. Generating videos with scene dynamics. In NeurIPS, 2016.
+
+Jacob Walker, Kenneth Marino, Abhinav Gupta, and Martial Hebert. The pose knows: Video forecasting by generating pose futures. In ICCV, 2017.
+
+Ting-Chun Wang, Ming-Yu Liu, Jun-Yan Zhu, Guilin Liu, Andrew Tao, Jan Kautz, and Bryan Catanzaro. Video-to-video synthesis. arXiv:1808.06601, 2018a.
+
+Yunbo Wang, Zhifeng Gao, Mingsheng Long, Jianmin Wang, and Philip S Yu. Predrnn $^ { + + }$ : Towards a resolution of the deep-in-time dilemma in spatiotemporal predictive learning. arXiv preprint arXiv:1804.06300, 2018b.
+
+![](images/2b82b8c12420384304cdce1e87dfb74e91a7c033b4b1bdbba1c564101dc5acd8.jpg)  
+Figure 7: The residual blocks for $\mathcal { G }$ and $\mathcal { D } _ { S } / \mathcal { D } _ { T }$ . See Figure 3 for the icons and A.2 for more detail.
+
+Yunbo Wang, Lu Jiang, Ming-Hsuan Yang, Li-Jia Li, Mingsheng Long, and Li Fei-Fei. Eidetic 3d lstm: A model for video prediction and beyond. 2018c.
+
+Dirk Weissenborn, Oscar Täckström, and Jakob Uszkoreit. Scaling autoregressive video models. arXiv:1906.02634, 2019.
+
+Yuxin Wu and Kaiming He. Group normalization. In ECCV, 2018.
+
+You Xie, Erik Franz, Mengyu Chu, and Nils Thuerey. tempoGAN: A temporally coherent, volumetric GAN for super-resolution fluid flow. TOG, 2018.
+
+Ceyuan Yang, Zhe Wang, Xinge Zhu, Chen Huang, Jianping Shi, and Dahua Lin. Pose guided human video generation. In ECCV, 2018.
+
+Han Zhang, Ian Goodfellow, Dimitris Metaxas, and Augustus Odena. Self-attention generative adversarial networks. arXiv:1805.08318, 2018.
+
+Yipin Zhou, Zhaowen Wang, Chen Fang, Trung Bui, and Tamara L Berg. Dance dance generation: Motion transfer for internet videos. arXiv:1904.00129, 2019.
+
+# A EXPERIMENT METHODOLOGY
+
+# A.1 DATASET PROCESSING
+
+For all datasets we randomly shuffle the training set for each model replica independently. Experiments on the BAIR Robot Pushing dataset are conducted in the native resolution of $6 4 \times 6 4$ , where for UCF-101 we operate at a (downsampled) $1 2 8 \times 1 2 8$ resolution. This is done by a bilinear resize such that the video’s smallest dimension is mapped to 128 pixels while maintaining aspect ratio (144 for UCF-101). From this we take a random 128-pixel crop along the other dimension. We use the same procedure to construct datasets of different resolutions for Kinetics-600. All three datasets contain videos with more frames than we generate, so we take a random sequence of consecutive frames from the resized output. For UCF-101, we augmented the dataset by randomly performing left-right flips with probability 0.5.
+
+# A.2 ARCHITECTURE DESCRIPTION
+
+Our model adopts many architectural choices from Brock et al. (2019) including our nomenclature for describing network width, which is determined by the product of a channel multiplier $c h$ with a constant for each layer in the network. The layer-wise constants for $\mathcal { G }$ are [8, 8, 8, 4, 2] for $6 4 \times 6 4$ videos and $[ 8 , 8 , 8 , 4 , 2 , 1 ]$ for $1 2 8 \times 1 2 8$ . The width of the $i$ -th layer is given by the product of $c h$ and the $i$ -th constant and all layers prior to the residual network in $\mathcal { G }$ use the initial layer’s multiplier and we refer to the product of that and $c h$ as $c h _ { 0 }$ . ch in DVD-GAN is 128 for videos with $6 4 \times 6 4$ resolution and 96 otherwise. The corresponding $c h$ lists for both $\mathcal { D } _ { T }$ and $\mathcal { D } _ { S }$ are [2, 4, 8, 16, 16] for $6 4 \times 6 4$ resolution and $[ 1 , 2 , 4 , 8 , 1 6 , 1 6 ]$ for $1 2 8 \times 1 2 8$ .
+
+The input to $\mathcal { G }$ consists of a Gaussian latent noise $z \sim \mathcal { N } ( 0 , I )$ and a learned linear embedding $e ( y )$ of the desired class $y$ . Both inputs are 120-dimensional vectors. $\mathcal { G }$ starts by computing an affine transformation of $[ z ; e ( y ) ]$ to a $[ 4 , 4 , c h _ { 0 } ]$ -shaped tensor (in Figure 3 this is represented as a $1 \times 1$ convolution). $[ z ; e ( y ) ]$ is used as the input to all class-conditional Batch Normalization layers throughout $\mathcal { G }$ (the gray line in Figure 7).
+
+This is then treated as the input (at each frame we would like to generate) to a Convolutional Gated Recurrent Unit (Ballas et al., 2015; Sutskever et al., 2011) whose update rule for input $x _ { t }$ and previous output $h _ { t - 1 }$ is given by the following:
+
+$$
+\begin{array} { r l } & { r = \sigma ( W _ { r } \star _ { 3 } \left[ h _ { t - 1 } ; x _ { t } \right] + b _ { r } ) } \\ & { u = \sigma ( W _ { u } \star _ { 3 } \left[ h _ { t - 1 } ; x _ { t } \right] + b _ { u } ) } \\ & { c = \rho ( W _ { c } \star _ { 3 } \left[ x _ { t } ; r \odot h _ { t - 1 } \right] + b _ { c } ) } \\ & { h _ { t } = u \odot h _ { t - 1 } + ( 1 - u ) \odot c } \end{array}
+$$
+
+In these equations $\sigma$ and $\rho$ are the elementwise sigmoid and ReLU functions respectively, the $\star _ { n }$ operator represents a convolution with a kernel of size $n \times n$ , and the $\odot$ operator is an elementwise multiplication. Brackets are used to represent a feature concatenation. This RNN is unrolled once per frame. The output of this RNN is processed by two residual blocks (whose architecture is given by Figure 7). The time dimension is combined with the batch dimension here, so each frame proceeds through the blocks independently. The output of these blocks has width and height dimensions which are doubled (we skip upsampling in the first block). This is repeated a number of times, with the output of one $\mathrm { R N N } +$ residual group fed as the input to the next group, until the output tensors have the desired spatial dimensions. We do not reduce over the time dimension when calculating Batch Normalization statistics. This prevents the network from utilizing the Batch Normalization layers to pass information between timesteps.
+
+The spatial discriminator $\mathcal { D } _ { S }$ functions almost identically to BigGAN’s discriminator, though an overview of the residual blocks is given in Figure 7 for completeness. A score is calculated for each of the uniformly sampled $k$ frames (we default to $k = 8$ ) and the $\mathcal { D } _ { S }$ output is the sum over per-frame scores. The temporal discriminator $\mathcal { D } _ { T }$ has a similar architecture, but pre-processes the real or generated video with a $2 \times 2$ average-pooling downsampling function $\phi$ . Furthermore, the first two residual blocks of $\mathcal { D } _ { T }$ are 3-D, where every convolution is replaced with a 3-D convolution with a kernel size of $3 \times 3 \times 3$ . The rest of the architecture follows BigGAN (Brock et al., 2019).
+
+# A.3 TRAINING DETAILS
+
+Sampling from DVD-GAN is very efficient, as the core of the generator architecture is a feed-forward convolutional network: two $6 4 \times 6 4$ 48-frame videos can be sampled in less than $1 5 0 \mathrm { m s }$ on a single TPU core. The dual discriminator $\mathcal { D }$ is updated twice for every update of $\mathcal { G }$ (Heusel et al., 2017) and we use Spectral Normalization (Zhang et al., 2018) for all weight layers (approximated by the first singular value) and orthogonal initialization of weights (Saxe et al., 2013). Sampling is carried out using the exponential moving average of $\mathcal { G }$ ’s weights, which is accumulated with decay $\gamma = 0 . 9 9 9 9$ starting after 20,000 training steps. The model is optimized using Adam (Kingma & Ba, 2014) with batch size 512 and a learning rate of $1 \cdot 1 0 ^ { - 4 }$ and $5 { \cdot } \bar { 1 } 0 ^ { - 4 }$ for $\mathcal { G }$ and $\mathcal { D }$ respectively. Class conditioning in $\mathcal { D }$ (Miyato & Koyama, 2018) is projection-based whereas $\mathcal { G }$ relies on class-conditional Batch Normalization (Ioffe & Szegedy, 2015; De Vries et al., 2017; Dumoulin et al., 2017): equivalent to standard Batch Normalization without a learned scale and offset, followed by an elementwise affine transformation where each parameter is a function of the noise vector and class conditioning.
+
+# A.4 FID FOR KINETICS-600 SYNTHESIS
+
+The FID we use for Synthesis on Kinetics-600 is calculated exactly as Fréchet Video Distance (Unterthiner et al., 2018) except that we use a different feature network: an I3D trained on Kinetics-600 (as opposed to the network trained on Kinetics-400 in FVD) and features from the final hidden layer instead of the logits. This metric can be implemented as a small change from the publically available FVD code (Google, 2019) by changing the name of the TF-Hub module to ’https://tfhub.dev/deepmind/i3d-kinetics-600/1’ and loading the tensor named ’RGB/inception_i3d/Logits/AvgPool3D’ from the resulting graph.
+
+# A.5 ARCHITECTURE EXTENSION TO VIDEO PREDICTION
+
+In order to provide results on future video prediction problems we describe a simple modification to DVD-GAN to facilitate the added conditioning. A diagram of the extended model is in Figure 8.
+
+![](images/1c5bc638de65612842638e42398458dcab82dea60e25561b2716a14decf2930c.jpg)  
+Figure 8: An architecture diagram describing the changes for the frame conditional model.
+
+![](images/972300bd4a0636857f606053d10d2722bb8de63b94b1ab68e1bfd6cd6e6dcd20.jpg)  
+Figure 9: Three video samples from a prediction model trained on the BAIR robot pushing dataset. Each row is a separate video, the leftmost column is a (true) conditioning frame.
+
+Given $C$ conditioning frames, our modified DVD-GAN- $F P$ passes each frame separately through a deep residual network identical to $\mathcal { D } _ { S }$ . The (near) symmetric design of $\mathcal { G }$ and $\mathcal { D } _ { S }$ ’s residual blocks mean that each output from a $\mathcal { D }$ -style residual block has a corresponding intermediate tensor in $\mathcal { G }$ of the same spatial resolution. After each block the resulting features for each conditioning frame are stacked in the channel dimension and passed through a $3 \times 3$ convolution and ReLU activation. The resulting tensor is used as the initial state for the Convolutional GRU in the corresponding block in $\mathcal { G }$ . Note that the frame conditioning stack reduces spatial resolution while $\mathcal { G }$ increases resolution. Therefore the smallest features of the conditioning frames (which have been through the most layers) are input earliest in $\mathcal { G }$ and the larger features (which have been through less processing) are input to $\mathcal { G }$ towards the end. $\mathcal { D } _ { T }$ operates on the concatenation of the conditioning frames and the output of $\mathcal { G }$ , meaning that it does not receive any extra information detailing that the first $C$ frames are special. However to reduce wasted computation we do not sample the first $C$ frames for $\mathcal { D } _ { S }$ on real or generated data. This technically means that $D _ { S }$ will never see the first few frames from real videos at full resolution, but this was not an issue in our experiments. Finally, our video prediction variant does not condition on any class information, allowing us to directly compare with prior art. This is achieved by settling the class id of all samples to 0.
+
+# B FURTHER EXPERIMENTS
+
+# B.1 UCF-101
+
+UCF-101 (Soomro et al., 2012) is a dataset of 13,320 videos of human actions across 101 classes that has previously been used for video synthesis and prediction (Saito et al., 2017; Saito & Saito, 2018; Tulyakov et al., 2018). In this case, DVD-GAN is not conditioned on class labels to make our results comparable with prior work. This is achieved by setting the class labels of all input samples to 0. We report Inception Score (IS) calculated with a C3D network (Tran et al., 2015)
+
+![](images/c66d3fb6922fc73f34e3f6b3729820b31c64bc1e26c4f66335ba2d99192c76d3.jpg)  
+Figure 10: The first frames of interpolations between UCF-101 samples. Each row is a separate interpolation. Contrast with samples in Appendix D.2.
+
+for quantitative comparison with prior work.4 This evaluation is performed by re-scaling the video to $1 2 8 \times 1 2 8$ , normalizing the input features based on mean statistics of the ground truth dataset, then taking a $1 1 2 \times 1 1 2$ center crop and applying C3D. Our model produces samples with an IS of 27.38, significantly outperforming the state of the art (see Table 2). The DVD-GAN architecture on UCF-101 is identical to the model used for Kinetics, and is trained on 16-frame $1 2 8 \times 1 2 8$ clips from UCF-101.
+
+The lack of class information does hurt the performance of DVD-GAN, and training on UCF-101 with class labels leads to an improved model with an Inception Score of 32.97. This is directly comparable to Conditional TGAN Saito et al. (2017) which achieved an IS of 15.83 and is close to the IS reported for the ground truth data ( 34.49). However we note than many more recent video generation papers do not test in this regime. It is worth mentioning that our improved score is, at least partially, due to memorization of the training data. In Figure 10 we show interpolation samples from our best UCF-101 model. Like interpolations in Appendix D.2, we sample 2 latents (left and rightmost columns) and show samples from the linear interpolation in latent space along each row. Here we show 4 such interpolations (the first frame from each video). Unlike Kinetics-600 interpolations, which smoothly transition from one sample to the other, we see abrupt jumps in the latent space between highly distinct samples, and little intra-video diversity between samples in each group. It can be further seen that some generated samples highly correlate with samples from the training set.
+
+We show this both as a failure of the Inception Score metric, the commonly reported value for classconditional video synthesis on UCF-101, but also as strong signal that UCF-101 is not a complex or diverse enough dataset to facilitate interesting video generation. Each class is relatively small, and reuse of clips from shared underlying videos means that the intra-class diversity can be restricted to just a handful of videos per class. This suggests the need for larger, more diverse and challenging datasets for generative video modelling, and we believe that Kinetics-600 provides a better benchmark for this task.
+
+# C MISCELLANEOUS EXPERIMENTS
+
+Here we detail a number of modifications or miscellaneous results we experimented with which did not produce a conclusive result.
+
+• We experimented with several variations of normalization which do not require calculating statistics over a batch of data. Group Normalization (Wu & He, 2018) performed best, almost on a par with (but worse than) Batch Normalization. We further tried Layer Normalization (Lei Ba et al., 2016), Instance Normalization (Ulyanov et al., 2016), and no normalization, but found that these significantly underperformed Batch Normalization.
+
+• We found that removing the final Batch Normalization in $\mathcal { G }$ , which occurs after the ResNet and before the final convolution, caused a catastrophic failure in learning. Interestingly, just removing the Batch Normalization layers within $\mathcal { G }$ ’s residual blocks still led to good (though slightly worse) generative models. In particular, variants without Batch Normalization in the residual blocks often achieve significantly higher IS (up to 110.05 for $6 4 \times 6 4 ~ 1 2$ frame samples – twice normal). But these models had substantially worse FID scores (1.22 for the aforementioned model) – and produced qualitatively worse video samples.
+
+• Early variants of DVD-GAN contained Batch Normalization which normalized over all frames of all batch elements. This gave $\mathcal { G }$ an extra channel to convey information across time. It took advantage of this, with the result being a model which required batch statistics in order to produce good samples. We found that the version which normalizes over timesteps independently worked just as well and without the dependence on statistics.
+
+• Models based on the residual blocks of BigGAN-deep trained faster (in wall clock time) but slower with regards to metrics, and struggled to reach the accuracy of models based on BigGAN’s residual blocks.
+
+D GENERATED SAMPLES
+
+It is difficult to accurately convey complicated generated video through still frames. Where provided, we recommend readers view the generated videos themselves via the provided links. We refer to videos within these batches by row/column number where the video in the 0th row and column is in the top left corner.
+
+D.1 SYNTHESIS SAMPLES
+
+![](images/94ff8771d2779ba74349cf5c682a7c411890625c34fccd663ccff2f8dadacbfc.jpg)  
+Figure 11: The first frames from a random batch of samples from DVD-GAN trained on 12 frames of $6 4 \times 6 4$ Kinetics-600. Full samples at https://drive.google.com/file/d/ 155F1lkHA5fMAd7k4W3CQvTsi1eKQDhGb/view?usp $^ { 1 = }$ sharing.
+
+![](images/ba4ac0ed5a88b2078f70859d40fd357a2be1a1ebc52c488c347b482e7845eb98.jpg)  
+Figure 12: The first frames from a random batch of samples from DVD-GAN trained on 48 frames of $6 4 \times 6 4$ Kinetics-600. Full samples at https://drive.google.com/file/d/ 1FjOQYdUuxPXvS8yeOhXdPQMapUQaklLi/view?usp $^ { 1 = }$ sharing.
+
+![](images/b955570d7e0b96214e40ad222dd8865698a3a930c1eac584e86f5182deb65aca.jpg)  
+Figure 13: The first frames from a random batch of samples from DVD-GAN trained on 12 frames of $1 2 8 \times 1 2 8$ Kinetics-600. Full samples at https://drive.google.com/file/ d/165Yxuvvu3viOy-39LhhSDGtczbWphj_i/view?usp $\mid =$ sharing
+
+![](images/d7bf35390195b9b19ead1dbb085b7bb784ca5644655d4df1fd3f9e784d2c1c8e.jpg)  
+Figure 14: The first frames from a random batch of samples from DVD-GAN trained on 48 frames of $1 2 8 \times 1 2 8$ Kinetics-600. Full samples at https://drive.google.com/file/ d/1P8SsWEGP6tEGPPNPH-iVycOlN6vpIgE8/view?usp $\mid =$ sharing. The sample in row 1, column 5 is a stereotypical example of a degenerate sample occasionally produced by DVD-GAN.
+
+![](images/1c617b1d9318ce41a070702225dab76601a5204b981f05962fe6381dad922e97.jpg)  
+Figure 15: The first frames from a random batch of samples from DVD-GAN trained on 12 frames of $2 5 6 \times 2 5 6$ Kinetics-600. Full samples at https://drive.google.com/file/ d/1RGRVKCpVaG8z3p9GBCamRk4apiIR7jUc/view?usp $^ { 1 = }$ sharing.
+
+![](images/91b71faf533db6ba61443412baec9781b80a516fa2acfefdc635e2f55ea46d31.jpg)  
+Figure 16: The first frames from a random batch of samples from DVD-GAN trained on UCF-101. Full samples at https://drive.google.com/file/d/ 1VVLF3bQLyfKtIiSxaKWKq5qFRHmv5EVW/view?usp $^ { 1 = }$ sharing.
+
+# D.2 INTERPOLATION SAMPLES
+
+We expect $\mathcal { G }$ to produce samples of higher quality from latents near the mean of the distribution (zero). This is the idea behind the Truncation Trick (Brock et al., 2019). Like BigGAN, we find that DVD-GAN is amenable to truncation. We also experiment with interpolations in the latent space and in the class embedding. In both cases, interpolations are evidence that $\mathcal { G }$ has learned a relatively smooth mapping from the latent space to real videos: this would be impossible for a network that has only memorized the training data, or which is only capable of generating a few exemplars per class. Note that while all latent vectors along an interpolation are valid (and therefore $\mathcal { G }$ should produce a reasonable sample), at no point during training is $\mathcal { G }$ asked to generate a sample halfway between two classes. Nevertheless $\mathcal { G }$ is able to interpolate between even very distinct classes.
+
+![](images/f318244709131bb46a8a172452daa8bb6c9d396662f3498e437390bf38aee8e1.jpg)  
+Figure 17: An example intra-class interpolation. Each column is a separate video (the vertical axis is the time dimension). The left and rightmost columns are randomly sampled latent vectors and are generated under a shared class. Columns in between represent videos generated under the same class across the linear interpolation between the two random samples. Note the smooth transition between videos at all six timesteps displayed here.
+
+![](images/046de18f772d7dd241b13bc673a77bf8afc09dfd94c3ce1faa2cf5ef6578aed4.jpg)  
+Figure 18: An example of class interpolation. As before, each column is a sequence of timesteps of a single video. Here, we sample a single latent vector, and the left and rightmost columns represent generating a video of that latent under two different classes. Columns in between represent videos of that same latent generated across an interpolation of the class embedding. Even though at no point has DVD-GAN been trained on data under an interpolated class, it nevertheless produces reasonable samples.

parse/train/Byx91R4twB/Byx91R4twB_content_list.json

@@ -0,0 +1,2142 @@
+[
+    {
+        "type": "text",
+        "text": "ADVERSARIAL VIDEO GENERATION ON COMPLEX DATASETS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            607,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            170,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            234,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Generative models of natural images have progressed towards high fidelity samples by the strong leveraging of scale. We attempt to carry this success to the field of video modeling by showing that large Generative Adversarial Networks trained on the complex Kinetics-600 dataset are able to produce video samples of substantially higher complexity and fidelity than previous work. Our proposed model, Dual Video Discriminator GAN (DVD-GAN), scales to longer and higher resolution videos by leveraging a computationally efficient decomposition of its discriminator. We evaluate on the related tasks of video synthesis and video prediction, and achieve new state-of-the-art Fréchet Inception Distance for prediction for Kinetics600, as well as state-of-the-art Inception Score for synthesis on the UCF-101 dataset, alongside establishing a strong baseline for synthesis on Kinetics-600. ",
+        "bbox": [
+            232,
+            267,
+            766,
+            420
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            448,
+            336,
+            463
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/adc877926138740958977e4f86b2fcca873d05c1b6527e19d41a8b97e5d1037c.jpg",
+        "image_caption": [
+            "Figure 1: Selected frames from videos generated by a DVD-GAN trained on Kinetics-600 at $2 5 6 \\times 2 5 6$ , $1 2 8 \\times 1 2 8$ , and $6 4 \\times 6 4$ resolutions (top to bottom). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            484,
+            823,
+            704
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Modern deep generative models can produce realistic natural images when trained on high-resolution and diverse datasets (Brock et al., 2019; Karras et al., 2018; Kingma & Dhariwal, 2018; Menick & Kalchbrenner, 2019; Razavi et al., 2019). Generation of natural video is an obvious further challenge for generative modeling, but one that is plagued by increased data complexity and computational requirements. For this reason, much prior work on video generation has revolved around relatively simple datasets, or tasks where strong temporal conditioning information is available. ",
+        "bbox": [
+            174,
+            776,
+            825,
+            861
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We focus on the tasks of video synthesis and video prediction (defined in Section 2.1), and aim to extend the strong results of generative image models to the video domain. Building upon the state-of-the-art BigGAN architecture (Brock et al., 2019), we introduce an efficient spatio-temporal decomposition of the discriminator which allows us to train on Kinetics-600 – a complex dataset of natural videos an order of magnitude larger than other commonly used datasets. The resulting model, Dual Video Discriminator GAN (DVD-GAN), is able to generate temporally coherent, high-resolution videos of relatively high fidelity (Figure 1). ",
+        "bbox": [
+            174,
+            867,
+            823,
+            922
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/a2dfb8515504437c7e53d843cc7ee19db4164b306149b5ece9aabdf44ecdcd57.jpg",
+        "image_caption": [
+            "Figure 2: Generated video samples with interesting behavior. In raster-scan order: a) On-screen generated text with further lines appearing.. b) Zooming in on an object. c) Colored detail from a pen being left on paper. d) A generated camera change and return. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            101,
+            825,
+            203
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            280,
+            825,
+            324
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our contributions are as follows: ",
+        "bbox": [
+            174,
+            330,
+            390,
+            344
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• We propose DVD-GAN – a scalable generative model of natural video which produces high-quality samples at resolutions up to $2 5 6 \\times 2 5 6$ and lengths up to 48 frames. • We achieve state of the art for video synthesis on UCF-101 and prediction on Kinetics-600. • We establish class-conditional video synthesis on Kinetics-600 as a new benchmark for generative video modeling, and report DVD-GAN results as a strong baseline. ",
+        "bbox": [
+            215,
+            354,
+            825,
+            434
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 BACKGROUND ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            453,
+            326,
+            469
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 VIDEO SYNTHESIS AND PREDICTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            484,
+            470,
+            498
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The exact formulation of the video generation task can differ in the type of conditioning signal provided. At one extreme lies unconditional video synthesis where the task is to generate any video following the training distribution. Another extreme is occupied by strongly-conditioned models, including generation conditioned on another video for content transfer (Bansal et al., 2018; Zhou et al., 2019), per-frame segmentation masks (Wang et al., 2018a), or pose information (Walker et al., 2017; Villegas et al., 2017b; Yang et al., 2018). In the middle ground there are tasks which are more structured than unconditional generation, and yet are more challenging from a modeling perspective than strongly-conditional generation (which gets a lot of information about the generated video through its input). The objective of class-conditional video synthesis is to generate a video of a given category (e.g., “riding a bike”) while future video prediction is concerned with generation of continuing video given initial frames. These problems differ in several aspects, but share a common requirement of needing to generate realistic temporal dynamics, and in this work we focus on these two problems. ",
+        "bbox": [
+            173,
+            510,
+            825,
+            690
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.2 GENERATIVE ADVERSARIAL NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            707,
+            500,
+            722
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Generative Adversarial Networks (GANs) (Goodfellow et al., 2014) are a class of generative models defined by a minimax game between a Discriminator $\\mathcal { D }$ and a Generator $\\mathcal { G }$ . The original objective was proposed by Goodfellow et al. (2014), and many improvements have since been suggested, mostly targeting improved training stability (Arjovsky et al., 2017; Zhang et al., 2018; Brock et al., 2019; Gulrajani et al., 2017; Miyato et al., 2018). We use the hinge formulation of the objective (Lim & Ye, 2017; Brock et al., 2019) which is optimized by gradient descent $\\overset { \\cdot } { \\rho }$ is the elementwise ReLU function): ",
+        "bbox": [
+            173,
+            732,
+            825,
+            832
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a19cd400427a081be9f5e597ca04787a8c47cd6c595e3f7c9e684121d34d5fb8.jpg",
+        "text": "$$\n\\mathcal D \\colon \\operatorname* { m i n } _ { \\mathcal D } \\underset { x \\sim d a t a ( x ) } { \\mathbb { E } } \\left[ \\rho ( 1 - \\mathcal D ( x ) ) \\right] + \\underset { z \\sim p ( z ) } { \\mathbb { E } } \\left[ \\rho ( 1 + \\mathcal D ( \\mathcal { G } ( z ) ) ) \\right] , \\quad \\mathcal G \\colon \\operatorname* { m a x } _ { \\mathcal G } \\underset { z \\sim p ( z ) } { \\mathbb { E } } \\left[ \\mathcal D ( \\mathcal { G } ( z ) ) \\right] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            192,
+            852,
+            805,
+            885
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "GANs have well-known limitations including a tendency towards limited diversity in generated samples (a phenomenon known as mode collapse) and the difficulty of quantitative evaluation due ",
+        "bbox": [
+            176,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "to the lack of an explicit likelihood measure over the data. Despite these downsides, GANs have produced some of the highest fidelity samples across many visual domains (Karras et al., 2018; Brock et al., 2019). ",
+        "bbox": [
+            174,
+            103,
+            823,
+            145
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.3 KINETICS-600 ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            162,
+            316,
+            178
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Kinetics is a large dataset of 10-second high-resolution YouTube clips (Kay et al., 2017; DeepMind, 2018) originally created for the task of human action recognition. We use the second iteration of the dataset, Kinetics-600 (Carreira et al., 2018), which consists of 600 classes with at least 600 videos per class for a total of around 500,000 videos.1 Kinetics videos are diverse and unconstrained, which allows us to train large models without being concerned with the overfitting that occurs on small datasets with fixed objects interacting in specified ways (Ebert et al., 2017; Blank et al., 2005). Among prior work, the closest dataset (in terms of subject and complexity) which is consistently used is UCF-101 (Soomro et al., 2012). We focus on Kinetics-600 because of its larger size (almost $5 0 \\mathrm { x }$ more videos than UCF-101) and its increased diversity (600 instead of 101 classes – not to mention increased intra-class diversity). Nevertheless for comparison with prior art we train on UCF-101 and achieve a state-of-the-art Inception Score there. Kinetics contains many artifacts expected from YouTube, including cuts (as in Figure 2d), title screens and visual effects. Except when specifically described, we choose frames with stride 2 (meaning we skip every other frame). This allows us to generate videos with more complexity without incurring higher computational cost. ",
+        "bbox": [
+            174,
+            189,
+            825,
+            383
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To the best of our knowledge we are the first to consider generative modelling of the entirety of the Kinetics video dataset2, although a small subset of Kinetics consisting of 4,000 selected and stabilized videos (via a SIFT $^ +$ RANSAC procedure) has been used in at least two prior papers (Li et al., 2018; Balaji et al., 2018). Due to the heavy pre-processing and stabilization present, as well as the sizable reduction in dataset size (two orders of magnitude) we do not consider these datasets comparable to the full Kinetics-600 dataset. ",
+        "bbox": [
+            174,
+            391,
+            825,
+            474
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.4 EVALUATION METRICS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            493,
+            374,
+            507
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Designing metrics for measuring the quality of generative models (GANs in particular) is an active area of research (Sajjadi et al., 2018; Barratt & Sharma, 2018). In this work we report the two most commonly used metrics, Inception Score (IS) (Salimans et al. (2016)) and Fréchet Inception Distance (FID) (Heusel et al., 2017). The standard instantiation of these metrics is intended for generative image models, and uses an Inception model (Szegedy et al., 2016) for image classification or feature extraction. For videos, we use the publicly available Inflated 3D Convnet (I3D) network trained on Kinetics-600 (Carreira & Zisserman, 2017). Our Fréchet Inception Distance is therefore very similar to the Fréchet Video Distance (FVD) (Unterthiner et al., 2018), although our implementation is different and more aligned with the original FID metric.3 More details are in Appendix A.4. ",
+        "bbox": [
+            173,
+            518,
+            825,
+            645
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 DUAL VIDEO DISCRIMINATOR GAN ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            665,
+            509,
+            681
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our primary contribution is Dual Video Discriminator GAN (DVD-GAN), a generative video model of complex human actions built upon the state-of-the-art BigGAN architecture (Brock et al., 2019) while introducing scalable, video-specific generator and discriminator architectures. An overview of the DVD-GAN architecture is given in Figure 3 and a detailed description is in Appendix A.2. Unlike some of the prior work, our generator contains no explicit priors for foreground, background or motion (optical flow); instead, we rely on a high-capacity neural network to learn this in a data-driven manner. While DVD-GAN contains sequential components (RNNs), it is not autoregressive in time or in space. In other words, the pixels of each frame do not directly depend on other pixels in the video, as would be the case for auto-regressive models or models generating one frame at a time. ",
+        "bbox": [
+            173,
+            696,
+            825,
+            823
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Generating long and high resolution videos is a heavy computational challenge: individual samples from Kinetics-600 (just 10 seconds long) contain upwards of 16 million pixels which need to be generated in a consistent fashion. This is a particular challenge to the discriminator. For example, a generated video might contain an object which leaves the field of view and incorrectly returns with a different color. Here, the ability to determine this video is generated is only possible by comparing two different spatial locations across two (potentially distant) frames. Given a video with length $T$ , height $H$ , and width $W$ , discriminators that process the entire video would have to process all $H \\times W \\times T$ pixels – limiting the size of the model and the size of the videos being generated. ",
+        "bbox": [
+            176,
+            830,
+            823,
+            858
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/c630e03b69f5632cb0f1b4fcdd5e6cbe2329d6a917d9c2f34800c987129c3f4f.jpg",
+        "image_caption": [
+            "ResNet Block Figure 3: Simplified architecture diagram of $\\mathcal { G }$ (left) and $\\mathcal { D } _ { S } / \\mathcal { D } _ { T }$ Block (right). More details in A.2. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            99,
+            820,
+            335
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            390,
+            825,
+            473
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 DUAL DISCRIMINATORS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            492,
+            382,
+            506
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "DVD-GAN tackles this scale problem by using two discriminators: a Spatial Discriminator $\\mathcal { D } _ { S }$ and a Temporal Discriminator $\\mathcal { D } _ { T }$ . $\\mathcal { D } _ { S }$ critiques single frame content and structure by randomly sampling $k$ full-resolution frames and judging them individually. We use $k = 8$ and discuss this choice in Section 4.3. $\\mathcal { D } _ { S }$ ’s final score is the sum of the per-frame scores. The temporal discriminator $\\mathcal { D } _ { T }$ must provide $\\mathcal { G }$ with the learning signal to generate movement (something not evaluated by $\\mathcal { D } _ { S }$ ). To make the model scalable, we apply a spatial downsampling function $\\phi ( \\cdot )$ to the whole video and feed its output to $\\mathcal { D } _ { T }$ . We choose $\\phi$ to be $2 \\times 2$ average pooling, and discuss alternatives in Section 4.3. This results in an architecture where the discriminators do not process the entire video’s worth of pixels, $\\mathcal { D } _ { S }$ processes only resolution, this $k \\times H \\times W$ pixels and umber of p $\\mathcal { D } _ { T }$ only  to pr $T \\times \\frac { H } { 2 } \\times \\frac { W } { 2 }$ . For a 48 frame video ato from 786432 to 327680: $1 2 8 \\times 1 2 8$   \na $5 8 \\%$ reduction. Despite this decomposition, the discriminator objective is still able to penalize almost all inconsistencies which would be penalized by a discriminator judging the entire video. $\\mathcal { D } _ { T }$ judges any temporal discrepancies across the entire length of the video, and $\\mathcal { D } _ { S }$ can judge any high resolution details. The only detail the DVD-GAN discriminator objective is unable to reflect is the temporal evolution of pixels within a $2 \\times 2$ window. We have however not noticed this affecting the generated samples in practice. DVD-GAN’s $\\mathcal { D } _ { S }$ is similar to the per-frame discriminator $\\mathcal { D } _ { I }$ in MoCoGAN (Tulyakov et al., 2018). However MoCoGAN’s analog of $\\mathcal { D } _ { T }$ looks at full resolution videos, whereas $\\mathcal { D } _ { S }$ is the only source of learning signal for high-resolution details in DVD-GAN. For this reason, $\\mathcal { D } _ { S }$ is essential when $\\phi$ is not the identity, unlike in MoCoGAN where the additional per-frame discriminator is less crucial. ",
+        "bbox": [
+            174,
+            517,
+            825,
+            795
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            814,
+            330,
+            827
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Generative video modeling is a widely explored problem which includes work on VAEs (Babaeizadeh et al., 2018; Denton & Fergus, 2018; Lee et al., 2018; Hsieh et al., 2018) and recurrent models (Wang et al., 2018b; Finn et al., 2016; Wang et al., 2018c; Byeon et al., 2018), auto-regressive models (Ranzato et al., 2014; Srivastava et al., 2015; Kalchbrenner et al., 2017; Weissenborn et al., 2019), normalizing flows (Kumar et al., 2019), and GANs (Mathieu et al., 2015; Vondrick et al., 2016; Saito et al., 2017; Saito & Saito, 2018). Much prior work considers decompositions which model the texture and spatial consistency of objects separately from their temporal dynamics. One approach is to split $\\mathcal { G }$ into foreground and background models (Vondrick et al., 2016; Spampinato et al., 2018), while another considers explicit or implicit optical flow or motion in either $\\mathcal { G }$ or $\\mathcal { D }$ (Saito et al., 2017; Ohnishi et al., 2018). Other methods decompose the generator (or encoder) to treat concepts like pose, content and motion separately from one another (Denton et al., 2017; Villegas et al., 2017a). Similar to DVD-GAN, MoCoGAN (Tulyakov et al., 2018) discriminates individual frames in addition to a discriminator which operates on fixed-length $K$ -frame slices of the whole video (where $K < T$ ). Though this potentially reduces the number of pixels to discriminate to $( H \\times W ) + ( K \\times H \\times W )$ , Tulyakov et al. (2018) describes discriminating sliding windows, which increases the total number of pixels. Other models follow this approach by discriminating groups of frames (Xie et al., 2018; Sun et al., 2018; Balaji et al., 2018). ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/4f9ff19b1e94ddb46e0d5406dc6163bf997b04b74c8e7e25c020f5ada2cc9adf.jpg",
+        "image_caption": [
+            "Figure 4: Each row is the first frame of 15 videos from a random class, all from the same checkpoint. The classes are: cooking scallops, changing wheel (not on bike), calculating, dribbling basketball. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            102,
+            823,
+            234
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/5108ab2cac78a011bdcfb9ec2f0d5b527d89d5f08bdbbf3f3f367b127993cbdd.jpg",
+        "image_caption": [
+            "Figure 5: All 48 frames (in raster-scan order) from a $6 4 \\times 6 4$ sample from watermelon cutting class. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            313,
+            823,
+            409
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            472,
+            826,
+            625
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "TGANv2 (Saito & Saito, 2018) proposes “adaptive batch reduction” for efficient training, an operation which randomly samples subsets of videos within a batch and temporal subwindows within each video. This operation is applied throughout TGANv2’s $\\mathcal { G }$ , with heads projecting intermediate feature maps directly to pixel space before applying batch reduction, and corresponding discriminators evaluating these lower resolution intermediate outputs. An effect of this choice is that TGANv2 discriminators only evaluate full-length videos at very low resolution. We show in Figure 6 that a similar reduction in DVD-GAN’s resolution when judging full videos leads to a loss in performance. We expect further reduction (towards the resolution at which TGANv2 evaluates the entire length of video) to lead to further degradation of DVD-GAN’s quality. Furthermore, this method is not easily adapted towards models with large batch sizes divided across a number of accelerators, with only a small batch size per replica. ",
+        "bbox": [
+            173,
+            631,
+            825,
+            785
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS AND ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            815,
+            459,
+            832
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "A detailed description of our training setup is in Appendix A.3. Each DVD-GAN was trained on TPU pods (Google, 2018) using between 32 and 512 replicas with an Adam (Kingma & Ba, 2014) optimizer. Video Synthesis models are trained for around 300,000 learning steps, whilst Video Prediction models are trained for up to 1,000,000 steps. Most models took between 12 and 96 hours to train. ",
+        "bbox": [
+            174,
+            853,
+            825,
+            922
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 VIDEO SYNTHESIS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            344,
+            117
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Our primary results concern the problem of Video Synthesis. We provide our results for the UCF-101 and Kinetics-600 datasets. With Kinetics-600 emerging as a new benchmark for generative video modelling, our results establish a strong baseline for future work. ",
+        "bbox": [
+            174,
+            135,
+            825,
+            176
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1.1 KINETICS-600 RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            204,
+            397,
+            218
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/7a3fa6bc6bb8a0c8f03a2353b1ddc787ac8bb4c51e10ca933931b21237fc2918.jpg",
+        "table_caption": [
+            "Table 1: FID/IS for DVD-GAN on Kinetics-600 Video Synthesis. We present the scores of the model taken at the point in training when the best FID was attained. The \"No Truncation\" columns contain the scores obtained without the truncation trick. The \"With Truncation\" columns contain the scores obtained at the truncation level which results in the best Inception Score. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>(#Frames /Resolution)</td><td colspan=\"2\">No Truncation FID (↓) IS (↑)</td><td colspan=\"2\">With Truncation FID (↓) IS (↑)</td></tr><tr><td>12/64 × 64</td><td>0.85</td><td>53.81</td><td>7.13</td><td>187.23</td></tr><tr><td>12/128 × 128</td><td>1.16</td><td>77.45</td><td>13.04</td><td>246.18</td></tr><tr><td>12/256 × 256</td><td>2.05</td><td>62.78</td><td>10.17</td><td>162.44</td></tr><tr><td>48/64 × 64</td><td>13.75</td><td>104.09</td><td>47.86</td><td>264.12</td></tr><tr><td>48/128 × 128</td><td>28.44</td><td>81.41</td><td>45.79</td><td>188.32</td></tr></table>",
+        "bbox": [
+            276,
+            343,
+            722,
+            457
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In Table 1 we show the main result of this paper: benchmarks for Class-Conditional Video Synthesis on Kinetics-600. In this regime, we train a single DVD-GAN on all classes of Kinetics-600, supplying per-sample class information to both $\\mathcal { G }$ and $\\mathcal { D }$ . We consider a range of resolutions and video lengths, and measure Inception Score and Fréchet Inception Distance (FID) for each (as described in Section 2.4). We further measure each model along a truncation curve, which we carry out by calculating FID and IS statistics while varying the standard deviation of the latent vectors between 0 and 1. There is no prior work with which to quantitatively compare these results (for comparative experiments see Section 4.1.2 and Section 4.2.1), but we believe these samples to show a level of fidelity not yet achieved in datasets as complex as Kinetics-600 (see samples from each row in Appendix D.1). Because all videos are resized for the I3D network (to $2 2 4 \\times 2 2 4 )$ ), it is meaningful to compare metrics across equal length videos at different resolutions. Neither IS nor FID are comparable across videos of different lengths, and should be treated as separate metrics. ",
+        "bbox": [
+            174,
+            484,
+            825,
+            651
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Generating longer and larger videos is a more challenging modeling problem, which is conveyed by the metrics (in particular, comparing 12-frame videos across $6 4 \\times 6 4$ , $1 2 8 \\times 1 2 8$ and $2 5 6 \\times 2 5 6$ resolutions). Nevertheless, DVD-GAN is able to generate plausible videos at all resolutions and with length spanning up to 4 seconds (48 frames). As can be seen in Appendix D.1, smaller videos display high quality textures, object composition and movement. At higher resolutions, generating coherent objects becomes more difficult (movement consists of a much larger number of pixels), but high-level details of the generated scenes are still extremely coherent, and textures (even complicated ones like a forest backdrop in Figure 1a) are generated well. It is further worth noting that the 48-frame models do not see more high resolution frames than the 12-frame model (due to the fixed choice of $k = 8$ described in Section 3.1), yet nevertheless learn to generate high resolution images. ",
+        "bbox": [
+            173,
+            657,
+            825,
+            797
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1.2 VIDEO SYNTHESIS ON UCF-101 ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            824,
+            452,
+            839
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We further verify our results by testing the same model on UCF-101 (Soomro et al., 2012), a smaller dataset of 13,320 videos of human actions across 101 classes that has previously been used for video synthesis and prediction (Saito et al., 2017; Saito & Saito, 2018; Tulyakov et al., 2018). Our model produces samples with an IS of 27.38, significantly outperforming the state of the art (see Table 2 for quantitative comparison and Appendix B.1 for more details). ",
+        "bbox": [
+            174,
+            853,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/143b4d4b4bb4dbe9dcbcec8fc9c868412646e5395e9dc3830ffb67ba8f133344.jpg",
+        "table_caption": [
+            "Table 2: IS on UCF-101 without class conditioning. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>IS (↑)</td></tr><tr><td>VGAN (Vondrick et al., 2016)</td><td>8.31 ± .09</td></tr><tr><td>TGAN (Saito et al., 2017)</td><td>11.85 ± .07</td></tr><tr><td>MoCoGAN (Tulyakov et al., 2018)</td><td>12.42 ± .03</td></tr><tr><td>ProgressiveVGAN (Acharya et al., 2018)</td><td>14.56 ± .05</td></tr><tr><td>TGANv2 (Saito &amp; Saito,2018)</td><td>24.34 ± .35</td></tr><tr><td>DVD-GAN (ours)</td><td>27.38 ± 0.53</td></tr></table>",
+        "bbox": [
+            176,
+            127,
+            573,
+            241
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/4107287d43756cd001ccac7d981c34a71ace3a8d89e4d4ce22c4ebe89faa34d2.jpg",
+        "table_caption": [
+            "Table 3: FVD on BAIR. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>FVD (↓)</td></tr><tr><td>SVP-FP CDNA</td><td>315.5</td></tr><tr><td>SV2P</td><td>296.5 262.5</td></tr><tr><td>SAVP</td><td>116.4</td></tr><tr><td>DVD-GAN-FP (ours)</td><td>109.8</td></tr><tr><td>Video Transformer</td><td>94±2</td></tr></table>",
+        "bbox": [
+            589,
+            126,
+            828,
+            239
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/e43f1629b966846439958e776407beca12b46e26857a90c91b97b77ad9e3eb6f.jpg",
+        "table_caption": [
+            "Table 4: DVD-GAN-FP’s FVD scores on Video Prediction for 16 frames of Kinetics-600 without frame skipping. The final row represents a Video Synthesis model generating 16 frames. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>Training Set FVD (↓)</td><td>Test Set FVD (↓)</td></tr><tr><td>Video Transformer (Weissenborn et al.,2019)</td><td></td><td>170±5</td></tr><tr><td>DVD-GAN-FP</td><td>68.66 ± 0.78</td><td>69.15 ± 1.16</td></tr><tr><td>DVD-GAN</td><td>32.3 ± 0.82</td><td>31.1 ± 0.56</td></tr></table>",
+        "bbox": [
+            191,
+            309,
+            805,
+            388
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 FUTURE VIDEO PREDICTION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            429,
+            415,
+            444
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Future Video Prediction is the problem of generating a sequence of frames which directly follow from one (or a number) of initial conditioning frames. Both this and video synthesis require $\\mathcal { G }$ to learn to produce realistic scenes and temporal dynamics, however video prediction further requires $\\mathcal { G }$ to analyze the conditioning frames and discover elements in the scene which will evolve over time. In this section, we use the Fréchet Video Distance exactly as Unterthiner et al. (2018): using the logits of an I3D network trained on Kinetics-400 as features. This allows for direct comparison to prior work. Our model, DVD-GAN-FP (Frame Prediction), is slightly modified to facilitate the changed problem, and details of these changes are given in Appendix A.5. ",
+        "bbox": [
+            174,
+            462,
+            825,
+            574
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2.1 FRAME-CONDITIONAL KINETICS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            607,
+            457,
+            621
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "For direct comparison with concurrent work on autoregressive video models (Weissenborn et al., 2019) we consider the generation of 11 frames of Kinetics-600 at $6 4 \\times 6 4$ resolution conditioned on 5 frames, where the videos for training are not taken with any frame skipping. We show results for all these cases in Table 4. Our frame-conditional model DVD-GAN- ${ \\pmb F } { \\pmb P }$ outperforms the prior work on frame-conditional prediction for Kinetics. The final row labeled DVD-GAN corresponds to 16-frame class-conditional Video Synthesis samples, generated without frame conditioning and without frame skipping. The FVD of this video synthesis model is notably better. ",
+        "bbox": [
+            174,
+            638,
+            825,
+            736
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "On the one hand, we hypothesize that the synthesis model has an easier generative task: it can choose to generate (relatively) simple samples for each class, rather than be forced to continue frames taken from videos which are class outliers, or contain more complicated details. On the other hand, a certain portion of the FID/FVD metric undoubtedly comes from the distribution of objects and backgrounds present in the dataset, and so it seems that the prediction model should have a handicap in the metric by being given the ground truth distribution of backgrounds and objects with which to continue videos. The synthesis model’s improved performance on this task seems to indicate that the advantage of being able to select videos to generate is greater than the advantage of having a ground truth distribution of starting frames. This result is un-intuitive, as the frame conditional model has access to strictly more information about the data distribution it is trying to recover compared to the synthesis model (despite the fact that the two models are being trained by an identical objective). This experiment favors the synthesis model for FVD, but we highlight that other models or other metrics might produce the opposite ordering. ",
+        "bbox": [
+            174,
+            743,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/329ac23a7eb4e35037e2a45da62a239de0af7a5ed97b9145e0822c627cb65e8d.jpg",
+        "image_caption": [
+            "Figure 6: The effect of $\\phi$ in $\\mathcal { D } _ { T }$ (left two) and $k$ in $\\mathcal { D } _ { S }$ (right two). FID is similar for any choice of $\\phi$ , while IS declines as downsampling increases. Increasing $k$ improves both with diminishing returns. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            101,
+            825,
+            203
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.2.2 BAIR ROBOT PUSHING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            270,
+            392,
+            284
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We further test future video prediction on the single-class BAIR Robot Pushing Dataset (Ebert et al., 2017), a dataset of stationary videos of a robot arm moving around a set of changing objects. In order for direct comparison with previous results reported in Unterthiner et al. (2018), we consider generating 15 frames conditioned on a single starting frame. Like on prediction with Kinetics, we report FVD exactly as in Unterthiner et al. (2018), with ground truth statistics and conditioning frames taken from the 256-video dev set. Results are reported in Table 3. Scores are taken from Unterthiner et al. (2018). DVD-GAN-FP outperforms all prior adversarial models trained on this dataset, but performs slightly worse than Video Transformer, a concurrently developed autoregressive model Weissenborn et al. (2019). Samples from DVD-GAN-FP on BAIR are given in Figure 9. ",
+        "bbox": [
+            174,
+            294,
+            825,
+            419
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.3 DUAL DISCRIMINATOR INPUT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            436,
+            421,
+            450
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We analyze several choices for $k$ (the number of frames per sample in the input to $\\mathcal { D } _ { S }$ ) and $\\phi$ (the downsampling function for $\\mathcal { D } _ { T }$ ). We expect setting $\\phi$ to the identity or $k = T$ to result in the best model, but we are interested in the maximally compressive $k$ and $\\phi$ that reduce discriminator input size (and the amount of computation), while still producing a high quality generator. For $\\phi$ , we consider: $2 \\times 2$ and $4 \\times 4$ average pooling, the identity (no downsampling), as well as a $\\phi$ which takes a random half-sized crop of the input video (as in Saito & Saito (2018)). Results can be seen in Figure 6. For each ablation, we train three identical DVD-GANs with different random initializations on 12-frame clips of Kinetics-600 at $6 4 \\times 6 4$ resolution for 100,000 steps. We report mean and standard deviation (via the error bars) across each group for the whole training period. For $k$ , we consider 1, 2, 8 and 10 frames. We see diminishing effect as $k$ increases, so settle on $k = 8$ . We note the substantially reduced IS of $4 \\times 4$ downsampling as opposed to $2 \\times 2$ , and further note that taking half-sized crops (which results in the same number of pixels input to $\\mathcal { D } _ { T }$ as $2 \\times 2$ pooling) is also notably worse. ",
+        "bbox": [
+            173,
+            463,
+            825,
+            642
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            662,
+            318,
+            679
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We approached the challenging problem of modeling natural video by introducing a GAN capable of capturing the complexity of a large video dataset. We showed that on UCF-101 and frame-conditional Kinetics-600 it quantitatively achieves the new state of the art, alongside qualitatively producing video synthesis samples with high complexity and diversity. We further wish to emphasize the benefit of training generative models on large and complex video datasets, such as Kinetics-600, and envisage the strong baselines we established on this dataset with DVD-GAN will be used as a reference point by the generative modeling community moving forward. While much remains to be done before realistic videos can be consistently generated in an unconstrained setting, we believe DVD-GAN is a step in that direction. ",
+        "bbox": [
+            174,
+            694,
+            825,
+            820
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            848,
+            285,
+            863
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Dinesh Acharya, Zhiwu Huang, Danda Pani Paudel, and Luc Van Gool. Towards high resolution video generation with progressive growing of sliced Wasserstein GANs. arXiv:1810.02419, 2018. ",
+        "bbox": [
+            174,
+            872,
+            825,
+            900
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Martin Arjovsky, Soumith Chintala, and Léon Bottou. Wasserstein GAN. arXiv:1701.07875, 2017. ",
+        "bbox": [
+            174,
+            909,
+            823,
+            922
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Mohammad Babaeizadeh, Chelsea Finn, Dumitru Erhan, Roy H Campbell, and Sergey Levine. Stochastic variational video prediction. ICLR, 2018. ",
+        "bbox": [
+            171,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yogesh Balaji, Martin Renqiang Min, Bing Bai, Rama Chellappa, and Hans Peter Graf. Tfgan: Improving conditioning for text-to-video synthesis. 2018. ",
+        "bbox": [
+            174,
+            141,
+            823,
+            171
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Nicolas Ballas, Li Yao, Chris Pal, and Aaron Courville. Delving deeper into convolutional networks for learning video representations. arXiv:1511.06432, 2015. ",
+        "bbox": [
+            173,
+            179,
+            823,
+            209
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Aayush Bansal, Shugao Ma, Deva Ramanan, and Yaser Sheikh. Recycle-GAN: Unsupervised video retargeting. In ECCV, September 2018. ",
+        "bbox": [
+            173,
+            218,
+            825,
+            247
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Shane Barratt and Rishi Sharma. A note on the Inception Score. arXiv:1801.01973, 2018. ",
+        "bbox": [
+            169,
+            256,
+            764,
+            272
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Moshe Blank, Lena Gorelick, Eli Shechtman, Michal Irani, and Ronen Basri. Actions as space-time shapes. In ICCV, 2005. ",
+        "bbox": [
+            173,
+            281,
+            821,
+            310
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Andrew Brock, Jeff Donahue, and Karen Simonyan. Large scale GAN training for high fidelity natural image synthesis. ICLR, 2019. ",
+        "bbox": [
+            173,
+            319,
+            823,
+            349
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Wonmin Byeon, Qin Wang, Rupesh Kumar Srivastava, and Petros Koumoutsakos. Contextvp: Fully context-aware video prediction. In Proceedings of the European Conference on Computer Vision (ECCV), pp. 753–769, 2018. ",
+        "bbox": [
+            173,
+            357,
+            825,
+            401
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Joao Carreira and Andrew Zisserman. Quo vadis, action recognition? A new model and the Kinetics dataset. In ICCV, 2017. ",
+        "bbox": [
+            173,
+            410,
+            823,
+            439
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Joao Carreira, Eric Noland, Andras Banki-Horvath, Chloe Hillier, and Andrew Zisserman. A short note about Kinetics-600. arXiv:1808.01340, 2018. ",
+        "bbox": [
+            173,
+            448,
+            823,
+            478
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Harm De Vries, Florian Strub, Jérémie Mary, Hugo Larochelle, Olivier Pietquin, and Aaron C Courville. Modulating early visual processing by language. In NeurIPS, 2017. ",
+        "bbox": [
+            174,
+            486,
+            821,
+            516
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "DeepMind, 2018. Kinetics. https://deepmind.com/research/open-source/ open-source-datasets/kinetics/. Accessed: 2019. ",
+        "bbox": [
+            174,
+            525,
+            821,
+            554
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Emily Denton and Rob Fergus. Stochastic video generation with a learned prior. ICML, 2018. ",
+        "bbox": [
+            173,
+            563,
+            790,
+            579
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Emily L Denton et al. Unsupervised learning of disentangled representations from video. In Advances in neural information processing systems, pp. 4414–4423, 2017. ",
+        "bbox": [
+            171,
+            588,
+            825,
+            617
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Vincent Dumoulin, Jonathon Shlens, and Manjunath Kudlur. A learned representation for artistic style. In ICLR, 2017. ",
+        "bbox": [
+            173,
+            626,
+            825,
+            656
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Frederik Ebert, Chelsea Finn, Alex X Lee, and Sergey Levine. Self-supervised visual planning with temporal skip connections. arXiv:1710.05268, 2017. ",
+        "bbox": [
+            174,
+            665,
+            823,
+            694
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Chelsea Finn, Ian Goodfellow, and Sergey Levine. Unsupervised learning for physical interaction through video prediction. In Advances in neural information processing systems, pp. 64–72, 2016. ",
+        "bbox": [
+            173,
+            703,
+            825,
+            733
+        ],
+        "page_idx": 8
+    },
+    {
+        "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 NeurIPS, 2014. ",
+        "bbox": [
+            173,
+            741,
+            825,
+            771
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Google, 2018. Cloud tpu. https://cloud.google.com/tpu/. Accessed: 2019. ",
+        "bbox": [
+            173,
+            780,
+            753,
+            796
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Google, 2019. Fvd. https://github.com/google-research/google-research/ tree/master/frechet_video_distance. Accessed: 2019. ",
+        "bbox": [
+            173,
+            805,
+            823,
+            834
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ishaan Gulrajani, Faruk Ahmed, Martin Arjovsky, Vincent Dumoulin, and Aaron C Courville. Improved training of Wasserstein GANs. In NeurIPS, 2017. ",
+        "bbox": [
+            171,
+            843,
+            825,
+            872
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Martin Heusel, Hubert Ramsauer, Thomas Unterthiner, Bernhard Nessler, and Sepp Hochreiter. GANs trained by a two time-scale update rule converge to a local nash equilibrium. In NeurIPS, 2017. ",
+        "bbox": [
+            174,
+            882,
+            826,
+            922
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jun-Ting Hsieh, Bingbin Liu, De-An Huang, Li Fei-Fei, and Juan Carlos Niebles. Learning to decompose and disentangle representations for video prediction. In NeurIPS. 2018. ",
+        "bbox": [
+            171,
+            103,
+            825,
+            133
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. arXiv:1502.03167, 2015. ",
+        "bbox": [
+            173,
+            141,
+            823,
+            171
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nal Kalchbrenner, Aäron van den Oord, Karen Simonyan, Ivo Danihelka, Oriol Vinyals, Alex Graves, and Koray Kavukcuoglu. Video pixel networks. In ICML, 2017. ",
+        "bbox": [
+            173,
+            179,
+            825,
+            209
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tero Karras, Samuli Laine, and Timo Aila. A style-based generator architecture for generative adversarial networks. arXiv:1812.04948, 2018. ",
+        "bbox": [
+            173,
+            217,
+            825,
+            247
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Will Kay, Joao Carreira, Karen Simonyan, Brian Zhang, Chloe Hillier, Sudheendra Vijayanarasimhan, Fabio Viola, Tim Green, Trevor Back, Paul Natsev, Mustafa Suleyman, and Andrew Zisserman. The Kinetics human action video dataset. arXiv:1705.06950, 2017. ",
+        "bbox": [
+            179,
+            256,
+            823,
+            299
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv:1412.6980, 2014. ",
+        "bbox": [
+            174,
+            308,
+            823,
+            338
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Durk P Kingma and Prafulla Dhariwal. Glow: Generative flow with invertible 1x1 convolutions. In NeurIPS, 2018. ",
+        "bbox": [
+            176,
+            345,
+            823,
+            376
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Manoj Kumar, Mohammad Babaeizadeh, Dumitru Erhan, Chelsea Finn, Sergey Levine, Laurent Dinh, and Durk Kingma. VideoFlow: A flow-based generative model for video. arXiv:1903.01434, 2019. ",
+        "bbox": [
+            174,
+            383,
+            825,
+            426
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alex X Lee, Richard Zhang, Frederik Ebert, Pieter Abbeel, Chelsea Finn, and Sergey Levine. Stochastic adversarial video prediction. arXiv:1804.01523, 2018. ",
+        "bbox": [
+            173,
+            435,
+            825,
+            467
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jimmy Lei Ba, Jamie Ryan Kiros, and Geoffrey E Hinton. Layer normalization. arXiv:1607.06450, 2016. ",
+        "bbox": [
+            174,
+            473,
+            823,
+            503
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yitong Li, Martin Renqiang Min, Dinghan Shen, David Carlson, and Lawrence Carin. Video generation from text. In Thirty-Second AAAI Conference on Artificial Intelligence, 2018. ",
+        "bbox": [
+            174,
+            512,
+            823,
+            542
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jae Hyun Lim and Jong Chul Ye. Geometric GAN. arXiv:1705.02894, 2017. ",
+        "bbox": [
+            173,
+            550,
+            683,
+            566
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Michael Mathieu, Camille Couprie, and Yann LeCun. Deep multi-scale video prediction beyond mean square error. arXiv:1511.05440, 2015. ",
+        "bbox": [
+            176,
+            575,
+            826,
+            604
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jacob Menick and Nal Kalchbrenner. Generating high fidelity images with subscale pixel networks and multidimensional upscaling. In ICLR, 2019. ",
+        "bbox": [
+            171,
+            613,
+            825,
+            643
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Takeru Miyato and Masanori Koyama. cGANs with projection discriminator. arXiv:1802.05637, 2018. ",
+        "bbox": [
+            173,
+            651,
+            825,
+            681
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Takeru Miyato, Toshiki Kataoka, Masanori Koyama, and Yuichi Yoshida. Spectral normalization for generative adversarial networks. arXiv:1802.05957, 2018. ",
+        "bbox": [
+            171,
+            689,
+            825,
+            719
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Katsunori Ohnishi, Shohei Yamamoto, Yoshitaka Ushiku, and Tatsuya Harada. Hierarchical video generation from orthogonal information: Optical flow and texture. In AAAI, 2018. ",
+        "bbox": [
+            173,
+            728,
+            823,
+            758
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Marc’Aurelio Ranzato, Arthur Szlam, Joan Bruna, Michaël Mathieu, Ronan Collobert, and Sumit Chopra. Video (language) modeling: a baseline for generative models of natural videos. arXiv:1412.6604, 2014. ",
+        "bbox": [
+            176,
+            766,
+            825,
+            809
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ali Razavi, Aaron van den Oord, and Oriol Vinyals. Generating diverse high-fidelity images with VQ-VAE-2. arXiv preprint arXiv:1906.00446, 2019. ",
+        "bbox": [
+            171,
+            818,
+            823,
+            848
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Masaki Saito and Shunta Saito. TGANv2: Efficient training of large models for video generation with multiple subsampling layers. arXiv:1811.09245, 2018. ",
+        "bbox": [
+            173,
+            857,
+            823,
+            886
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Masaki Saito, Eiichi Matsumoto, and Shunta Saito. Temporal generative adversarial nets with singular value clipping. In ICCV, 2017. ",
+        "bbox": [
+            174,
+            895,
+            820,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Mehdi SM Sajjadi, Olivier Bachem, Mario Lucic, Olivier Bousquet, and Sylvain Gelly. Assessing generative models via precision and recall. In NeurIPS, 2018. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tim Salimans, Ian Goodfellow, Wojciech Zaremba, Vicki Cheung, Alec Radford, and Xi Chen. Improved techniques for training GANs. In NeurIPS, 2016. ",
+        "bbox": [
+            173,
+            141,
+            823,
+            171
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Andrew M Saxe, James L McClelland, and Surya Ganguli. Exact solutions to the nonlinear dynamics of learning in deep linear neural networks. arXiv:1312.6120, 2013. ",
+        "bbox": [
+            171,
+            180,
+            823,
+            209
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Khurram Soomro, Amir Roshan Zamir, and Mubarak Shah. UCF101: A dataset of 101 human actions classes from videos in the wild. arXiv:1212.0402, 2012. ",
+        "bbox": [
+            173,
+            219,
+            821,
+            248
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Concetto Spampinato, Sergio Palazzo, P D’Oro, Francesca Murabito, Daniela Giordano, and M Shah. VOS-GAN: Adversarial learning of visual-temporal dynamics for unsupervised dense prediction in videos. arXiv:1803.09092, 2018. ",
+        "bbox": [
+            174,
+            257,
+            825,
+            301
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nitish Srivastava, Elman Mansimov, and Ruslan Salakhutdinov. Unsupervised learning of video representations using LSTMs. In ICML, 2015. ",
+        "bbox": [
+            173,
+            310,
+            823,
+            340
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ximeng Sun, Huijuan Xu, and Kate Saenko. A two-stream variational adversarial network for video generation. arXiv:1812.01037, 2018. ",
+        "bbox": [
+            174,
+            349,
+            823,
+            378
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ilya Sutskever, James Martens, and Geoffrey E Hinton. Generating text with recurrent neural networks. In ICML, 2011. ",
+        "bbox": [
+            173,
+            387,
+            825,
+            417
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Christian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jonathon Shlens, and Zbigniew Wojna. Rethinking the Inception architecture for computer vision. In CVPR, 2016. ",
+        "bbox": [
+            171,
+            426,
+            825,
+            457
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Seiya Tokui, Kenta Oono, Shohei Hido, and Justin Clayton. Chainer: a next-generation open source framework for deep learning. In Workshop on Systems for ML and Open Source Software at NeurIPS, 2015. ",
+        "bbox": [
+            174,
+            465,
+            823,
+            508
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Du Tran, Lubomir Bourdev, Rob Fergus, Lorenzo Torresani, and Manohar Paluri. Learning spatiotemporal features with 3D convolutional networks. In ICCV, 2015. ",
+        "bbox": [
+            171,
+            518,
+            825,
+            547
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sergey Tulyakov, Ming-Yu Liu, Xiaodong Yang, and Jan Kautz. MoCoGAN: Decomposing motion and content for video generation. In CVPR, 2018. ",
+        "bbox": [
+            174,
+            556,
+            823,
+            587
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Dmitry Ulyanov, Andrea Vedaldi, and Victor Lempitsky. Instance normalization: The missing ingredient for fast stylization. arXiv:1607.08022, 2016. ",
+        "bbox": [
+            173,
+            595,
+            821,
+            626
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Thomas Unterthiner, Sjoerd van Steenkiste, Karol Kurach, Raphael Marinier, Marcin Michalski, and Sylvain Gelly. Towards accurate generative models of video: A new metric & challenges. arXiv:1812.01717, 2018. ",
+        "bbox": [
+            173,
+            633,
+            825,
+            678
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ruben Villegas, Jimei Yang, Seunghoon Hong, Xunyu Lin, and Honglak Lee. Decomposing motion and content for natural video sequence prediction. arXiv preprint arXiv:1706.08033, 2017a. ",
+        "bbox": [
+            171,
+            686,
+            823,
+            717
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ruben Villegas, Jimei Yang, Yuliang Zou, Sungryull Sohn, Xunyu Lin, and Honglak Lee. Learning to generate long-term future via hierarchical prediction. In ICML, 2017b. ",
+        "bbox": [
+            171,
+            726,
+            823,
+            756
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Carl Vondrick, Hamed Pirsiavash, and Antonio Torralba. Generating videos with scene dynamics. In NeurIPS, 2016. ",
+        "bbox": [
+            173,
+            765,
+            823,
+            795
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jacob Walker, Kenneth Marino, Abhinav Gupta, and Martial Hebert. The pose knows: Video forecasting by generating pose futures. In ICCV, 2017. ",
+        "bbox": [
+            169,
+            803,
+            823,
+            833
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ting-Chun Wang, Ming-Yu Liu, Jun-Yan Zhu, Guilin Liu, Andrew Tao, Jan Kautz, and Bryan Catanzaro. Video-to-video synthesis. arXiv:1808.06601, 2018a. ",
+        "bbox": [
+            169,
+            842,
+            825,
+            872
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yunbo Wang, Zhifeng Gao, Mingsheng Long, Jianmin Wang, and Philip S Yu. Predrnn $^ { + + }$ : Towards a resolution of the deep-in-time dilemma in spatiotemporal predictive learning. arXiv preprint arXiv:1804.06300, 2018b. ",
+        "bbox": [
+            176,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/2b82b8c12420384304cdce1e87dfb74e91a7c033b4b1bdbba1c564101dc5acd8.jpg",
+        "image_caption": [
+            "Figure 7: The residual blocks for $\\mathcal { G }$ and $\\mathcal { D } _ { S } / \\mathcal { D } _ { T }$ . See Figure 3 for the icons and A.2 for more detail. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            101,
+            821,
+            174
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yunbo Wang, Lu Jiang, Ming-Hsuan Yang, Li-Jia Li, Mingsheng Long, and Li Fei-Fei. Eidetic 3d lstm: A model for video prediction and beyond. 2018c. ",
+        "bbox": [
+            173,
+            229,
+            825,
+            258
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Dirk Weissenborn, Oscar Täckström, and Jakob Uszkoreit. Scaling autoregressive video models. arXiv:1906.02634, 2019. ",
+        "bbox": [
+            174,
+            267,
+            825,
+            297
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yuxin Wu and Kaiming He. Group normalization. In ECCV, 2018. ",
+        "bbox": [
+            174,
+            308,
+            614,
+            323
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "You Xie, Erik Franz, Mengyu Chu, and Nils Thuerey. tempoGAN: A temporally coherent, volumetric GAN for super-resolution fluid flow. TOG, 2018. ",
+        "bbox": [
+            173,
+            333,
+            821,
+            362
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ceyuan Yang, Zhe Wang, Xinge Zhu, Chen Huang, Jianping Shi, and Dahua Lin. Pose guided human video generation. In ECCV, 2018. ",
+        "bbox": [
+            174,
+            372,
+            823,
+            401
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Han Zhang, Ian Goodfellow, Dimitris Metaxas, and Augustus Odena. Self-attention generative adversarial networks. arXiv:1805.08318, 2018. ",
+        "bbox": [
+            174,
+            411,
+            823,
+            440
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yipin Zhou, Zhaowen Wang, Chen Fang, Trung Bui, and Tamara L Berg. Dance dance generation: Motion transfer for internet videos. arXiv:1904.00129, 2019. ",
+        "bbox": [
+            174,
+            450,
+            825,
+            479
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A EXPERIMENT METHODOLOGY ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            507,
+            460,
+            523
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.1 DATASET PROCESSING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            540,
+            377,
+            554
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "For all datasets we randomly shuffle the training set for each model replica independently. Experiments on the BAIR Robot Pushing dataset are conducted in the native resolution of $6 4 \\times 6 4$ , where for UCF-101 we operate at a (downsampled) $1 2 8 \\times 1 2 8$ resolution. This is done by a bilinear resize such that the video’s smallest dimension is mapped to 128 pixels while maintaining aspect ratio (144 for UCF-101). From this we take a random 128-pixel crop along the other dimension. We use the same procedure to construct datasets of different resolutions for Kinetics-600. All three datasets contain videos with more frames than we generate, so we take a random sequence of consecutive frames from the resized output. For UCF-101, we augmented the dataset by randomly performing left-right flips with probability 0.5. ",
+        "bbox": [
+            173,
+            565,
+            825,
+            691
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.2 ARCHITECTURE DESCRIPTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            709,
+            429,
+            723
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Our model adopts many architectural choices from Brock et al. (2019) including our nomenclature for describing network width, which is determined by the product of a channel multiplier $c h$ with a constant for each layer in the network. The layer-wise constants for $\\mathcal { G }$ are [8, 8, 8, 4, 2] for $6 4 \\times 6 4$ videos and $[ 8 , 8 , 8 , 4 , 2 , 1 ]$ for $1 2 8 \\times 1 2 8$ . The width of the $i$ -th layer is given by the product of $c h$ and the $i$ -th constant and all layers prior to the residual network in $\\mathcal { G }$ use the initial layer’s multiplier and we refer to the product of that and $c h$ as $c h _ { 0 }$ . ch in DVD-GAN is 128 for videos with $6 4 \\times 6 4$ resolution and 96 otherwise. The corresponding $c h$ lists for both $\\mathcal { D } _ { T }$ and $\\mathcal { D } _ { S }$ are [2, 4, 8, 16, 16] for $6 4 \\times 6 4$ resolution and $[ 1 , 2 , 4 , 8 , 1 6 , 1 6 ]$ for $1 2 8 \\times 1 2 8$ . ",
+        "bbox": [
+            174,
+            734,
+            825,
+            848
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "The input to $\\mathcal { G }$ consists of a Gaussian latent noise $z \\sim \\mathcal { N } ( 0 , I )$ and a learned linear embedding $e ( y )$ of the desired class $y$ . Both inputs are 120-dimensional vectors. $\\mathcal { G }$ starts by computing an affine transformation of $[ z ; e ( y ) ]$ to a $[ 4 , 4 , c h _ { 0 } ]$ -shaped tensor (in Figure 3 this is represented as a $1 \\times 1$ convolution). $[ z ; e ( y ) ]$ is used as the input to all class-conditional Batch Normalization layers throughout $\\mathcal { G }$ (the gray line in Figure 7). ",
+        "bbox": [
+            174,
+            853,
+            823,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "This is then treated as the input (at each frame we would like to generate) to a Convolutional Gated Recurrent Unit (Ballas et al., 2015; Sutskever et al., 2011) whose update rule for input $x _ { t }$ and previous output $h _ { t - 1 }$ is given by the following: ",
+        "bbox": [
+            173,
+            103,
+            825,
+            146
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/457f3f29289d7bf00bf86bbaaf273b20bb607063e86a97e98c486c874ffe679f.jpg",
+        "text": "$$\n\\begin{array} { r l } & { r = \\sigma ( W _ { r } \\star _ { 3 } \\left[ h _ { t - 1 } ; x _ { t } \\right] + b _ { r } ) } \\\\ & { u = \\sigma ( W _ { u } \\star _ { 3 } \\left[ h _ { t - 1 } ; x _ { t } \\right] + b _ { u } ) } \\\\ & { c = \\rho ( W _ { c } \\star _ { 3 } \\left[ x _ { t } ; r \\odot h _ { t - 1 } \\right] + b _ { c } ) } \\\\ & { h _ { t } = u \\odot h _ { t - 1 } + ( 1 - u ) \\odot c } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            387,
+            167,
+            611,
+            242
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In these equations $\\sigma$ and $\\rho$ are the elementwise sigmoid and ReLU functions respectively, the $\\star _ { n }$ operator represents a convolution with a kernel of size $n \\times n$ , and the $\\odot$ operator is an elementwise multiplication. Brackets are used to represent a feature concatenation. This RNN is unrolled once per frame. The output of this RNN is processed by two residual blocks (whose architecture is given by Figure 7). The time dimension is combined with the batch dimension here, so each frame proceeds through the blocks independently. The output of these blocks has width and height dimensions which are doubled (we skip upsampling in the first block). This is repeated a number of times, with the output of one $\\mathrm { R N N } +$ residual group fed as the input to the next group, until the output tensors have the desired spatial dimensions. We do not reduce over the time dimension when calculating Batch Normalization statistics. This prevents the network from utilizing the Batch Normalization layers to pass information between timesteps. ",
+        "bbox": [
+            174,
+            247,
+            825,
+            401
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The spatial discriminator $\\mathcal { D } _ { S }$ functions almost identically to BigGAN’s discriminator, though an overview of the residual blocks is given in Figure 7 for completeness. A score is calculated for each of the uniformly sampled $k$ frames (we default to $k = 8$ ) and the $\\mathcal { D } _ { S }$ output is the sum over per-frame scores. The temporal discriminator $\\mathcal { D } _ { T }$ has a similar architecture, but pre-processes the real or generated video with a $2 \\times 2$ average-pooling downsampling function $\\phi$ . Furthermore, the first two residual blocks of $\\mathcal { D } _ { T }$ are 3-D, where every convolution is replaced with a 3-D convolution with a kernel size of $3 \\times 3 \\times 3$ . The rest of the architecture follows BigGAN (Brock et al., 2019). ",
+        "bbox": [
+            174,
+            407,
+            825,
+            505
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A.3 TRAINING DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            521,
+            354,
+            535
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Sampling from DVD-GAN is very efficient, as the core of the generator architecture is a feed-forward convolutional network: two $6 4 \\times 6 4$ 48-frame videos can be sampled in less than $1 5 0 \\mathrm { m s }$ on a single TPU core. The dual discriminator $\\mathcal { D }$ is updated twice for every update of $\\mathcal { G }$ (Heusel et al., 2017) and we use Spectral Normalization (Zhang et al., 2018) for all weight layers (approximated by the first singular value) and orthogonal initialization of weights (Saxe et al., 2013). Sampling is carried out using the exponential moving average of $\\mathcal { G }$ ’s weights, which is accumulated with decay $\\gamma = 0 . 9 9 9 9$ starting after 20,000 training steps. The model is optimized using Adam (Kingma & Ba, 2014) with batch size 512 and a learning rate of $1 \\cdot 1 0 ^ { - 4 }$ and $5 { \\cdot } \\bar { 1 } 0 ^ { - 4 }$ for $\\mathcal { G }$ and $\\mathcal { D }$ respectively. Class conditioning in $\\mathcal { D }$ (Miyato & Koyama, 2018) is projection-based whereas $\\mathcal { G }$ relies on class-conditional Batch Normalization (Ioffe & Szegedy, 2015; De Vries et al., 2017; Dumoulin et al., 2017): equivalent to standard Batch Normalization without a learned scale and offset, followed by an elementwise affine transformation where each parameter is a function of the noise vector and class conditioning. ",
+        "bbox": [
+            174,
+            547,
+            825,
+            713
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A.4 FID FOR KINETICS-600 SYNTHESIS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            729,
+            467,
+            743
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The FID we use for Synthesis on Kinetics-600 is calculated exactly as Fréchet Video Distance (Unterthiner et al., 2018) except that we use a different feature network: an I3D trained on Kinetics-600 (as opposed to the network trained on Kinetics-400 in FVD) and features from the final hidden layer instead of the logits. This metric can be implemented as a small change from the publically available FVD code (Google, 2019) by changing the name of the TF-Hub module to ’https://tfhub.dev/deepmind/i3d-kinetics-600/1’ and loading the tensor named ’RGB/inception_i3d/Logits/AvgPool3D’ from the resulting graph. ",
+        "bbox": [
+            174,
+            756,
+            825,
+            853
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A.5 ARCHITECTURE EXTENSION TO VIDEO PREDICTION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            869,
+            581,
+            883
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In order to provide results on future video prediction problems we describe a simple modification to DVD-GAN to facilitate the added conditioning. A diagram of the extended model is in Figure 8. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/1c5bc638de65612842638e42398458dcab82dea60e25561b2716a14decf2930c.jpg",
+        "image_caption": [
+            "Figure 8: An architecture diagram describing the changes for the frame conditional model. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            99,
+            821,
+            315
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/972300bd4a0636857f606053d10d2722bb8de63b94b1ab68e1bfd6cd6e6dcd20.jpg",
+        "image_caption": [
+            "Figure 9: Three video samples from a prediction model trained on the BAIR robot pushing dataset. Each row is a separate video, the leftmost column is a (true) conditioning frame. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            364,
+            825,
+            460
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Given $C$ conditioning frames, our modified DVD-GAN- $F P$ passes each frame separately through a deep residual network identical to $\\mathcal { D } _ { S }$ . The (near) symmetric design of $\\mathcal { G }$ and $\\mathcal { D } _ { S }$ ’s residual blocks mean that each output from a $\\mathcal { D }$ -style residual block has a corresponding intermediate tensor in $\\mathcal { G }$ of the same spatial resolution. After each block the resulting features for each conditioning frame are stacked in the channel dimension and passed through a $3 \\times 3$ convolution and ReLU activation. The resulting tensor is used as the initial state for the Convolutional GRU in the corresponding block in $\\mathcal { G }$ . Note that the frame conditioning stack reduces spatial resolution while $\\mathcal { G }$ increases resolution. Therefore the smallest features of the conditioning frames (which have been through the most layers) are input earliest in $\\mathcal { G }$ and the larger features (which have been through less processing) are input to $\\mathcal { G }$ towards the end. $\\mathcal { D } _ { T }$ operates on the concatenation of the conditioning frames and the output of $\\mathcal { G }$ , meaning that it does not receive any extra information detailing that the first $C$ frames are special. However to reduce wasted computation we do not sample the first $C$ frames for $\\mathcal { D } _ { S }$ on real or generated data. This technically means that $D _ { S }$ will never see the first few frames from real videos at full resolution, but this was not an issue in our experiments. Finally, our video prediction variant does not condition on any class information, allowing us to directly compare with prior art. This is achieved by settling the class id of all samples to 0. ",
+        "bbox": [
+            173,
+            536,
+            825,
+            757
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "B FURTHER EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            787,
+            413,
+            804
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "B.1 UCF-101 ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            824,
+            282,
+            838
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "UCF-101 (Soomro et al., 2012) is a dataset of 13,320 videos of human actions across 101 classes that has previously been used for video synthesis and prediction (Saito et al., 2017; Saito & Saito, 2018; Tulyakov et al., 2018). In this case, DVD-GAN is not conditioned on class labels to make our results comparable with prior work. This is achieved by setting the class labels of all input samples to 0. We report Inception Score (IS) calculated with a C3D network (Tran et al., 2015) ",
+        "bbox": [
+            174,
+            853,
+            825,
+            924
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/c66d3fb6922fc73f34e3f6b3729820b31c64bc1e26c4f66335ba2d99192c76d3.jpg",
+        "image_caption": [
+            "Figure 10: The first frames of interpolations between UCF-101 samples. Each row is a separate interpolation. Contrast with samples in Appendix D.2. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            101,
+            823,
+            243
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "for quantitative comparison with prior work.4 This evaluation is performed by re-scaling the video to $1 2 8 \\times 1 2 8$ , normalizing the input features based on mean statistics of the ground truth dataset, then taking a $1 1 2 \\times 1 1 2$ center crop and applying C3D. Our model produces samples with an IS of 27.38, significantly outperforming the state of the art (see Table 2). The DVD-GAN architecture on UCF-101 is identical to the model used for Kinetics, and is trained on 16-frame $1 2 8 \\times 1 2 8$ clips from UCF-101. ",
+        "bbox": [
+            174,
+            310,
+            825,
+            393
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "The lack of class information does hurt the performance of DVD-GAN, and training on UCF-101 with class labels leads to an improved model with an Inception Score of 32.97. This is directly comparable to Conditional TGAN Saito et al. (2017) which achieved an IS of 15.83 and is close to the IS reported for the ground truth data ( 34.49). However we note than many more recent video generation papers do not test in this regime. It is worth mentioning that our improved score is, at least partially, due to memorization of the training data. In Figure 10 we show interpolation samples from our best UCF-101 model. Like interpolations in Appendix D.2, we sample 2 latents (left and rightmost columns) and show samples from the linear interpolation in latent space along each row. Here we show 4 such interpolations (the first frame from each video). Unlike Kinetics-600 interpolations, which smoothly transition from one sample to the other, we see abrupt jumps in the latent space between highly distinct samples, and little intra-video diversity between samples in each group. It can be further seen that some generated samples highly correlate with samples from the training set. ",
+        "bbox": [
+            173,
+            401,
+            825,
+            580
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "We show this both as a failure of the Inception Score metric, the commonly reported value for classconditional video synthesis on UCF-101, but also as strong signal that UCF-101 is not a complex or diverse enough dataset to facilitate interesting video generation. Each class is relatively small, and reuse of clips from shared underlying videos means that the intra-class diversity can be restricted to just a handful of videos per class. This suggests the need for larger, more diverse and challenging datasets for generative video modelling, and we believe that Kinetics-600 provides a better benchmark for this task. ",
+        "bbox": [
+            174,
+            588,
+            825,
+            685
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "C MISCELLANEOUS EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            707,
+            480,
+            723
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Here we detail a number of modifications or miscellaneous results we experimented with which did not produce a conclusive result. ",
+        "bbox": [
+            174,
+            739,
+            823,
+            767
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "• We experimented with several variations of normalization which do not require calculating statistics over a batch of data. Group Normalization (Wu & He, 2018) performed best, almost on a par with (but worse than) Batch Normalization. We further tried Layer Normalization (Lei Ba et al., 2016), Instance Normalization (Ulyanov et al., 2016), and no normalization, but found that these significantly underperformed Batch Normalization. ",
+        "bbox": [
+            215,
+            781,
+            823,
+            851
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "• We found that removing the final Batch Normalization in $\\mathcal { G }$ , which occurs after the ResNet and before the final convolution, caused a catastrophic failure in learning. Interestingly, just removing the Batch Normalization layers within $\\mathcal { G }$ ’s residual blocks still led to good (though slightly worse) generative models. In particular, variants without Batch Normalization in the residual blocks often achieve significantly higher IS (up to 110.05 for $6 4 \\times 6 4 ~ 1 2$ frame samples – twice normal). But these models had substantially worse FID scores (1.22 for the aforementioned model) – and produced qualitatively worse video samples. ",
+        "bbox": [
+            214,
+            857,
+            821,
+            886
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            232,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "• Early variants of DVD-GAN contained Batch Normalization which normalized over all frames of all batch elements. This gave $\\mathcal { G }$ an extra channel to convey information across time. It took advantage of this, with the result being a model which required batch statistics in order to produce good samples. We found that the version which normalizes over timesteps independently worked just as well and without the dependence on statistics. ",
+        "bbox": [
+            217,
+            314,
+            825,
+            385
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "• Models based on the residual blocks of BigGAN-deep trained faster (in wall clock time) but slower with regards to metrics, and struggled to reach the accuracy of models based on BigGAN’s residual blocks. ",
+        "bbox": [
+            217,
+            526,
+            825,
+            568
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "D GENERATED SAMPLES ",
+        "bbox": [
+            174,
+            743,
+            398,
+            758
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "It is difficult to accurately convey complicated generated video through still frames. Where provided, we recommend readers view the generated videos themselves via the provided links. We refer to videos within these batches by row/column number where the video in the 0th row and column is in the top left corner. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            922
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "D.1 SYNTHESIS SAMPLES ",
+        "bbox": [
+            174,
+            103,
+            369,
+            118
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/94ff8771d2779ba74349cf5c682a7c411890625c34fccd663ccff2f8dadacbfc.jpg",
+        "image_caption": [
+            "Figure 11: The first frames from a random batch of samples from DVD-GAN trained on 12 frames of $6 4 \\times 6 4$ Kinetics-600. Full samples at https://drive.google.com/file/d/ 155F1lkHA5fMAd7k4W3CQvTsi1eKQDhGb/view?usp $^ { 1 = }$ sharing. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            342,
+            825,
+            872
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/ba4ac0ed5a88b2078f70859d40fd357a2be1a1ebc52c488c347b482e7845eb98.jpg",
+        "image_caption": [
+            "Figure 12: The first frames from a random batch of samples from DVD-GAN trained on 48 frames of $6 4 \\times 6 4$ Kinetics-600. Full samples at https://drive.google.com/file/d/ 1FjOQYdUuxPXvS8yeOhXdPQMapUQaklLi/view?usp $^ { 1 = }$ sharing. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            101,
+            823,
+            648
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "image",
+        "img_path": "images/b955570d7e0b96214e40ad222dd8865698a3a930c1eac584e86f5182deb65aca.jpg",
+        "image_caption": [
+            "Figure 13: The first frames from a random batch of samples from DVD-GAN trained on 12 frames of $1 2 8 \\times 1 2 8$ Kinetics-600. Full samples at https://drive.google.com/file/ d/165Yxuvvu3viOy-39LhhSDGtczbWphj_i/view?usp $\\mid =$ sharing "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            101,
+            823,
+            661
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "image",
+        "img_path": "images/d7bf35390195b9b19ead1dbb085b7bb784ca5644655d4df1fd3f9e784d2c1c8e.jpg",
+        "image_caption": [
+            "Figure 14: The first frames from a random batch of samples from DVD-GAN trained on 48 frames of $1 2 8 \\times 1 2 8$ Kinetics-600. Full samples at https://drive.google.com/file/ d/1P8SsWEGP6tEGPPNPH-iVycOlN6vpIgE8/view?usp $\\mid =$ sharing. The sample in row 1, column 5 is a stereotypical example of a degenerate sample occasionally produced by DVD-GAN. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            102,
+            820,
+            603
+        ],
+        "page_idx": 19
+    },
+    {
+        "type": "image",
+        "img_path": "images/1c617b1d9318ce41a070702225dab76601a5204b981f05962fe6381dad922e97.jpg",
+        "image_caption": [
+            "Figure 15: The first frames from a random batch of samples from DVD-GAN trained on 12 frames of $2 5 6 \\times 2 5 6$ Kinetics-600. Full samples at https://drive.google.com/file/ d/1RGRVKCpVaG8z3p9GBCamRk4apiIR7jUc/view?usp $^ { 1 = }$ sharing. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            102,
+            823,
+            604
+        ],
+        "page_idx": 20
+    },
+    {
+        "type": "image",
+        "img_path": "images/91b71faf533db6ba61443412baec9781b80a516fa2acfefdc635e2f55ea46d31.jpg",
+        "image_caption": [
+            "Figure 16: The first frames from a random batch of samples from DVD-GAN trained on UCF-101. Full samples at https://drive.google.com/file/d/ 1VVLF3bQLyfKtIiSxaKWKq5qFRHmv5EVW/view?usp $^ { 1 = }$ sharing. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            101,
+            825,
+            650
+        ],
+        "page_idx": 21
+    },
+    {
+        "type": "text",
+        "text": "D.2 INTERPOLATION SAMPLES",
+        "text_level": 1,
+        "bbox": [
+            174,
+            757,
+            401,
+            771
+        ],
+        "page_idx": 21
+    },
+    {
+        "type": "text",
+        "text": "We expect $\\mathcal { G }$ to produce samples of higher quality from latents near the mean of the distribution (zero). This is the idea behind the Truncation Trick (Brock et al., 2019). Like BigGAN, we find that DVD-GAN is amenable to truncation. We also experiment with interpolations in the latent space and in the class embedding. In both cases, interpolations are evidence that $\\mathcal { G }$ has learned a relatively smooth mapping from the latent space to real videos: this would be impossible for a network that has only memorized the training data, or which is only capable of generating a few exemplars per class. Note that while all latent vectors along an interpolation are valid (and therefore $\\mathcal { G }$ should produce a reasonable sample), at no point during training is $\\mathcal { G }$ asked to generate a sample halfway between two classes. Nevertheless $\\mathcal { G }$ is able to interpolate between even very distinct classes. ",
+        "bbox": [
+            173,
+            797,
+            825,
+            924
+        ],
+        "page_idx": 21
+    },
+    {
+        "type": "image",
+        "img_path": "images/f318244709131bb46a8a172452daa8bb6c9d396662f3498e437390bf38aee8e1.jpg",
+        "image_caption": [
+            "Figure 17: An example intra-class interpolation. Each column is a separate video (the vertical axis is the time dimension). The left and rightmost columns are randomly sampled latent vectors and are generated under a shared class. Columns in between represent videos generated under the same class across the linear interpolation between the two random samples. Note the smooth transition between videos at all six timesteps displayed here. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            102,
+            823,
+            287
+        ],
+        "page_idx": 22
+    },
+    {
+        "type": "image",
+        "img_path": "images/046de18f772d7dd241b13bc673a77bf8afc09dfd94c3ce1faa2cf5ef6578aed4.jpg",
+        "image_caption": [
+            "Figure 18: An example of class interpolation. As before, each column is a sequence of timesteps of a single video. Here, we sample a single latent vector, and the left and rightmost columns represent generating a video of that latent under two different classes. Columns in between represent videos of that same latent generated across an interpolation of the class embedding. Even though at no point has DVD-GAN been trained on data under an interpolated class, it nevertheless produces reasonable samples. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            383,
+            823,
+            571
+        ],
+        "page_idx": 22
+    }
+]

parse/train/HyesB2RqFQ/HyesB2RqFQ.md

@@ -0,0 +1,320 @@
+# BRIDGING HMMS AND RNNS THROUGH ARCHITECTURAL TRANSFORMATIONS
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+A distinct commonality between HMMs and RNNs is that they both learn hidden representations for sequential data. In addition, it has been noted that the backward computation of the Baum-Welch algorithm for HMMs is a special case of the back-propagation algorithm used for neural networks (Eisner (2016)). Do these observations suggest that, despite their many apparent differences, HMMs are a special case of RNNs? In this paper, we investigate a series of architectural transformations between HMMs and RNNs, both through theoretical derivations and empirical hybridization, to answer this question. In particular, we investigate three key design factors—independence assumptions between the hidden states and the observation, the placement of softmax, and the use of non-linearity—in order to pin down their empirical effects. We present a comprehensive empirical study to provide insights on the interplay between expressivity and interpretability with respect to language modeling and parts-of-speech induction.
+
+# 1 INTRODUCTION
+
+Sequence is a common structure among many forms of naturally occurring data, including speech, text, video, and DNA. As such, sequence modeling has long been a core research problem across several fields of machine learning and AI. By far the most widely used approach for decades is the Hidden Markov Models of Baum & Eagon (1967); Jelinek et al. (1975), which assumes a sequence of discrete latent variables to generate a sequence of observed variables. When the latent variables are unobserved, unsupervised training of HMMs can be performed via the Baum-Welch algorithm (which, in turn, is based on the forward-backward algorithm), as a special case of ExpectationMaximization (EM) (Dempster et al. (1977)). Importantly, the discrete nature of the latent variables has the benefit of interpretability, as they recover contextual clustering of the output variables.
+
+In contrast, Recurrent Neural Networks (RNNs), introduced later in the form of Jordan (1986) and Elman (1990) networks, assume continuous latent representations. Notably, unlike the hidden states of HMMs, there is no probabilistic interpretation of the hidden states of RNNs, regardless of their many different architectural variants (e.g. LSTMs of Hochreiter & Schmidhuber (1997), GRUs of Cho et al. (2014) and RANs of Lee et al. (2017)).
+
+Despite their many apparent differences, both HMMs and RNNs model hidden representations for sequential data. At the heart of both models are: a state at time $t$ , a transition function $f : h _ { t - 1 } \to h _ { t }$ in latent space, and an emission function $g \ : \ h _ { t } \ \to \ x _ { t }$ . In addition, it has been noted that the backward computation in the Baum-Welch algorithm is a special case of back-propagation for neural networks (Eisner (2016)). Therefore, a natural question arises as to the fundamental relationship between HMMs and RNNs. Might HMMs be a special case of RNNs?
+
+In this paper, we investigate a series of architectural transformations between HMMs and RNNs— both through theoretical derivations and empirical hybridization. In particular, we demonstrate that the forward marginal inference for an HMM—accumulating forward probabilities to compute the marginal emission and hidden state distributions at each time step—can be reformulated as equations for computing an RNN cell. In addition, we investigate three key design factors—independence assumptions between the hidden states and the observation, the placement of soft- max, and the use of non-linearity—in order to pin down their empirical effects.
+
+Trans/Emit:
+
+![](images/57b8662677ea3422292eb7995e0d6de1f148536dd21a00c23ba11f9ff30ba49e.jpg)  
+Figure 1: Above each of the models we indicate the type of transition and emission cells used. H for HMM, R for RNN/Elman and F is a novel Fusion defined in $\ S 3 . 3$ . It is particularly important to understanding this work to track when a vector is a distribution (resides in a simplex) versus in the unit cube (e.g. after a sigmoid non-linearity). These cases are indicated by $\boldsymbol { \hat { \mathbf { \mathit { c } } } } _ { i }$ and $\mathrm { \ddot { ‰} }$ , respectively.
+
+Our work is supported by several earlier works such as Wessels & Omlin (2000) and $\mathrm { W u }$ et al. (2016) that have also noted the connection between RNNs and HMMs (see $^ { \ S 7 }$ for more detailed discussion). Our contribution is to provide the first thorough theoretical investigation into the model variants, carefully controlling for every design choices, along with comprehensive empirical analysis over the spectrum of possible hybridization between HMMs and RNNs.
+
+We find that the key elements to better performance of the HMMs are the use of a sigmoid instead of softmax linearity in the recurrent cell, and the use of an unnormalized output distribution matrix in the emission computation. On the other hand, multiplicative integration of the previous hidden state and input embedding, and intermediate normalizations in the cell computation are less consequential. We also find that HMM outperforms other RNNs variants for unsupervised prediction of the next POS tag, demonstrating the advantages of discrete bottlenecks for increased interpretability.
+
+The rest of the paper is structured as follows. First, we present in §2 the derivation of HMM marginal inference as a special case of RNN computation. Next in $\ S 3$ , we explore a gradual transformation of HMMs into RNNs. In $\ S 4$ , we present the reverse transformation of Elman RNNs back to HMMs. Finally, building on these continua, we provide empirical analysis in $\ S 5$ and $\ S 6$ to pin point the empirical effects of varying design choices over the possible hybridization between HMMs and RNNs. We discuss related work in $^ { \ S 7 }$ and conclude in $\ S 8$ .
+
+# 2 FORMULATING HMMS AS RECURRENT NEURAL NETWORKS
+
+We start by defining HMMs as sequence models, together with the forward-backward algorithm which is used for inference. Then we show that, by rewriting the forward algorithm, the computation can be viewed as updating a hidden state at each time step by feeding the previous word prediction, and then computing the next word distribution, similar to the way RNNs are structured. The resulting architecture corresponds to the first cell in Figure 1.
+
+# 2.1 MODEL DEFINITION
+
+Let $\mathbf { x } ^ { ( 1 : n ) } = \{ \mathbf { x } ^ { ( 1 ) } , \ldots , \mathbf { x } ^ { ( n ) } \}$ be a sequence of random variables, where each $\mathbf { X }$ is drawn from a vocabulary $\mathbb { V }$ of size $v$ , and an instance $\mathbf { X }$ is represented as an integer $w$ or a one-hot vector ${ e ^ { ( w ) } }$ , where $w$ corresponds to an index in $\mathbb { V }$ . 1 We also define a corresponding sequence of hidden variables $\mathbf { h } ^ { ( 1 : n ) } = \{ \mathbf { h } ^ { ( 1 ) } , \ldots , \mathbf { h } ^ { ( n ) } \}$ , where $\mathtt { h } \in \{ 1 , 2 , \dots m \}$ . The distribution $P ( \mathbf { x } )$ is defined by
+
+marginalizing over $\mathbf { h }$ , and factorizes as follows:
+
+$$
+P ( \mathbf { x } ) = \sum _ { \mathbf { h } } P ( \mathbf { x } , \mathbf { h } ) = \sum _ { \mathbf { h } } P ( \mathbf { h } ^ { ( 1 ) } ) p ( \mathbf { x } ^ { ( 1 ) } | \mathbf { h } ^ { ( 1 ) } ) \prod _ { i = 2 } ^ { n } P ( \mathbf { h } ^ { ( i ) } | \mathbf { h } ^ { ( i - 1 ) } ) P ( \mathbf { x } ^ { ( i ) } | \mathbf { h } ^ { ( i ) } )
+$$
+
+We define the hidden state distribution, referred to as the transition distribution, as
+
+$$
+\begin{array} { r l } & { P ( \mathrm { h } ^ { ( i ) } | \mathrm { h } ^ { ( i - 1 ) } = l ) = \mathrm { s o f t m a x } ( W _ { l , : } + b ) , W \in \mathbb R ^ { m \times m } , \boldsymbol { b } \in \mathbb R ^ { m } } \\ & { \qquad P ( \mathrm { h } ^ { ( 1 ) } ) = \mathrm { s o f t m a x } ( \displaystyle \sum _ { l } W _ { l , : } ^ { \top } + b ) , } \end{array}
+$$
+
+and the emission (output) distribution as
+
+$$
+p ( \mathbf { x } ^ { ( i ) } | \mathbf { h } ^ { ( i ) } = k ) = \mathrm { s o f t m a x } ( \mathbf { { E } } _ { k , : } + d ) , E \in \mathbb { R } ^ { m \times v } , d \in \mathbb { R } ^ { v } .
+$$
+
+# 2.2 INFERENCE
+
+Inference for HMMs (marginalizing over the hidden states to compute the observed sequence probabilities) is performed with the forward-backward algorithm. The backward algorithm is equivalent to automatically differentiating the forward algorithm Eisner (2016). Therefore, while traditional HMM implementations had to implement both the forward and backward algorithm, and train the model with the EM algorithm, we only implement the forward algorithm in standard deep learning software, and perform end-to-end minibatched SGD training, efficiently parallelized on the GPU.
+
+Let $\pmb { w } = \{ w ^ { ( 1 ) } , \dots , w ^ { ( n ) } \}$ be the observed sequence, and $\mathbf { \Delta } _ { w } ( i )$ the one-hot representation of $w ^ { ( i ) }$ The forward probabilities $\textbf { \em a }$ are defined recurrently (i.e., sequentially recursively) as
+
+$$
+\begin{array} { l } { { \displaystyle a _ { k } ^ { ( i ) } = P ( { \bf h } ^ { ( i ) } = k , { \bf x } ^ { ( 1 : i ) } = w ^ { ( 1 : i ) } ) } , \ ~ } \\ { { \displaystyle ~ = P ( { \bf x } ^ { ( i ) } = w ^ { ( i ) } | { \bf h } ^ { ( i ) } = k ) \sum _ { l = 1 } ^ { m } a _ { l } ^ { ( i - 1 ) } P ( { \bf h } ^ { ( i ) } = k | { \bf h } ^ { ( i - 1 ) } = l ) } . } \end{array}
+$$
+
+This can be rewritten by defining
+
+$$
+\begin{array} { r l } & { \mathbf { \boldsymbol { \mathsf { c } } } ^ { ( i ) } = P ( \mathsf { h } ^ { ( i ) } | \mathbf { \boldsymbol { \mathsf { x } } } ^ { ( 1 : i - 1 ) } = \boldsymbol { \mathsf { \pmb { w } } } ^ { ( 1 : i - 1 ) } ) , } \\ & { \mathbf { \boldsymbol { \mathsf { s } } } ^ { ( i ) } = P ( \mathsf { h } ^ { ( i ) } | \mathbf { \boldsymbol { \mathsf { x } } } ^ { ( 1 : i ) } = \boldsymbol { \mathsf { w } } ^ { ( 1 : i ) } ) , } \\ & { \mathbf { \boldsymbol { \mathsf { x } } } ^ { ( i ) } = P ( \mathbf { \boldsymbol { \mathsf { x } } } ^ { ( i ) } = \boldsymbol { \mathsf { w } } ^ { ( i ) } | \mathbf { \boldsymbol { \mathsf { x } } } ^ { ( 1 : i - 1 ) } = \boldsymbol { \mathsf { w } } ^ { ( 1 : i ) } ) , } \end{array}
+$$
+
+and substituting $\textbf { \em a }$ , so that equation 6 is rewritten as (left below) or if expressed directly in terms of the parameters used to define the distributions with vectorized computations (right below):
+
+$$
+\begin{array} { r l r l } & { c _ { k } ^ { ( i ) } = \displaystyle \sum _ { l = 1 } ^ { m } s _ { l } ^ { ( i - 1 ) } P ( { \bf h } ^ { ( i ) } = k | { \bf h } ^ { ( i - 1 ) } = l ) , \quad } & & { c ^ { ( i ) } = \mathrm { s o f t m a x } _ { \mathrm { r o w s } } ( W ) ^ { \top } s ^ { ( i - 1 ) } , } \\ & { } & & \\ & { } & & { e ^ { ( i ) } = \mathrm { s o f t m a x } _ { \mathrm { r o w s } } ( E ) { \pmb w } ^ { ( i ) } , } \\ & { x ^ { ( i ) } = \displaystyle \sum _ { k = 1 } ^ { m } P ( { \bf x } ^ { ( i ) } = w ^ { ( i ) } | { \bf h } ^ { ( i ) } = k ) c _ { k } ^ { ( i ) } , \quad } & & { x ^ { ( i ) } = e ^ { ( i ) ^ { \top } } c ^ { ( i ) } , } \\ & { } & & \\ & { s _ { k } ^ { ( i ) } = \displaystyle \frac { 1 } { x ^ { ( i ) } } P ( { \bf x } ^ { ( i ) } = w ^ { ( i ) } | { \bf h } ^ { ( i ) } = k ) c _ { k } ^ { ( i ) } . \quad } & & { s ^ { ( i ) } = \displaystyle \frac { 1 } { x ^ { ( i ) } } e ^ { ( i ) } \circ c ^ { ( i ) } . } \end{array}
+$$
+
+Here $\mathbf { \Delta } _ { w } ( i )$ used as a one-hot vector, and the bias vectors $^ { b }$ and $^ d$ are omitted for clarity. Note that the computation of $\mathbf { \boldsymbol { s } } ^ { ( i ) }$ can be delayed until time step $i + 1$ . The computation step can therefore be
+
+rewritten to let $^ c$ be the recurrent vector (equivalent logspace formulations presented on the right): 2
+
+$$
+\begin{array} { r l r l } & { e ^ { ( i - 1 ) } = \mathrm { s o f t m a x } _ { \mathrm { r o w s } } ( E ) w ^ { ( i - 1 ) } , } & & { = \mathrm { l o g s o f t m a x } _ { \mathrm { r o w s } } ( E ) w ^ { ( i - 1 ) } , } \\ & { s ^ { ( i - 1 ) } = \mathrm { n o r m a l i z e } ( e ^ { ( i - 1 ) } \circ c ^ { ( i - 1 ) } ) , } & & { = \mathrm { s o f t m a x } ( e ^ { ( i - 1 ) } + c ^ { ( i - 1 ) } ) , } \\ & { \pmb { c } ^ { ( i ) } = \mathrm { s o f t m a x } _ { \mathrm { r o w s } } ( W ) ^ { \top } \pmb { s } ^ { ( i - 1 ) } , } & & { = \mathrm { l o g } ( \mathrm { s o f t m a x } _ { \mathrm { r o w s } } ( W ) ^ { \top } \pmb { s } ^ { ( i - 1 ) } ) , } \\ & { e ^ { ( i ) } = \mathrm { s o f t m a x } _ { \mathrm { r o w s } } ( E ) \pmb { w } ^ { ( i ) } , } & & { = \mathrm { l o g s o f t m a x } _ { \mathrm { r o w s } } ( E ) \pmb { w } ^ { ( i ) } , } \\ & { \pmb { x } ^ { ( i ) } = e ^ { ( i ) ^ { \top } } \pmb { c } ^ { ( i ) } , } & & { = \mathrm { l o g s u m e x p } ( e ^ { ( i ) } + c ^ { ( i ) } ) . } \end{array}
+$$
+
+This can be viewed as a step of a recurrent neural network with tied input and output embeddings: Equation 14 embeds the previous prediction, equations 15 and 16, the transition step, updates the hidden state $^ c$ , corresponding to the cell of a RNN, and equations 17 and 18, the emission step, computes the output next word probability.
+
+We can now compare this formulation against the definition of a Elman RNN with tied embeddings and a sigmoid non-linearity. These equations correspond to the first and last cells in Figure 1. The Elman RNN has the same parameters, except for an additional input matrix $U \in \mathbb { R } ^ { m \times m }$ .
+
+$$
+\begin{array} { l } { { \pmb { c } } ^ { ( i ) } = \sigma ( { \pmb { W } } { \pmb { c } } ^ { ( i - 1 ) } + { \pmb { U } } { \pmb { e } } ^ { ( i - 1 ) } ) , } \\ { { \pmb { x } } ^ { ( i ) } = \mathrm { s o f t m a x } ( { \pmb { E } } { \pmb { c } } ^ { ( i ) } ) { \pmb { w } } ^ { ( i ) } . } \end{array}
+$$
+
+# 3 TRANSFORMING AN HMM TOWARDS AN RNN
+
+Having established the relation between HMMs and RNNs, we propose a number of models that we hypothesize have intermediate expressiveness between HMMs and RNNs. The architecture transformations can be seen in the first 3 cells in Figure 1. We will evaluate these model variants empirically, and also investigate their interpretability.
+
+# 3.1 CONDITIONING TRANSITION PROBABILITY ON PREVIOUS WORD
+
+By relaxing the independence assumption of the HMM transition probability distribution we can increase the expressiveness of the HMM “cell” by modelling more complex interactions between the fed word and the hidden state.
+
+# Tensor-based feeding:
+
+Following Tran et al. (2016) we define the transition distribution as
+
+$$
+P ( \mathbf { h } ^ { ( i ) } | \mathbf { h } ^ { ( i - 1 ) } = l , \mathbf { x } ^ { ( i - 1 ) } = w ) = \mathrm { s o f t m a x } ( \pmb { W } _ { l , : } e ^ { ( i - 1 ) } + \pmb { B } _ { l , : } ) ,
+$$
+
+where $\pmb { \mathsf { W } } \in \mathbb { R } ^ { m \times m \times m } , \pmb { B } \in \mathbb { R } ^ { m \times m }$
+
+# Addition-based feeding:
+
+As the tensor-based methods increases the number of parameters considerably, we also propose an additive version:
+
+$$
+P ( \mathbf { h } ^ { ( i ) } | \mathbf { h } ^ { ( i - 1 ) } = l , \mathbf { x } ^ { ( i - 1 ) } = w ) = \mathrm { s o f t m a x } ( W _ { l , : } + U e ^ { ( i - 1 ) } + b ) ,
+$$
+
+where $W \in \mathbb { R } ^ { m \times m } , U \in \mathbb { R } ^ { m \times m } , b \in \mathbb { R } ^ { m }$
+
+# Gating-based feeding:
+
+Finally we propose a more expressive model where interaction is controlled via a gating mechanism and the feeding step uses unnormalized embeddings (this does not violate the HMM factorization):
+
+$$
+\begin{array} { c } { e ^ { ' ( i - 1 ) } = E \pmb { w } ^ { ( i - 1 ) } , } \\ { \pmb { f } ^ { i } = \sigma ( U e ^ { ' ( i - 1 ) } + \pmb { b } ) , } \\ { P ( \mathbf { h } ^ { ( i ) } | \mathbf { h } ^ { ( i - 1 ) } = l , \mathbf { x } ^ { ( i - 1 ) } = w ) = \mathrm { s o f t m a x } ( W _ { l , : } \circ \pmb { f } ^ { ( i ) } ) , } \end{array}
+$$
+
+where $U \in \mathbb { R } ^ { m \times m } , \boldsymbol { b } \in \mathbb { R } ^ { m } , W \in \mathbb { R } ^ { m \times m }$
+
+# 3.2 DELAYED SOFTMAXES
+
+Another way to make HMMs more expressive is to relax their independence assumptions through delaying when vectors are normalized to probability distributions by applying the softmax function.
+
+# Delayed transition softmax
+
+The computation of the recurrent vector $\pmb { c } ^ { ( i ) } = P ( \mathbf { h } ^ { ( i ) } | \mathbf { x } ^ { ( 1 : i - 1 ) } )$ is replaced with
+
+$$
+\pmb { c } ^ { ( i ) } = \mathrm { s o f t m a x } ( \pmb { W } \pmb { s } ^ { ( i - 1 ) } ) .
+$$
+
+Both $^ c$ and $\pmb { s }$ are still valid probability distributions, but the independence assumption in the distribution over $\mathrm { h } ^ { ( i ) }$ no longer holds.
+
+# Delayed emission softmax
+
+A further transformation is to delay the emission softmax until after multiplication with the hidden vector. This effectively replaces the HMM’s emission computation with that of the RNN:
+
+$$
+\boldsymbol { x } ^ { ( i ) } = \mathrm { s o f t m a x } ( E \boldsymbol { c } ^ { ( i ) } ) \boldsymbol { w } ^ { ( i ) } .
+$$
+
+This formulation breaks the independence assumption that the output distribution is only conditioned on the hidden state assignment. Instead it can be viewed as taking the expectation over the (unnormalized) embeddings with respect to the state distribution $^ c$ , then softmaxed $\mathbf { H } \mathbf { R }$ in Fig 1).
+
+# 3.3 SIGMOID NON-LINEARITY
+
+We can go further towards RNNs and replace the softmax in the transition by a sigmoid non-linearity. The sigmoid is placed in the same position as the delayed softmax. The recurrent state $^ c$ is no longer a distribution so the output has to be renormalized so the emission still computes a distribution:
+
+$$
+\begin{array} { l } { { \pmb { c } } ^ { ( i ) } = \mathrm { s i g m o i d } ( { \pmb { W } } { \pmb { s } } ^ { ( i - 1 ) } ) , } \\ { { \pmb { x } } ^ { ( i ) } = { \pmb { e } } ^ { ( i ) ^ { \top } } \mathrm { n o r m a l i z e } ( { \pmb { c } } ^ { ( i ) } ) . } \end{array}
+$$
+
+This model could also be combined with a delayed emission softmax - which we’ll see makes it closer to an Elman RNN. This model is indicated as $\mathbf { F }$ for fusion in Figure 1
+
+# 4 TRANSFORMING AN RNN TOWARDS AN HMM
+
+Analogously to making the HMM more similar to Elman RNNs, we can make Elman networks more similar to HMMs. Examples of these transformations can be seen in the last 2 cells in Figure 1.
+
+# 4.1 HMM EMISSION
+
+First, we use the Elman cell with an HMM emission. This requires the hidden state be a distribution, thus we consider two options. One is to replace the sigmoid non-linearity with the softmax function:
+
+$$
+\begin{array} { r l } & { \pmb { c } ^ { ( i ) } = \mathrm { s o f t m a x } ( \pmb { W } \pmb { c } ^ { ( i - 1 ) } + \pmb { U } \pmb { e } ^ { ( i - 1 ) } ) } \\ & { \pmb { x } ^ { ( i ) } = ( \mathrm { s o f t m a x } ( \pmb { E } ) \pmb { w } ^ { ( i ) } ) ^ { \top } \pmb { c } ^ { ( i ) } . } \end{array}
+$$
+
+This model is depicted as $\textbf { R H }$ in Figure 1. The second formulation is to keep the sigmoid nonlinearity, but normalize the hidden state output in the emission computation:
+
+$$
+\begin{array} { r l } & { \pmb { c } ^ { ( i ) } = \sigma ( \pmb { W } \pmb { c } ^ { ( i - 1 ) } + \pmb { U } \pmb { e } ^ { ( i - 1 ) } ) } \\ & { \pmb { x } ^ { ( i ) } = ( \mathrm { s o f t m a x } ( \pmb { E } ) \pmb { w } ^ { ( i ) } ) ^ { \top } \mathrm { n o r m a l i z e } ( \pmb { c } ^ { ( i ) } ) . } \end{array}
+$$
+
+# 4.2 MULTIPLICATIVE INTEGRATION
+
+In the HMM cell, the integration of the previous recurrent state and the input embedding is modelled through an element-wise product instead of adding affine transformations of the two vectors. We can modify the Elman cell to do a similar multiplicative integration:3
+
+$$
+\pmb { c } ^ { ( i ) } = \sigma ( ( W \pmb { c } ^ { ( i - 1 ) } ) \circ ( U \pmb { e } ^ { ( i - 1 ) } ) ) )
+$$
+
+Or, using a single transformation matrix:
+
+$$
+\pmb { c } ^ { ( i ) } = \sigma ( \pmb { W } ( \pmb { c } ^ { ( i - 1 ) } \circ e ^ { ( i - 1 ) } ) )
+$$
+
+# 4.3 SOFTMAX NON-LINEARITY
+
+Finally, and most extreme, we experiment with replacing the sigmoid non-linearity with a softmax:
+
+$$
+\pmb { c } ^ { ( i ) } = \mathrm { s o f t m a x } ( \pmb { W } \pmb { c } ^ { ( i - 1 ) } + \pmb { U } \pmb { e } ^ { ( i - 1 ) } )
+$$
+
+And a more flexible variant, where the softmax is applied only to compute the emission distribution, while the sigmoid non-linearity is still applied to recurrent state:
+
+$$
+\begin{array} { r l } & { \pmb { c } ^ { ( i ) } = ( \pmb { W \sigma } ( \pmb { c } ^ { ( i - 1 ) } ) + \pmb { U e } ^ { ( i - 1 ) } ) } \\ & { \pmb { x } ^ { ( i ) } = \mathrm { s o f t m a x } ( \pmb { E } \mathrm { s o f t m a x } ( \pmb { c } ^ { ( i ) } ) \pmb { w } ^ { ( i ) } ) . } \end{array}
+$$
+
+# 5 LANGUAGE MODELING EXPERIMENTS
+
+Our formulations investigate a series of small architectural changes to HMMs and Elman cells. In particular, these changes raise questions about the expressivity and importance of (1) normalization within the recurrence and (2) independence assumptions during emission. In this section, we analyze the effects of these changes quantitatively via a standard language modeling benchmark.
+
+# 5.1 SETUP
+
+We follow the standard PTB language modeling setup Chelba & Jelinek (1998); Mikolov et al. (2011). We work with one-layer models to enable a direct comparison between RNNs and HMMs and a budget of 10 million parameters (typically corresponding to hidden state sizes of around 900). Models are trained with batched backpropagation through time (35 steps). Input and output embeddings are tied in all models.
+
+Models are optimized with a grid search over optimizer parameters for two strategies: $\mathrm { S G D ^ { 4 } }$ and AMSProp. AMSProp is based on the optimization setup proposed by Melis et al. (2017).5
+
+# 5.2 RESULTS
+
+We see from the results in Table 1 (also depicted in Figure 2) that the HMM models perform significantly worse than the Elman network, as expected. Interestingly, many of the HMM variants that in principle have more expressivity or weaker independence assumptions do not perform better than the vanilla HMM. This includes delaying the transition or emission softmax, and most of the feeding models. The exception is the gated feeding model, which does substantially better, showing that Table 2gating is an effective way of incorporating more context into the transition matrix. Using a sigmoid Perplexity PTB UPOSnon-linearity before the output of the HMM cell (instead of a softmax) does improve performance (by $4 4 \mathrm { p p l } $ 288.15 45.16 61.66), and combining that with delaying the emission softmax gives a substantial improvement (almost another $1 0 0 \mathrm { p p l }$ 142.31 42.09 52.41), making it much closer to some of the RNN variants.
+
+Table 1: Language Modeling Perplexity for our baseline and transformed models.5 4 284.59 225.366 5 287 207.95   
+
+<table><tr><td>Model</td><td>dev ppl</td><td>Model</td><td>dev ppl</td></tr><tr><td>HMM</td><td></td><td>Elman</td><td></td></tr><tr><td></td><td>284.59</td><td>-softmax,HMMemission</td><td>313.84</td></tr><tr><td>- Tensor feeding</td><td>288.15</td><td>-HMM emission</td><td>312.63</td></tr><tr><td>- Addition feeding</td><td>288.62</td><td>- softmax non-linearity</td><td>207.95</td></tr><tr><td>- Gated feeding</td><td>243.51</td><td>- normalize before emit</td><td>225.36</td></tr><tr><td>-Delayed transition softmax</td><td>284.59</td><td>- multiplicative (single matrix)</td><td>107.45</td></tr><tr><td>-Delayed emission softmax</td><td>287.00</td><td>- multiplicative</td><td>100.71</td></tr><tr><td>-Delayed transition and emission softmax</td><td>293.72</td><td></td><td>87.27</td></tr><tr><td>- Sigmoid non-linearity</td><td>240.91</td><td></td><td></td></tr><tr><td>- Sigmoid non-linearity,delayed emission softmax</td><td>142.31</td><td>LSTM</td><td>80.61</td></tr></table>
+
+![](images/c4b26ac64456719fce9b2c5a93981e316de3301ec22c05f2c75459cfa887607c.jpg)  
+Figure 2: This plot shows how perplexities change under our transformations, and which lead the models to converge and pass each other.
+
+207.95 36.68 48.5487.27 44.97 54.59We also evaluate variants of Elman RNNs: Just replacing the sigmoid non-linearity with the softmax 80.61 function leads to a substantial drop in performance $\mathrm { ( 1 2 0 ~ p p l ) }$ 55.08, although it still performs better than the HMM variants where the recurrent state is a distribution. Another way to investigate the effect of the softmax is to normalize the hidden state output just before applying the emission function, while keeping the sigmoid non-linearity: This performs somewhat worse than the softmax non-linearity, Table 2-1 PTB UPOSwhich indicates that it is significant whether the input to the emission function is normalized or softPerplexity PTB UPOSmaxed before multiplying with the (emission) embedding matrix. As a comparison for how much 288.15 45.16 61.66the softmax non-linearity acts as a bottleneck, a neural bigram model outperforms these approaches, 142.31 obtaining 177 validation perplexity on this same setup.
+
+207.95 36.68 48.54Replacing the RNN emission function with that of an HMM leads to even worse performance than 87.27 44.97 54.5980.61 45.75 55.08the HMM: Using a softmax non-linearity or a sigmoid followed by normalization does not make a significant difference. Using multiplicative integration leads to only a small drop in performance 25 50 125 200 275 3compared to a vanilla Elman RNN, and doing so with a single transformation matrix (making it comparable to what an RNN is doing) leads to only a small further drop. In contrast, preliminary experiments showed that the second transformation matrix is crucial in the performance of the vanilla Elman network.
+
+In our experimental setup an LSTM performs only slightly better than the Elman network (80 vs 87 perplexity). While more extensive hyperparameter tuning Melis et al. (2017) or more sophisticated optimization and regularization techniques Merity et al. (2017) would likely improve performance, that is not the goal of this evaluation.
+
+![](images/23eab0de6949949e7364c9835bef1c628e3d3746cb3f3ef857fe9acc538ffabf.jpg)  
+Figure 3: Tagging accuracies (right) are plotted against perplexities from Table 1. We see a somewhat quadratic relationship.
+
+<table><tr><td>Model</td><td>PTB</td><td>UPOS</td></tr><tr><td>HMM</td><td></td><td></td></tr><tr><td></td><td>52.36</td><td>68.23</td></tr><tr><td>- Tensor feeding</td><td>45.16</td><td>61.66</td></tr><tr><td>- Gated feeding</td><td>44.62</td><td>59.64</td></tr><tr><td>- Sigmoid non-linearity - Sigmoid non-linearity with</td><td>31.82</td><td>44.13</td></tr><tr><td>delayed emission softmax</td><td>42.09</td><td>52.41</td></tr><tr><td>Elman</td><td></td><td></td></tr><tr><td>- softmax,HMM emission</td><td>30.86</td><td>45.85</td></tr><tr><td>- softmax non-linearity</td><td>36.68</td><td>48.54</td></tr><tr><td>1</td><td>44.97</td><td>54.59</td></tr><tr><td>LSTM</td><td>45.75</td><td>55.08</td></tr></table>
+
+Table 2: Tagging accuracies for several representative models. Accuracy is calculated by converting $p ( w )$ to $p ( t )$ according to WSJ tag distributions.
+
+# 6 SYNTACTIC EVALUATION
+
+A strength of HMM bottlenecks is forcing the model to produce an interpretable hidden representation. A classic example of this property is part-of-speech tag induction. It is therefore natural to ask whether changes in the architecture of our models correlate with their ability to discover syntactic properties. We evaluate this by analyzing the models implicitly predicted tag distribution at each time step. Specifically, while no model is likely to predict the correct next word, we assume the HMMs errors will preserve basic tag-tag patterns of the language, and that this may not be true for RNNs. We test this by computing the accuracy of predicting the tag of the word in the sequence out of the next word distribution. None of the models were trained to perform this task.
+
+First, we compute a tag distribution $p ( t | w )$ for every word in the training portion of the Penn Treebank. Next, we multiply this value by the model’s $p ( w ) = \widehat { x } _ { i }$ , and sum across the vocabulary. This provides us the model’s distribution over tags at the given time $p ( t ) _ { i }$ . We compare the most likely marginal tag against the ground truth to compute a tagging accuracy. This evaluation rewards models which place their emission probability mass predominantly on words of the correct part-of-speech. We compute this metric across both the full PTB tagset and the universal tags of Petrov et al. (2012).
+
+The HMM allows for Viterbi decoding which allows us to compute $p ( t | \mathrm { m a x } _ { \mathrm { d i m } } ( c _ { i } ) )$ . The more distributed the models’ representations are, the more the tag distribution given the max dimension will differ from the complete marginal. For HMMs with distributional hidden states the maximum dimension provided the best performance. In contrast, Elman models perform best when conditioned on the full hidden state. Results are shown in Table 2 and plotted against perplexity in Figure 3.6
+
+# 7 RELATED WORK
+
+Recently, a number of recent papers have identified variants of gated RNNs which are simpler than LSTMs but perform competitively or satisfy properties that LSTMs lack. Foerster et al. (2017) proposed RNNs without recurrent non-linearities to improve interpretability. Balduzzi & Ghifary (2016) proposed gated RNN variants with type constraints. Peng et al. (2018) identified a class of RNNs called rational recurrences, in which the hidden states can be computed by WFSAs.
+
+Another strand of recent work proposed neural models that learn discrete, interpretable structure: Yang et al. (2017) introduced a mixture of softmax model where the output distribution is conditioned on discrete latent variable. Shen et al. (2017) proposed a language model that jointly learns unsupervised syntactic (tree) structure, while Tran et al. (2016) used neural hidden Markov models for Part-of-Speech induction. Wiseman et al. (2018) and Wang et al. (2017) proposed models for segmental structure over sequences, while neural transduction models with discrete latent alignments have also been proposed Yu et al. (2016).
+
+# 8 CONCLUSION
+
+In this work, we presented a theoretical and empirical investigation into the model variants over the spectrum of possible hybridization between HMMs and RNNs. By carefully controlling for every design choices, we provide new insights into several factors including independence assumptions, the placement of softmax, and the use of nonliniarity and how these choices influence the interplay between expressiveness and interpretability. Comprehensive empirical results demonstrate that the key elements to better performance of the HMM are the use of a sigmoid instead of softmax linearity in the recurrent cell, and the use of an unnormalized output distribution matrix in the emission computation. Multiplicative integration of the previous hidden state and input embedding, and intermediate normalizations in the cell computation are less consequential. We also find that HMM outperforms other RNNs variants in a next POS tag prediction task, which demonstrates the advantages of models with discrete bottlenecks in increased interpretability.
+
+# REFERENCES
+
+David Balduzzi and Muhammad Ghifary. Strongly-typed recurrent neural networks. CoRR, abs/1602.02218, 2016. URL http://arxiv.org/abs/1602.02218.
+
+Leonard E. Baum and J. A. Eagon. An inequality with applications to statistical estimation for probabilistic functions of markov processes and to a model for ecology. Bulletin of the American Mathematical Society, 73(3):360 – 363, 1967.
+
+Ciprian Chelba and Frederick Jelinek. Exploiting syntactic structure for language modeling. In Proceedings of the 36th Annual Meeting of the Association for Computational Linguistics and 17th International Conference on Computational Linguistics, Volume 1, pp. 225–231, Montreal, Quebec, Canada, August 1998. Association for Computational Linguistics. doi: 10.3115/980845. 980882. URL http://www.aclweb.org/anthology/P98-1035.
+
+Kyunghyun Cho, Bart van Merrienboer, Caglar Gulcehre, Dzmitry Bahdanau, Fethi Bougares, Holger Schwenk, and Yoshua Bengio. Learning phrase representations using rnn encoder–decoder for statistical machine translation. In Proceedings of the 2014 Conference on Empirical Methods in Natural Language Processing (EMNLP), pp. 1724–1734, Doha, Qatar, October 2014. Association for Computational Linguistics.
+
+A Dempster, N Laird, and D Rubin. Maximum likelihood from incomplete data via the em algorithm. 01 1977.
+
+Jason Eisner. Inside-outside and forward-backward algorithms are just backprop (tutorial paper). In Proceedings of the Workshop on Structured Prediction for NLP, pp. 1–17, Austin, TX, November 2016. Association for Computational Linguistics. URL http://aclweb.org/ anthology/W16-5901.
+
+J Elman. Finding structure in time. 14(2):179–211, 06 1990.
+
+Jakob N Foerster, Justin Gilmer, Jascha Sohl-Dickstein, Jan Chorowski, and David Sussillo. Input switched affine networks: An rnn architecture designed for interpretability. In International Conference on Machine Learning, pp. 1136–1145, 2017.
+
+Ian Goodfellow, Yoshua Bengio, Aaron Courville, and Yoshua Bengio. Deep learning, volume 1. MIT Press, 2016.
+
+Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural Computation, 9(8): 1735–1780, 1997.
+
+Frederick Jelinek, Lalit R. Bahl, and Robert L Mercer. Design of a linguistic statistical decoder for the recognition of continuous speech. IEEE Transactions on Information Theory, 21(3):250–256, May 1975.
+
+Michael I Jordan. Serial order: A parallel distributed processsing approach. Technical report, University of California, San Diego, 1986.
+
+Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
+
+Kenton Lee, Omer Levy, and Luke S Zettlemoyer. Recurrent additive networks. arXiv preprint arXiv:1705.07393, 05 2017.
+
+Gabor Melis, Chris Dyer, and Phil Blunsom. On the state of the art of evaluation in neural language ´ models. arXiv preprint arXiv:1707.05589, 2017.
+
+Stephen Merity, Nitish Shirish Keskar, and Richard Socher. Regularizing and optimizing LSTM language models. CoRR, abs/1708.02182, 2017. URL http://arxiv.org/abs/1708. 02182.
+
+Toma´s Mikolov, Anoop Deoras, Stefan Kombrink, Luk ˇ a´s Burget, and Jan ˇ Cernock ˇ y. Empirical \` evaluation and combination of advanced language modeling techniques. In Twelfth Annual Conference of the International Speech Communication Association, 2011.
+
+Hao Peng, Roy Schwartz, Sam Thomson, and Noah A. Smith. Rational recurrences. In Proc. of EMNLP, 2018.
+
+Slav Petrov, Dipanjan Das, and Ryan McDonald. A universal part-of-speech tagset. In Proceedings of the Eighth International Conference on Language Resources and Evaluation (LREC-2012), pp. 2089–2096, Istanbul, Turkey, 05 2012.
+
+Sashank J Reddi, Satyen Kale, and Sanjiv Kumar. On the convergence of adam and beyond. 2018.
+
+Yikang Shen, Zhouhan Lin, Chin-Wei Huang, and Aaron C. Courville. Neural language modeling by jointly learning syntax and lexicon. CoRR, abs/1711.02013, 2017. URL http://arxiv. org/abs/1711.02013.
+
+Ke M. Tran, Yonatan Bisk, Ashish Vaswani, Daniel Marcu, and Kevin Knight. Unsupervised neural hidden markov models. In Proceedings of the Workshop on Structured Prediction for NLP, pp. 63–71, Austin, TX, November 2016. Association for Computational Linguistics. URL http: //aclweb.org/anthology/W16-5907.
+
+Chong Wang, Yining Wang, Po-Sen Huang, Abdelrahman Mohamed, Dengyong Zhou, and Li Deng. Sequence modeling via segmentations. arXiv preprint arXiv:1702.07463, 2017.
+
+T Wessels and Christian W Omlin. Refining hidden markov models with recurrent neural networks. In Proceedings of the IEEE-INNS-ENNS International Joint Conference on Neural Networks, volume 2, pp. 271–276. IEEE, 2000.
+
+Sam Wiseman, Stuart M Schieber, and Alexander M Rush. Learning neural templates for text generation. arXiv preprint arXiv:1808.10122, 08 2018.
+
+Yuhuai Wu, Saizheng Zhang, Ying Zhang, Yoshua Bengio, and Ruslan R Salakhutdinov. On multiplicative integration with recurrent neural networks. In D. D. Lee, M. Sugiyama, U. V. Luxburg, I. Guyon, and R. Garnett (eds.), Advances in Neural Information Processing Systems 29, pp. 2856–2864. Curran Associates, Inc., 2016. URL http://papers.nips.cc/paper/ 6215-on-multiplicative-integration-with-recurrent-neural-networks. pdf.
+
+Zhilin Yang, Zihang Dai, Ruslan Salakhutdinov, and William W Cohen. Breaking the softmax bottleneck: A high-rank rnn language model. arXiv preprint arXiv:1711.03953, 2017.
+
+Lei Yu, Jan Buys, and Phil Blunsom. Online segment to segment neural transduction. In Proceedings of the 2016 Conference on Empirical Methods in Natural Language Processing, pp. 1307–1316, Austin, Texas, November 2016. Association for Computational Linguistics. URL https:// aclweb.org/anthology/D16-1138.

parse/train/HyesB2RqFQ/HyesB2RqFQ_content_list.json

@@ -0,0 +1,1617 @@
+[
+    {
+        "type": "text",
+        "text": "BRIDGING HMMS AND RNNS THROUGH ARCHITECTURAL TRANSFORMATIONS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            668,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            184,
+            170,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            234,
+            544,
+            250
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "A distinct commonality between HMMs and RNNs is that they both learn hidden representations for sequential data. In addition, it has been noted that the backward computation of the Baum-Welch algorithm for HMMs is a special case of the back-propagation algorithm used for neural networks (Eisner (2016)). Do these observations suggest that, despite their many apparent differences, HMMs are a special case of RNNs? In this paper, we investigate a series of architectural transformations between HMMs and RNNs, both through theoretical derivations and empirical hybridization, to answer this question. In particular, we investigate three key design factors—independence assumptions between the hidden states and the observation, the placement of softmax, and the use of non-linearity—in order to pin down their empirical effects. We present a comprehensive empirical study to provide insights on the interplay between expressivity and interpretability with respect to language modeling and parts-of-speech induction. ",
+        "bbox": [
+            233,
+            271,
+            764,
+            452
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            491,
+            336,
+            507
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Sequence is a common structure among many forms of naturally occurring data, including speech, text, video, and DNA. As such, sequence modeling has long been a core research problem across several fields of machine learning and AI. By far the most widely used approach for decades is the Hidden Markov Models of Baum & Eagon (1967); Jelinek et al. (1975), which assumes a sequence of discrete latent variables to generate a sequence of observed variables. When the latent variables are unobserved, unsupervised training of HMMs can be performed via the Baum-Welch algorithm (which, in turn, is based on the forward-backward algorithm), as a special case of ExpectationMaximization (EM) (Dempster et al. (1977)). Importantly, the discrete nature of the latent variables has the benefit of interpretability, as they recover contextual clustering of the output variables. ",
+        "bbox": [
+            174,
+            526,
+            825,
+            652
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In contrast, Recurrent Neural Networks (RNNs), introduced later in the form of Jordan (1986) and Elman (1990) networks, assume continuous latent representations. Notably, unlike the hidden states of HMMs, there is no probabilistic interpretation of the hidden states of RNNs, regardless of their many different architectural variants (e.g. LSTMs of Hochreiter & Schmidhuber (1997), GRUs of Cho et al. (2014) and RANs of Lee et al. (2017)). ",
+        "bbox": [
+            174,
+            659,
+            825,
+            728
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Despite their many apparent differences, both HMMs and RNNs model hidden representations for sequential data. At the heart of both models are: a state at time $t$ , a transition function $f : h _ { t - 1 } \\to h _ { t }$ in latent space, and an emission function $g \\ : \\ h _ { t } \\ \\to \\ x _ { t }$ . In addition, it has been noted that the backward computation in the Baum-Welch algorithm is a special case of back-propagation for neural networks (Eisner (2016)). Therefore, a natural question arises as to the fundamental relationship between HMMs and RNNs. Might HMMs be a special case of RNNs? ",
+        "bbox": [
+            174,
+            734,
+            825,
+            819
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we investigate a series of architectural transformations between HMMs and RNNs— both through theoretical derivations and empirical hybridization. In particular, we demonstrate that the forward marginal inference for an HMM—accumulating forward probabilities to compute the marginal emission and hidden state distributions at each time step—can be reformulated as equations for computing an RNN cell. In addition, we investigate three key design factors—independence assumptions between the hidden states and the observation, the placement of soft- max, and the use of non-linearity—in order to pin down their empirical effects. ",
+        "bbox": [
+            174,
+            827,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Trans/Emit: ",
+        "bbox": [
+            176,
+            99,
+            266,
+            114
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/57b8662677ea3422292eb7995e0d6de1f148536dd21a00c23ba11f9ff30ba49e.jpg",
+        "image_caption": [
+            "Figure 1: Above each of the models we indicate the type of transition and emission cells used. H for HMM, R for RNN/Elman and F is a novel Fusion defined in $\\ S 3 . 3$ . It is particularly important to understanding this work to track when a vector is a distribution (resides in a simplex) versus in the unit cube (e.g. after a sigmoid non-linearity). These cases are indicated by $\\boldsymbol { \\hat { \\mathbf { \\mathit { c } } } } _ { i }$ and $\\mathrm { \\ddot { ‰} }$ , respectively. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            114,
+            826,
+            301
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our work is supported by several earlier works such as Wessels & Omlin (2000) and $\\mathrm { W u }$ et al. (2016) that have also noted the connection between RNNs and HMMs (see $^ { \\ S 7 }$ for more detailed discussion). Our contribution is to provide the first thorough theoretical investigation into the model variants, carefully controlling for every design choices, along with comprehensive empirical analysis over the spectrum of possible hybridization between HMMs and RNNs. ",
+        "bbox": [
+            174,
+            398,
+            825,
+            468
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We find that the key elements to better performance of the HMMs are the use of a sigmoid instead of softmax linearity in the recurrent cell, and the use of an unnormalized output distribution matrix in the emission computation. On the other hand, multiplicative integration of the previous hidden state and input embedding, and intermediate normalizations in the cell computation are less consequential. We also find that HMM outperforms other RNNs variants for unsupervised prediction of the next POS tag, demonstrating the advantages of discrete bottlenecks for increased interpretability. ",
+        "bbox": [
+            173,
+            476,
+            825,
+            559
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The rest of the paper is structured as follows. First, we present in §2 the derivation of HMM marginal inference as a special case of RNN computation. Next in $\\ S 3$ , we explore a gradual transformation of HMMs into RNNs. In $\\ S 4$ , we present the reverse transformation of Elman RNNs back to HMMs. Finally, building on these continua, we provide empirical analysis in $\\ S 5$ and $\\ S 6$ to pin point the empirical effects of varying design choices over the possible hybridization between HMMs and RNNs. We discuss related work in $^ { \\ S 7 }$ and conclude in $\\ S 8$ . ",
+        "bbox": [
+            173,
+            565,
+            825,
+            650
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 FORMULATING HMMS AS RECURRENT NEURAL NETWORKS",
+        "text_level": 1,
+        "bbox": [
+            174,
+            674,
+            710,
+            691
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We start by defining HMMs as sequence models, together with the forward-backward algorithm which is used for inference. Then we show that, by rewriting the forward algorithm, the computation can be viewed as updating a hidden state at each time step by feeding the previous word prediction, and then computing the next word distribution, similar to the way RNNs are structured. The resulting architecture corresponds to the first cell in Figure 1. ",
+        "bbox": [
+            174,
+            709,
+            825,
+            780
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 MODEL DEFINITION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            803,
+            352,
+            816
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Let $\\mathbf { x } ^ { ( 1 : n ) } = \\{ \\mathbf { x } ^ { ( 1 ) } , \\ldots , \\mathbf { x } ^ { ( n ) } \\}$ be a sequence of random variables, where each $\\mathbf { X }$ is drawn from a vocabulary $\\mathbb { V }$ of size $v$ , and an instance $\\mathbf { X }$ is represented as an integer $w$ or a one-hot vector ${ e ^ { ( w ) } }$ , where $w$ corresponds to an index in $\\mathbb { V }$ . 1 We also define a corresponding sequence of hidden variables $\\mathbf { h } ^ { ( 1 : n ) } = \\{ \\mathbf { h } ^ { ( 1 ) } , \\ldots , \\mathbf { h } ^ { ( n ) } \\}$ , where $\\mathtt { h } \\in \\{ 1 , 2 , \\dots m \\}$ . The distribution $P ( \\mathbf { x } )$ is defined by ",
+        "bbox": [
+            174,
+            828,
+            825,
+            891
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "marginalizing over $\\mathbf { h }$ , and factorizes as follows: ",
+        "bbox": [
+            173,
+            103,
+            486,
+            118
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/33e5f1b768be5fbe5d9d32c46939b4c657e2be5ddabd59d8c142e724a394645c.jpg",
+        "text": "$$\nP ( \\mathbf { x } ) = \\sum _ { \\mathbf { h } } P ( \\mathbf { x } , \\mathbf { h } ) = \\sum _ { \\mathbf { h } } P ( \\mathbf { h } ^ { ( 1 ) } ) p ( \\mathbf { x } ^ { ( 1 ) } | \\mathbf { h } ^ { ( 1 ) } ) \\prod _ { i = 2 } ^ { n } P ( \\mathbf { h } ^ { ( i ) } | \\mathbf { h } ^ { ( i - 1 ) } ) P ( \\mathbf { x } ^ { ( i ) } | \\mathbf { h } ^ { ( i ) } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            240,
+            131,
+            756,
+            172
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We define the hidden state distribution, referred to as the transition distribution, as ",
+        "bbox": [
+            171,
+            190,
+            712,
+            205
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2e601f75344a12f75a1f2c543f1e0b43de8ec072fb295f82b21306fcb74f6cb1.jpg",
+        "text": "$$\n\\begin{array} { r l } & { P ( \\mathrm { h } ^ { ( i ) } | \\mathrm { h } ^ { ( i - 1 ) } = l ) = \\mathrm { s o f t m a x } ( W _ { l , : } + b ) , W \\in \\mathbb R ^ { m \\times m } , \\boldsymbol { b } \\in \\mathbb R ^ { m } } \\\\ & { \\qquad P ( \\mathrm { h } ^ { ( 1 ) } ) = \\mathrm { s o f t m a x } ( \\displaystyle \\sum _ { l } W _ { l , : } ^ { \\top } + b ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            284,
+            215,
+            712,
+            272
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "and the emission (output) distribution as ",
+        "bbox": [
+            173,
+            284,
+            439,
+            299
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bdbd8f01bf1e87bf3ab083df549c425d9307ab3d435956e6228fc6dfcb8864c0.jpg",
+        "text": "$$\np ( \\mathbf { x } ^ { ( i ) } | \\mathbf { h } ^ { ( i ) } = k ) = \\mathrm { s o f t m a x } ( \\mathbf { { E } } _ { k , : } + d ) , E \\in \\mathbb { R } ^ { m \\times v } , d \\in \\mathbb { R } ^ { v } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            299,
+            310,
+            699,
+            330
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 INFERENCE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            352,
+            295,
+            366
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Inference for HMMs (marginalizing over the hidden states to compute the observed sequence probabilities) is performed with the forward-backward algorithm. The backward algorithm is equivalent to automatically differentiating the forward algorithm Eisner (2016). Therefore, while traditional HMM implementations had to implement both the forward and backward algorithm, and train the model with the EM algorithm, we only implement the forward algorithm in standard deep learning software, and perform end-to-end minibatched SGD training, efficiently parallelized on the GPU. ",
+        "bbox": [
+            173,
+            380,
+            825,
+            465
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Let $\\pmb { w } = \\{ w ^ { ( 1 ) } , \\dots , w ^ { ( n ) } \\}$ be the observed sequence, and $\\mathbf { \\Delta } _ { w } ( i )$ the one-hot representation of $w ^ { ( i ) }$ The forward probabilities $\\textbf { \\em a }$ are defined recurrently (i.e., sequentially recursively) as ",
+        "bbox": [
+            174,
+            470,
+            821,
+            501
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/054558db5b52c256ae2753ab58fca87ff4bf3af37c1be589c38f5b4d8283f0b8.jpg",
+        "text": "$$\n\\begin{array} { l } { { \\displaystyle a _ { k } ^ { ( i ) } = P ( { \\bf h } ^ { ( i ) } = k , { \\bf x } ^ { ( 1 : i ) } = w ^ { ( 1 : i ) } ) } , \\ ~ } \\\\ { { \\displaystyle ~ = P ( { \\bf x } ^ { ( i ) } = w ^ { ( i ) } | { \\bf h } ^ { ( i ) } = k ) \\sum _ { l = 1 } ^ { m } a _ { l } ^ { ( i - 1 ) } P ( { \\bf h } ^ { ( i ) } = k | { \\bf h } ^ { ( i - 1 ) } = l ) } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            281,
+            512,
+            715,
+            578
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "This can be rewritten by defining ",
+        "bbox": [
+            174,
+            595,
+            393,
+            611
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3ef4643b69b0ec40ec7a32674577cce9205e7c758a0e6aa29247c3b9a602e753.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\mathbf { \\boldsymbol { \\mathsf { c } } } ^ { ( i ) } = P ( \\mathsf { h } ^ { ( i ) } | \\mathbf { \\boldsymbol { \\mathsf { x } } } ^ { ( 1 : i - 1 ) } = \\boldsymbol { \\mathsf { \\pmb { w } } } ^ { ( 1 : i - 1 ) } ) , } \\\\ & { \\mathbf { \\boldsymbol { \\mathsf { s } } } ^ { ( i ) } = P ( \\mathsf { h } ^ { ( i ) } | \\mathbf { \\boldsymbol { \\mathsf { x } } } ^ { ( 1 : i ) } = \\boldsymbol { \\mathsf { w } } ^ { ( 1 : i ) } ) , } \\\\ & { \\mathbf { \\boldsymbol { \\mathsf { x } } } ^ { ( i ) } = P ( \\mathbf { \\boldsymbol { \\mathsf { x } } } ^ { ( i ) } = \\boldsymbol { \\mathsf { w } } ^ { ( i ) } | \\mathbf { \\boldsymbol { \\mathsf { x } } } ^ { ( 1 : i - 1 ) } = \\boldsymbol { \\mathsf { w } } ^ { ( 1 : i ) } ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            362,
+            621,
+            633,
+            688
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "and substituting $\\textbf { \\em a }$ , so that equation 6 is rewritten as (left below) or if expressed directly in terms of the parameters used to define the distributions with vectorized computations (right below): ",
+        "bbox": [
+            176,
+            696,
+            826,
+            726
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e462a8ef9f606faee48673ebbb30a1b2e9b3de60d4ac2d9ecebe4ed511e32a52.jpg",
+        "text": "$$\n\\begin{array} { r l r l } & { c _ { k } ^ { ( i ) } = \\displaystyle \\sum _ { l = 1 } ^ { m } s _ { l } ^ { ( i - 1 ) } P ( { \\bf h } ^ { ( i ) } = k | { \\bf h } ^ { ( i - 1 ) } = l ) , \\quad } & & { c ^ { ( i ) } = \\mathrm { s o f t m a x } _ { \\mathrm { r o w s } } ( W ) ^ { \\top } s ^ { ( i - 1 ) } , } \\\\ & { } & & \\\\ & { } & & { e ^ { ( i ) } = \\mathrm { s o f t m a x } _ { \\mathrm { r o w s } } ( E ) { \\pmb w } ^ { ( i ) } , } \\\\ & { x ^ { ( i ) } = \\displaystyle \\sum _ { k = 1 } ^ { m } P ( { \\bf x } ^ { ( i ) } = w ^ { ( i ) } | { \\bf h } ^ { ( i ) } = k ) c _ { k } ^ { ( i ) } , \\quad } & & { x ^ { ( i ) } = e ^ { ( i ) ^ { \\top } } c ^ { ( i ) } , } \\\\ & { } & & \\\\ & { s _ { k } ^ { ( i ) } = \\displaystyle \\frac { 1 } { x ^ { ( i ) } } P ( { \\bf x } ^ { ( i ) } = w ^ { ( i ) } | { \\bf h } ^ { ( i ) } = k ) c _ { k } ^ { ( i ) } . \\quad } & & { s ^ { ( i ) } = \\displaystyle \\frac { 1 } { x ^ { ( i ) } } e ^ { ( i ) } \\circ c ^ { ( i ) } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            225,
+            737,
+            771,
+            875
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Here $\\mathbf { \\Delta } _ { w } ( i )$ used as a one-hot vector, and the bias vectors $^ { b }$ and $^ d$ are omitted for clarity. Note that the computation of $\\mathbf { \\boldsymbol { s } } ^ { ( i ) }$ can be delayed until time step $i + 1$ . The computation step can therefore be ",
+        "bbox": [
+            173,
+            893,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "rewritten to let $^ c$ be the recurrent vector (equivalent logspace formulations presented on the right): 2 ",
+        "bbox": [
+            173,
+            103,
+            823,
+            119
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ad4c0db6b05132509dbd8ce0cf1311cff7b86dd051181df81eefbf86a61cf394.jpg",
+        "text": "$$\n\\begin{array} { r l r l } & { e ^ { ( i - 1 ) } = \\mathrm { s o f t m a x } _ { \\mathrm { r o w s } } ( E ) w ^ { ( i - 1 ) } , } & & { = \\mathrm { l o g s o f t m a x } _ { \\mathrm { r o w s } } ( E ) w ^ { ( i - 1 ) } , } \\\\ & { s ^ { ( i - 1 ) } = \\mathrm { n o r m a l i z e } ( e ^ { ( i - 1 ) } \\circ c ^ { ( i - 1 ) } ) , } & & { = \\mathrm { s o f t m a x } ( e ^ { ( i - 1 ) } + c ^ { ( i - 1 ) } ) , } \\\\ & { \\pmb { c } ^ { ( i ) } = \\mathrm { s o f t m a x } _ { \\mathrm { r o w s } } ( W ) ^ { \\top } \\pmb { s } ^ { ( i - 1 ) } , } & & { = \\mathrm { l o g } ( \\mathrm { s o f t m a x } _ { \\mathrm { r o w s } } ( W ) ^ { \\top } \\pmb { s } ^ { ( i - 1 ) } ) , } \\\\ & { e ^ { ( i ) } = \\mathrm { s o f t m a x } _ { \\mathrm { r o w s } } ( E ) \\pmb { w } ^ { ( i ) } , } & & { = \\mathrm { l o g s o f t m a x } _ { \\mathrm { r o w s } } ( E ) \\pmb { w } ^ { ( i ) } , } \\\\ & { \\pmb { x } ^ { ( i ) } = e ^ { ( i ) ^ { \\top } } \\pmb { c } ^ { ( i ) } , } & & { = \\mathrm { l o g s u m e x p } ( e ^ { ( i ) } + c ^ { ( i ) } ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            230,
+            122,
+            738,
+            232
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "This can be viewed as a step of a recurrent neural network with tied input and output embeddings: Equation 14 embeds the previous prediction, equations 15 and 16, the transition step, updates the hidden state $^ c$ , corresponding to the cell of a RNN, and equations 17 and 18, the emission step, computes the output next word probability. ",
+        "bbox": [
+            173,
+            242,
+            825,
+            299
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We can now compare this formulation against the definition of a Elman RNN with tied embeddings and a sigmoid non-linearity. These equations correspond to the first and last cells in Figure 1. The Elman RNN has the same parameters, except for an additional input matrix $U \\in \\mathbb { R } ^ { m \\times m }$ . ",
+        "bbox": [
+            174,
+            305,
+            823,
+            348
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/525dfe82982fc490b326c8dce4eac467e07ae54816e95e909ed9d0441e41e526.jpg",
+        "text": "$$\n\\begin{array} { l } { { \\pmb { c } } ^ { ( i ) } = \\sigma ( { \\pmb { W } } { \\pmb { c } } ^ { ( i - 1 ) } + { \\pmb { U } } { \\pmb { e } } ^ { ( i - 1 ) } ) , } \\\\ { { \\pmb { x } } ^ { ( i ) } = \\mathrm { s o f t m a x } ( { \\pmb { E } } { \\pmb { c } } ^ { ( i ) } ) { \\pmb { w } } ^ { ( i ) } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            398,
+            375,
+            614,
+            416
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 TRANSFORMING AN HMM TOWARDS AN RNN ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            434,
+            594,
+            452
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Having established the relation between HMMs and RNNs, we propose a number of models that we hypothesize have intermediate expressiveness between HMMs and RNNs. The architecture transformations can be seen in the first 3 cells in Figure 1. We will evaluate these model variants empirically, and also investigate their interpretability. ",
+        "bbox": [
+            173,
+            464,
+            825,
+            522
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 CONDITIONING TRANSITION PROBABILITY ON PREVIOUS WORD ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            537,
+            656,
+            553
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "By relaxing the independence assumption of the HMM transition probability distribution we can increase the expressiveness of the HMM “cell” by modelling more complex interactions between the fed word and the hidden state. ",
+        "bbox": [
+            174,
+            563,
+            825,
+            606
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Tensor-based feeding: ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            619,
+            328,
+            633
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Following Tran et al. (2016) we define the transition distribution as ",
+        "bbox": [
+            173,
+            635,
+            612,
+            648
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/66c19817de619d48da05e89f22b56aaded6f2cd379aed4f7777c9915e8837871.jpg",
+        "text": "$$\nP ( \\mathbf { h } ^ { ( i ) } | \\mathbf { h } ^ { ( i - 1 ) } = l , \\mathbf { x } ^ { ( i - 1 ) } = w ) = \\mathrm { s o f t m a x } ( \\pmb { W } _ { l , : } e ^ { ( i - 1 ) } + \\pmb { B } _ { l , : } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            289,
+            651,
+            707,
+            670
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\pmb { \\mathsf { W } } \\in \\mathbb { R } ^ { m \\times m \\times m } , \\pmb { B } \\in \\mathbb { R } ^ { m \\times m }$ ",
+        "bbox": [
+            174,
+            671,
+            413,
+            686
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Addition-based feeding: ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            702,
+            343,
+            715
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "As the tensor-based methods increases the number of parameters considerably, we also propose an additive version: ",
+        "bbox": [
+            173,
+            715,
+            823,
+            743
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fa7d489e54d32b64915de13eaa3399bcbfeff443c62a1292f4ed514a995f9673.jpg",
+        "text": "$$\nP ( \\mathbf { h } ^ { ( i ) } | \\mathbf { h } ^ { ( i - 1 ) } = l , \\mathbf { x } ^ { ( i - 1 ) } = w ) = \\mathrm { s o f t m a x } ( W _ { l , : } + U e ^ { ( i - 1 ) } + b ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            279,
+            743,
+            715,
+            762
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $W \\in \\mathbb { R } ^ { m \\times m } , U \\in \\mathbb { R } ^ { m \\times m } , b \\in \\mathbb { R } ^ { m }$ ",
+        "bbox": [
+            176,
+            765,
+            457,
+            780
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Gating-based feeding: ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            794,
+            330,
+            809
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Finally we propose a more expressive model where interaction is controlled via a gating mechanism and the feeding step uses unnormalized embeddings (this does not violate the HMM factorization): ",
+        "bbox": [
+            173,
+            809,
+            820,
+            837
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/388a6a26862238390004bb7f5e1508d89b80f572af3da65e05cec40f859cd984.jpg",
+        "text": "$$\n\\begin{array} { c } { e ^ { ' ( i - 1 ) } = E \\pmb { w } ^ { ( i - 1 ) } , } \\\\ { \\pmb { f } ^ { i } = \\sigma ( U e ^ { ' ( i - 1 ) } + \\pmb { b } ) , } \\\\ { P ( \\mathbf { h } ^ { ( i ) } | \\mathbf { h } ^ { ( i - 1 ) } = l , \\mathbf { x } ^ { ( i - 1 ) } = w ) = \\mathrm { s o f t m a x } ( W _ { l , : } \\circ \\pmb { f } ^ { ( i ) } ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            310,
+            837,
+            686,
+            902
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $U \\in \\mathbb { R } ^ { m \\times m } , \\boldsymbol { b } \\in \\mathbb { R } ^ { m } , W \\in \\mathbb { R } ^ { m \\times m }$ ",
+        "bbox": [
+            176,
+            102,
+            457,
+            118
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 DELAYED SOFTMAXES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            136,
+            372,
+            150
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Another way to make HMMs more expressive is to relax their independence assumptions through delaying when vectors are normalized to probability distributions by applying the softmax function. ",
+        "bbox": [
+            173,
+            161,
+            825,
+            190
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Delayed transition softmax ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            207,
+            364,
+            220
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The computation of the recurrent vector $\\pmb { c } ^ { ( i ) } = P ( \\mathbf { h } ^ { ( i ) } | \\mathbf { x } ^ { ( 1 : i - 1 ) } )$ is replaced with ",
+        "bbox": [
+            173,
+            219,
+            699,
+            237
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bf40a494716471e6631ad0ca7fdbcc973db3d275fb0d4fb3d8842d4ab8d51b5d.jpg",
+        "text": "$$\n\\pmb { c } ^ { ( i ) } = \\mathrm { s o f t m a x } ( \\pmb { W } \\pmb { s } ^ { ( i - 1 ) } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            406,
+            244,
+            591,
+            263
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Both $^ c$ and $\\pmb { s }$ are still valid probability distributions, but the independence assumption in the distribution over $\\mathrm { h } ^ { ( i ) }$ no longer holds. ",
+        "bbox": [
+            174,
+            270,
+            825,
+            301
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Delayed emission softmax ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            318,
+            356,
+            332
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "A further transformation is to delay the emission softmax until after multiplication with the hidden vector. This effectively replaces the HMM’s emission computation with that of the RNN: ",
+        "bbox": [
+            171,
+            332,
+            823,
+            359
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b30cc31bbcdb28d3bada4c325e06a1ee05a36df83252299965c6103aa99cf5ec.jpg",
+        "text": "$$\n\\boldsymbol { x } ^ { ( i ) } = \\mathrm { s o f t m a x } ( E \\boldsymbol { c } ^ { ( i ) } ) \\boldsymbol { w } ^ { ( i ) } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            403,
+            366,
+            594,
+            386
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "This formulation breaks the independence assumption that the output distribution is only conditioned on the hidden state assignment. Instead it can be viewed as taking the expectation over the (unnormalized) embeddings with respect to the state distribution $^ c$ , then softmaxed $\\mathbf { H } \\mathbf { R }$ in Fig 1). ",
+        "bbox": [
+            173,
+            393,
+            825,
+            436
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.3 SIGMOID NON-LINEARITY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            454,
+            397,
+            468
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We can go further towards RNNs and replace the softmax in the transition by a sigmoid non-linearity. The sigmoid is placed in the same position as the delayed softmax. The recurrent state $^ c$ is no longer a distribution so the output has to be renormalized so the emission still computes a distribution: ",
+        "bbox": [
+            174,
+            479,
+            825,
+            522
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/55df48e64ffd83f32a38b543298d88c291c7554f8c1e3cdbff9413ae37b4ded1.jpg",
+        "text": "$$\n\\begin{array} { l } { { \\pmb { c } } ^ { ( i ) } = \\mathrm { s i g m o i d } ( { \\pmb { W } } { \\pmb { s } } ^ { ( i - 1 ) } ) , } \\\\ { { \\pmb { x } } ^ { ( i ) } = { \\pmb { e } } ^ { ( i ) ^ { \\top } } \\mathrm { n o r m a l i z e } ( { \\pmb { c } } ^ { ( i ) } ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            401,
+            529,
+            598,
+            571
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "This model could also be combined with a delayed emission softmax - which we’ll see makes it closer to an Elman RNN. This model is indicated as $\\mathbf { F }$ for fusion in Figure 1 ",
+        "bbox": [
+            173,
+            585,
+            826,
+            614
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 TRANSFORMING AN RNN TOWARDS AN HMM ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            635,
+            596,
+            651
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Analogously to making the HMM more similar to Elman RNNs, we can make Elman networks more similar to HMMs. Examples of these transformations can be seen in the last 2 cells in Figure 1. ",
+        "bbox": [
+            173,
+            666,
+            825,
+            695
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 HMM EMISSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            713,
+            330,
+            728
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "First, we use the Elman cell with an HMM emission. This requires the hidden state be a distribution, thus we consider two options. One is to replace the sigmoid non-linearity with the softmax function: ",
+        "bbox": [
+            173,
+            738,
+            823,
+            768
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e44a80d18b462c17064864ac16bea799d3b42ed56ea8ac863c757158493f81d2.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\pmb { c } ^ { ( i ) } = \\mathrm { s o f t m a x } ( \\pmb { W } \\pmb { c } ^ { ( i - 1 ) } + \\pmb { U } \\pmb { e } ^ { ( i - 1 ) } ) } \\\\ & { \\pmb { x } ^ { ( i ) } = ( \\mathrm { s o f t m a x } ( \\pmb { E } ) \\pmb { w } ^ { ( i ) } ) ^ { \\top } \\pmb { c } ^ { ( i ) } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            369,
+            792,
+            627,
+            837
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "This model is depicted as $\\textbf { R H }$ in Figure 1. The second formulation is to keep the sigmoid nonlinearity, but normalize the hidden state output in the emission computation: ",
+        "bbox": [
+            174,
+            848,
+            825,
+            878
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c21b9d244c9ea7260504b8070d6b088eac28163db05149961c4f8fe32dd87157.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\pmb { c } ^ { ( i ) } = \\sigma ( \\pmb { W } \\pmb { c } ^ { ( i - 1 ) } + \\pmb { U } \\pmb { e } ^ { ( i - 1 ) } ) } \\\\ & { \\pmb { x } ^ { ( i ) } = ( \\mathrm { s o f t m a x } ( \\pmb { E } ) \\pmb { w } ^ { ( i ) } ) ^ { \\top } \\mathrm { n o r m a l i z e } ( \\pmb { c } ^ { ( i ) } ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            349,
+            883,
+            648,
+            926
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.2 MULTIPLICATIVE INTEGRATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            434,
+            118
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In the HMM cell, the integration of the previous recurrent state and the input embedding is modelled through an element-wise product instead of adding affine transformations of the two vectors. We can modify the Elman cell to do a similar multiplicative integration:3 ",
+        "bbox": [
+            173,
+            130,
+            825,
+            171
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d914f35fdab36b12916ad1ace92d9e7faffcc1cff48de257ba4b757035cdc1d5.jpg",
+        "text": "$$\n\\pmb { c } ^ { ( i ) } = \\sigma ( ( W \\pmb { c } ^ { ( i - 1 ) } ) \\circ ( U \\pmb { e } ^ { ( i - 1 ) } ) ) )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            380,
+            179,
+            616,
+            199
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Or, using a single transformation matrix: ",
+        "bbox": [
+            176,
+            213,
+            441,
+            228
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3ea7afbd011b72f9aec46682154ed0d3ccaef1f235633fed0222d0ae81f4b7f8.jpg",
+        "text": "$$\n\\pmb { c } ^ { ( i ) } = \\sigma ( \\pmb { W } ( \\pmb { c } ^ { ( i - 1 ) } \\circ e ^ { ( i - 1 ) } ) )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            397,
+            234,
+            599,
+            255
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.3 SOFTMAX NON-LINEARITY ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            270,
+            401,
+            285
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Finally, and most extreme, we experiment with replacing the sigmoid non-linearity with a softmax: ",
+        "bbox": [
+            171,
+            296,
+            820,
+            311
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9de52e28fab324daf15054025f3b3efb52a0310f1dcef08f8c500c584411cb82.jpg",
+        "text": "$$\n\\pmb { c } ^ { ( i ) } = \\mathrm { s o f t m a x } ( \\pmb { W } \\pmb { c } ^ { ( i - 1 ) } + \\pmb { U } \\pmb { e } ^ { ( i - 1 ) } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            370,
+            329,
+            627,
+            348
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "And a more flexible variant, where the softmax is applied only to compute the emission distribution, while the sigmoid non-linearity is still applied to recurrent state: ",
+        "bbox": [
+            174,
+            359,
+            825,
+            388
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d9070b591dc3b296f34f3c1cd8bc3e39571c8b6c7a8bc90c2e80a1e449eca1cf.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\pmb { c } ^ { ( i ) } = ( \\pmb { W \\sigma } ( \\pmb { c } ^ { ( i - 1 ) } ) + \\pmb { U e } ^ { ( i - 1 ) } ) } \\\\ & { \\pmb { x } ^ { ( i ) } = \\mathrm { s o f t m a x } ( \\pmb { E } \\mathrm { s o f t m a x } ( \\pmb { c } ^ { ( i ) } ) \\pmb { w } ^ { ( i ) } ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            367,
+            412,
+            629,
+            457
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 LANGUAGE MODELING EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            473,
+            527,
+            491
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Our formulations investigate a series of small architectural changes to HMMs and Elman cells. In particular, these changes raise questions about the expressivity and importance of (1) normalization within the recurrence and (2) independence assumptions during emission. In this section, we analyze the effects of these changes quantitatively via a standard language modeling benchmark. ",
+        "bbox": [
+            174,
+            506,
+            825,
+            563
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.1 SETUP ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            579,
+            261,
+            594
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We follow the standard PTB language modeling setup Chelba & Jelinek (1998); Mikolov et al. (2011). We work with one-layer models to enable a direct comparison between RNNs and HMMs and a budget of 10 million parameters (typically corresponding to hidden state sizes of around 900). Models are trained with batched backpropagation through time (35 steps). Input and output embeddings are tied in all models. ",
+        "bbox": [
+            174,
+            606,
+            825,
+            676
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Models are optimized with a grid search over optimizer parameters for two strategies: $\\mathrm { S G D ^ { 4 } }$ and AMSProp. AMSProp is based on the optimization setup proposed by Melis et al. (2017).5 ",
+        "bbox": [
+            174,
+            683,
+            821,
+            712
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.2 RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            728,
+            279,
+            742
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We see from the results in Table 1 (also depicted in Figure 2) that the HMM models perform significantly worse than the Elman network, as expected. Interestingly, many of the HMM variants that in principle have more expressivity or weaker independence assumptions do not perform better than the vanilla HMM. This includes delaying the transition or emission softmax, and most of the feeding models. The exception is the gated feeding model, which does substantially better, showing that Table 2gating is an effective way of incorporating more context into the transition matrix. Using a sigmoid Perplexity PTB UPOSnon-linearity before the output of the HMM cell (instead of a softmax) does improve performance (by $4 4 \\mathrm { p p l } $ 288.15 45.16 61.66), and combining that with delaying the emission softmax gives a substantial improvement (almost another $1 0 0 \\mathrm { p p l }$ 142.31 42.09 52.41), making it much closer to some of the RNN variants. ",
+        "bbox": [
+            178,
+            755,
+            823,
+            784
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/4d787334b1b615ca16140a5a6d3a34505ced83c1bfcc57e8984054e4c9052ab4.jpg",
+        "table_caption": [
+            "Table 1: Language Modeling Perplexity for our baseline and transformed models.5 4 284.59 225.366 5 287 207.95 "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>dev ppl</td><td>Model</td><td>dev ppl</td></tr><tr><td>HMM</td><td></td><td>Elman</td><td></td></tr><tr><td></td><td>284.59</td><td>-softmax,HMMemission</td><td>313.84</td></tr><tr><td>- Tensor feeding</td><td>288.15</td><td>-HMM emission</td><td>312.63</td></tr><tr><td>- Addition feeding</td><td>288.62</td><td>- softmax non-linearity</td><td>207.95</td></tr><tr><td>- Gated feeding</td><td>243.51</td><td>- normalize before emit</td><td>225.36</td></tr><tr><td>-Delayed transition softmax</td><td>284.59</td><td>- multiplicative (single matrix)</td><td>107.45</td></tr><tr><td>-Delayed emission softmax</td><td>287.00</td><td>- multiplicative</td><td>100.71</td></tr><tr><td>-Delayed transition and emission softmax</td><td>293.72</td><td></td><td>87.27</td></tr><tr><td>- Sigmoid non-linearity</td><td>240.91</td><td></td><td></td></tr><tr><td>- Sigmoid non-linearity,delayed emission softmax</td><td>142.31</td><td>LSTM</td><td>80.61</td></tr></table>",
+        "bbox": [
+            179,
+            101,
+            818,
+            256
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/c4b26ac64456719fce9b2c5a93981e316de3301ec22c05f2c75459cfa887607c.jpg",
+        "image_caption": [
+            "Figure 2: This plot shows how perplexities change under our transformations, and which lead the models to converge and pass each other. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            305,
+            299,
+            691,
+            453
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            526,
+            825,
+            625
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "207.95 36.68 48.5487.27 44.97 54.59We also evaluate variants of Elman RNNs: Just replacing the sigmoid non-linearity with the softmax 80.61 function leads to a substantial drop in performance $\\mathrm { ( 1 2 0 ~ p p l ) }$ 55.08, although it still performs better than the HMM variants where the recurrent state is a distribution. Another way to investigate the effect of the softmax is to normalize the hidden state output just before applying the emission function, while keeping the sigmoid non-linearity: This performs somewhat worse than the softmax non-linearity, Table 2-1 PTB UPOSwhich indicates that it is significant whether the input to the emission function is normalized or softPerplexity PTB UPOSmaxed before multiplying with the (emission) embedding matrix. As a comparison for how much 288.15 45.16 61.66the softmax non-linearity acts as a bottleneck, a neural bigram model outperforms these approaches, 142.31 obtaining 177 validation perplexity on this same setup. ",
+        "bbox": [
+            174,
+            631,
+            825,
+            757
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "207.95 36.68 48.54Replacing the RNN emission function with that of an HMM leads to even worse performance than 87.27 44.97 54.5980.61 45.75 55.08the HMM: Using a softmax non-linearity or a sigmoid followed by normalization does not make a significant difference. Using multiplicative integration leads to only a small drop in performance 25 50 125 200 275 3compared to a vanilla Elman RNN, and doing so with a single transformation matrix (making it comparable to what an RNN is doing) leads to only a small further drop. In contrast, preliminary experiments showed that the second transformation matrix is crucial in the performance of the vanilla Elman network. ",
+        "bbox": [
+            174,
+            763,
+            825,
+            861
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In our experimental setup an LSTM performs only slightly better than the Elman network (80 vs 87 perplexity). While more extensive hyperparameter tuning Melis et al. (2017) or more sophisticated optimization and regularization techniques Merity et al. (2017) would likely improve performance, that is not the goal of this evaluation. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/23eab0de6949949e7364c9835bef1c628e3d3746cb3f3ef857fe9acc538ffabf.jpg",
+        "image_caption": [
+            "Figure 3: Tagging accuracies (right) are plotted against perplexities from Table 1. We see a somewhat quadratic relationship. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            122,
+            459,
+            286
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/f222ee02f56dd48935c8c9bb741c743b0f502a6257e2f392fe018b0f7f80a888.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>PTB</td><td>UPOS</td></tr><tr><td>HMM</td><td></td><td></td></tr><tr><td></td><td>52.36</td><td>68.23</td></tr><tr><td>- Tensor feeding</td><td>45.16</td><td>61.66</td></tr><tr><td>- Gated feeding</td><td>44.62</td><td>59.64</td></tr><tr><td>- Sigmoid non-linearity - Sigmoid non-linearity with</td><td>31.82</td><td>44.13</td></tr><tr><td>delayed emission softmax</td><td>42.09</td><td>52.41</td></tr><tr><td>Elman</td><td></td><td></td></tr><tr><td>- softmax,HMM emission</td><td>30.86</td><td>45.85</td></tr><tr><td>- softmax non-linearity</td><td>36.68</td><td>48.54</td></tr><tr><td>1</td><td>44.97</td><td>54.59</td></tr><tr><td>LSTM</td><td>45.75</td><td>55.08</td></tr></table>",
+        "bbox": [
+            483,
+            101,
+            818,
+            286
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 2: Tagging accuracies for several representative models. Accuracy is calculated by converting $p ( w )$ to $p ( t )$ according to WSJ tag distributions. ",
+        "bbox": [
+            473,
+            296,
+            834,
+            338
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 SYNTACTIC EVALUATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            362,
+            415,
+            377
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "A strength of HMM bottlenecks is forcing the model to produce an interpretable hidden representation. A classic example of this property is part-of-speech tag induction. It is therefore natural to ask whether changes in the architecture of our models correlate with their ability to discover syntactic properties. We evaluate this by analyzing the models implicitly predicted tag distribution at each time step. Specifically, while no model is likely to predict the correct next word, we assume the HMMs errors will preserve basic tag-tag patterns of the language, and that this may not be true for RNNs. We test this by computing the accuracy of predicting the tag of the word in the sequence out of the next word distribution. None of the models were trained to perform this task. ",
+        "bbox": [
+            173,
+            393,
+            825,
+            505
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "First, we compute a tag distribution $p ( t | w )$ for every word in the training portion of the Penn Treebank. Next, we multiply this value by the model’s $p ( w ) = \\widehat { x } _ { i }$ , and sum across the vocabulary. This provides us the model’s distribution over tags at the given time $p ( t ) _ { i }$ . We compare the most likely marginal tag against the ground truth to compute a tagging accuracy. This evaluation rewards models which place their emission probability mass predominantly on words of the correct part-of-speech. We compute this metric across both the full PTB tagset and the universal tags of Petrov et al. (2012). ",
+        "bbox": [
+            174,
+            511,
+            823,
+            598
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The HMM allows for Viterbi decoding which allows us to compute $p ( t | \\mathrm { m a x } _ { \\mathrm { d i m } } ( c _ { i } ) )$ . The more distributed the models’ representations are, the more the tag distribution given the max dimension will differ from the complete marginal. For HMMs with distributional hidden states the maximum dimension provided the best performance. In contrast, Elman models perform best when conditioned on the full hidden state. Results are shown in Table 2 and plotted against perplexity in Figure 3.6 ",
+        "bbox": [
+            174,
+            604,
+            825,
+            674
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "7 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            694,
+            344,
+            710
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Recently, a number of recent papers have identified variants of gated RNNs which are simpler than LSTMs but perform competitively or satisfy properties that LSTMs lack. Foerster et al. (2017) proposed RNNs without recurrent non-linearities to improve interpretability. Balduzzi & Ghifary (2016) proposed gated RNN variants with type constraints. Peng et al. (2018) identified a class of RNNs called rational recurrences, in which the hidden states can be computed by WFSAs. ",
+        "bbox": [
+            174,
+            726,
+            825,
+            795
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Another strand of recent work proposed neural models that learn discrete, interpretable structure: Yang et al. (2017) introduced a mixture of softmax model where the output distribution is conditioned on discrete latent variable. Shen et al. (2017) proposed a language model that jointly learns unsupervised syntactic (tree) structure, while Tran et al. (2016) used neural hidden Markov models for Part-of-Speech induction. Wiseman et al. (2018) and Wang et al. (2017) proposed models for segmental structure over sequences, while neural transduction models with discrete latent alignments have also been proposed Yu et al. (2016). ",
+        "bbox": [
+            174,
+            803,
+            825,
+            900
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "8 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            318,
+            117
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this work, we presented a theoretical and empirical investigation into the model variants over the spectrum of possible hybridization between HMMs and RNNs. By carefully controlling for every design choices, we provide new insights into several factors including independence assumptions, the placement of softmax, and the use of nonliniarity and how these choices influence the interplay between expressiveness and interpretability. Comprehensive empirical results demonstrate that the key elements to better performance of the HMM are the use of a sigmoid instead of softmax linearity in the recurrent cell, and the use of an unnormalized output distribution matrix in the emission computation. Multiplicative integration of the previous hidden state and input embedding, and intermediate normalizations in the cell computation are less consequential. We also find that HMM outperforms other RNNs variants in a next POS tag prediction task, which demonstrates the advantages of models with discrete bottlenecks in increased interpretability. ",
+        "bbox": [
+            174,
+            133,
+            825,
+            286
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            308,
+            285,
+            323
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "David Balduzzi and Muhammad Ghifary. Strongly-typed recurrent neural networks. CoRR, abs/1602.02218, 2016. URL http://arxiv.org/abs/1602.02218. ",
+        "bbox": [
+            174,
+            332,
+            823,
+            361
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Leonard E. Baum and J. A. Eagon. An inequality with applications to statistical estimation for probabilistic functions of markov processes and to a model for ecology. Bulletin of the American Mathematical Society, 73(3):360 – 363, 1967. ",
+        "bbox": [
+            174,
+            369,
+            825,
+            412
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ciprian Chelba and Frederick Jelinek. Exploiting syntactic structure for language modeling. In Proceedings of the 36th Annual Meeting of the Association for Computational Linguistics and 17th International Conference on Computational Linguistics, Volume 1, pp. 225–231, Montreal, Quebec, Canada, August 1998. Association for Computational Linguistics. doi: 10.3115/980845. 980882. URL http://www.aclweb.org/anthology/P98-1035. ",
+        "bbox": [
+            173,
+            422,
+            825,
+            493
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Kyunghyun Cho, Bart van Merrienboer, Caglar Gulcehre, Dzmitry Bahdanau, Fethi Bougares, Holger Schwenk, and Yoshua Bengio. Learning phrase representations using rnn encoder–decoder for statistical machine translation. In Proceedings of the 2014 Conference on Empirical Methods in Natural Language Processing (EMNLP), pp. 1724–1734, Doha, Qatar, October 2014. Association for Computational Linguistics. ",
+        "bbox": [
+            174,
+            502,
+            825,
+            573
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "A Dempster, N Laird, and D Rubin. Maximum likelihood from incomplete data via the em algorithm. 01 1977. ",
+        "bbox": [
+            174,
+            583,
+            820,
+            612
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jason Eisner. Inside-outside and forward-backward algorithms are just backprop (tutorial paper). In Proceedings of the Workshop on Structured Prediction for NLP, pp. 1–17, Austin, TX, November 2016. Association for Computational Linguistics. URL http://aclweb.org/ anthology/W16-5901. ",
+        "bbox": [
+            173,
+            621,
+            825,
+            678
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "J Elman. Finding structure in time. 14(2):179–211, 06 1990. ",
+        "bbox": [
+            173,
+            688,
+            573,
+            703
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jakob N Foerster, Justin Gilmer, Jascha Sohl-Dickstein, Jan Chorowski, and David Sussillo. Input switched affine networks: An rnn architecture designed for interpretability. In International Conference on Machine Learning, pp. 1136–1145, 2017. ",
+        "bbox": [
+            173,
+            713,
+            826,
+            756
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ian Goodfellow, Yoshua Bengio, Aaron Courville, and Yoshua Bengio. Deep learning, volume 1. MIT Press, 2016. ",
+        "bbox": [
+            169,
+            765,
+            823,
+            795
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural Computation, 9(8): 1735–1780, 1997. ",
+        "bbox": [
+            173,
+            804,
+            823,
+            833
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Frederick Jelinek, Lalit R. Bahl, and Robert L Mercer. Design of a linguistic statistical decoder for the recognition of continuous speech. IEEE Transactions on Information Theory, 21(3):250–256, May 1975. ",
+        "bbox": [
+            173,
+            842,
+            823,
+            886
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Michael I Jordan. Serial order: A parallel distributed processsing approach. Technical report, University of California, San Diego, 1986. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "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": [
+            173,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kenton Lee, Omer Levy, and Luke S Zettlemoyer. Recurrent additive networks. arXiv preprint arXiv:1705.07393, 05 2017. ",
+        "bbox": [
+            171,
+            141,
+            823,
+            170
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Gabor Melis, Chris Dyer, and Phil Blunsom. On the state of the art of evaluation in neural language ´ models. arXiv preprint arXiv:1707.05589, 2017. ",
+        "bbox": [
+            171,
+            179,
+            823,
+            208
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Stephen Merity, Nitish Shirish Keskar, and Richard Socher. Regularizing and optimizing LSTM language models. CoRR, abs/1708.02182, 2017. URL http://arxiv.org/abs/1708. 02182. ",
+        "bbox": [
+            174,
+            215,
+            825,
+            258
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Toma´s Mikolov, Anoop Deoras, Stefan Kombrink, Luk ˇ a´s Burget, and Jan ˇ Cernock ˇ y. Empirical \\` evaluation and combination of advanced language modeling techniques. In Twelfth Annual Conference of the International Speech Communication Association, 2011. ",
+        "bbox": [
+            174,
+            267,
+            823,
+            310
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hao Peng, Roy Schwartz, Sam Thomson, and Noah A. Smith. Rational recurrences. In Proc. of EMNLP, 2018. ",
+        "bbox": [
+            173,
+            319,
+            823,
+            348
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Slav Petrov, Dipanjan Das, and Ryan McDonald. A universal part-of-speech tagset. In Proceedings of the Eighth International Conference on Language Resources and Evaluation (LREC-2012), pp. 2089–2096, Istanbul, Turkey, 05 2012. ",
+        "bbox": [
+            173,
+            357,
+            825,
+            400
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sashank J Reddi, Satyen Kale, and Sanjiv Kumar. On the convergence of adam and beyond. 2018. ",
+        "bbox": [
+            171,
+            409,
+            818,
+            425
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yikang Shen, Zhouhan Lin, Chin-Wei Huang, and Aaron C. Courville. Neural language modeling by jointly learning syntax and lexicon. CoRR, abs/1711.02013, 2017. URL http://arxiv. org/abs/1711.02013. ",
+        "bbox": [
+            174,
+            433,
+            825,
+            476
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ke M. Tran, Yonatan Bisk, Ashish Vaswani, Daniel Marcu, and Kevin Knight. Unsupervised neural hidden markov models. In Proceedings of the Workshop on Structured Prediction for NLP, pp. 63–71, Austin, TX, November 2016. Association for Computational Linguistics. URL http: //aclweb.org/anthology/W16-5907. ",
+        "bbox": [
+            174,
+            484,
+            825,
+            541
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Chong Wang, Yining Wang, Po-Sen Huang, Abdelrahman Mohamed, Dengyong Zhou, and Li Deng. Sequence modeling via segmentations. arXiv preprint arXiv:1702.07463, 2017. ",
+        "bbox": [
+            173,
+            549,
+            821,
+            579
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "T Wessels and Christian W Omlin. Refining hidden markov models with recurrent neural networks. In Proceedings of the IEEE-INNS-ENNS International Joint Conference on Neural Networks, volume 2, pp. 271–276. IEEE, 2000. ",
+        "bbox": [
+            176,
+            587,
+            825,
+            630
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sam Wiseman, Stuart M Schieber, and Alexander M Rush. Learning neural templates for text generation. arXiv preprint arXiv:1808.10122, 08 2018. ",
+        "bbox": [
+            171,
+            638,
+            825,
+            667
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yuhuai Wu, Saizheng Zhang, Ying Zhang, Yoshua Bengio, and Ruslan R Salakhutdinov. On multiplicative integration with recurrent neural networks. In D. D. Lee, M. Sugiyama, U. V. Luxburg, I. Guyon, and R. Garnett (eds.), Advances in Neural Information Processing Systems 29, pp. 2856–2864. Curran Associates, Inc., 2016. URL http://papers.nips.cc/paper/ 6215-on-multiplicative-integration-with-recurrent-neural-networks. pdf. ",
+        "bbox": [
+            174,
+            676,
+            838,
+            761
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Zhilin Yang, Zihang Dai, Ruslan Salakhutdinov, and William W Cohen. Breaking the softmax bottleneck: A high-rank rnn language model. arXiv preprint arXiv:1711.03953, 2017. ",
+        "bbox": [
+            173,
+            770,
+            823,
+            799
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Lei Yu, Jan Buys, and Phil Blunsom. Online segment to segment neural transduction. In Proceedings of the 2016 Conference on Empirical Methods in Natural Language Processing, pp. 1307–1316, Austin, Texas, November 2016. Association for Computational Linguistics. URL https:// aclweb.org/anthology/D16-1138. ",
+        "bbox": [
+            173,
+            808,
+            826,
+            864
+        ],
+        "page_idx": 9
+    }
+]

parse/train/SJAr0QFxe/SJAr0QFxe.md

@@ -0,0 +1,452 @@
+# DEMYSTIFYING RESNET
+
+# Jiantao Jiao, Yanjun Han, Tsachy Weissman
+
+Sihan Li   
+Department of Electronic Engineering   
+Tsinghua University   
+Beijing 100084, China   
+lisihan13@mails.tsinghua.edu.cn   
+Department of Electrical Engineering   
+Stanford University   
+Stanford, CA 94305, USA   
+{jiantao,yjhan,tsachy}@stanford.edu
+
+# ABSTRACT
+
+We provide a theoretical explanation for the great performance of ResNet via the study of deep linear networks and some nonlinear variants. We show that with or without nonlinearities, by adding shortcuts that have depth two, the condition number of the Hessian of the loss function at the zero initial point is depthinvariant, which makes training very deep models no more difficult than shallow ones. Shortcuts of higher depth result in an extremely flat (high-order) stationary point initially, from which the optimization algorithm is hard to escape. The 1- shortcut, however, is essentially equivalent to no shortcuts. Extensive experiments are provided accompanying our theoretical results. We show that initializing the network to small weights with 2-shortcuts achieves significantly better results than random Gaussian (Xavier) initialization, orthogonal initialization, and shortcuts of deeper depth, from various perspectives ranging from final loss, learning dynamics and stability, to the behavior of the Hessian along the learning process.
+
+# 1 INTRODUCTION
+
+Residual network (ResNet) was first proposed in He et al. (2015a) and extended in He et al. (2016). It followed a principled approach to add shortcut connections every two layers to a VGG-style network (Simonyan & Zisserman, 2014). The new network becomes easier to train, and achieves both lower training and test errors. Using the new structure, He et al. (2015a) managed to train a network with 1001 layers, which was virtually impossible before. Unlike Highway Network (Srivastava et al., 2015a;b) which not only has shortcut paths but also borrows the idea of gates from LSTM (Sainath et al., 2013), ResNet does not have gates. Later He et al. (2016) found that by keeping a clean shortcut path, residual networks will perform even better.
+
+Many attempts have been made to improve ResNet to a further extent. “ResNet in ResNet” (Targ et al., 2016) adds more convolution layers and data paths to each layer, making it capable of representing several types of residual units. “ResNets of ResNets” (Zhang et al., 2016) construct multilevel shortcut connections, which means there exist shortcuts that skip multiple residual units. Wide Residual Networks (Zagoruyko & Komodakis, 2016) makes the residual network shorter but wider, and achieves state of the art results on several datasets while using a shallower network. Moreover, some existing models are also reported to be improved by shortcut connections, including Inceptionv4 (Szegedy et al., 2016), in which shortcut connections make the deep network easier to train.
+
+Why are residual networks so easy to train? He et al. (2015a) suggests that layers in residual networks are learning residual mappings, making them easier to represent identity mappings, which prevents the networks from degradation when the depths of the networks increase. However, Veit et al. (2016) claims that ResNets are actually ensembles of shallow networks, which means they do not solve the problem of training deep networks completely.
+
+We propose a theoretical explanation for the great performance of ResNet. We concur with He et al. (2015a) that the key contribution of ResNet should be some special structure of the loss function that makes training very deep models no more difficult than shallow ones. Analysis, however, seems non-trivial. Quoting He et al. (2015a):
+
+“Deeper non-bottleneck ResNets (e.g., Fig. 5 left) also gain accuracy from increased depth (as shown on CIFAR-10), but are not as economical as the bottleneck ResNets. So the usage of bottleneck designs is mainly due to practical considerations. We further note that the degradation problem of plain nets is also witnessed for the bottleneck designs.
+
+Their empirical observations are inspiring. First, the 1-shortcuts mentioned in the first paragraph do not work. Second, noting that the non-bottleneck ResNets have 2-shortcuts, but the bottleneck ResNets use 3-shortcuts, one sees that shortcuts with depth three also do not work. Hence, a reasonable theoretical explanation must be able to distinguish the 2-shortcut from shortcuts of other depths, and clearly demonstrate why the 2-shortcuts are special and are able to ease the optimization process so significantly for deep models, while shortcuts of other depths may not do the job.
+
+Aiming at explaining the performance of 2-shortcuts, we need to eliminate other variables that may contribute to the success of ResNet. Indeed, one may argue that the deep structure of ResNet may give it better representation power (lower approximation error), which contributes to lower training errors. To eliminate this effect, we focus on deep linear networks, where deeper models do not have better approximation properties. The special role of 2-shortcuts naturally arises in the study.
+
+# 2 MAIN RESULTS
+
+Our work reveals that non-degenerate depth-invariant initial condition numbers, a unique property of residual networks with 2-shortcuts, contributed to the success of ResNet. In fact, in a linear network that will be defined rigorously later, the condition number of Hessian of the Frobenius loss function at the zero initial point is
+
+$$
+\operatorname { c o n d } ( H ) = { \sqrt { \operatorname { c o n d } ( ( \Sigma ^ { X X } - \Sigma ^ { Y X } ) ^ { T } ( \Sigma ^ { X X } - \Sigma ^ { Y X } ) ) } } ,
+$$
+
+which is independent of the number of layers. Here $\Sigma ^ { X X }$ and $\Sigma ^ { Y X }$ denote the input-input and the output-input correlation matrices, defined in Section 3.3. The condition number of a possibly non-PSD matrix is defined as:
+
+Definition 1. The condition number of a matrix $A$ is defined as
+
+$$
+\operatorname { c o n d } ( A ) = \frac { \sigma _ { \operatorname* { m a x } } ( A ) } { \sigma _ { \operatorname* { m i n } } ( A ) } ,
+$$
+
+where $\sigma _ { \mathrm { m a x } } ( A )$ and $\sigma _ { \mathrm { m i n } } ( A )$ are the maximum and minimum of singular values of $A$ . In particular, if $A$ is normal, i.e. $A ^ { T } A \stackrel { \cdot } { = } A A ^ { T }$ , the definition can be simplified to 1
+
+$$
+\mathrm { c o n d } ( A ) = { \frac { | \lambda ( A ) | _ { \operatorname* { m a x } } } { | \lambda ( A ) | _ { \operatorname* { m i n } } } } ,
+$$
+
+where $| \lambda ( A ) | _ { \mathrm { m a x } }$ and $| \lambda ( A ) | _ { \mathrm { m i n } }$ are the maximum and minimum of the absolute values of eigenvalues of $A$ .
+
+Moreover, the zero initial point for ResNet with 2-shortcuts is in fact a so-called strict saddle point (Ge et al., 2015), which are proved to be easy to escape from.
+
+Why shortcuts of other depths do not work? We show that the Hessian at the zero initial point for the 1-shortcut ResNet has condition number growing unboundedly for deep nets. As is well known in convex optimization theory, large condition numbers can have enormous adversarial impact on the convergence of first order methods (Nemirovski, 2005). Hence, it is quite clear that starting training at a point with a huge condition number would make the algorithm very difficult to escape from the initial point, making 1-shortcut ResNet no better than conventional approaches.
+
+For shortcuts with depth deeper than two, the Hessian at the zero initial point is a zero matrix, making it a higher-order stationary point. Intuitively, the higher order the stationary point is, the harder it is to escape from it. Indeed, it is supported both in theory (Anandkumar & Ge, 2016) and by our experiments.
+
+One may still ask: why are we interested in the Hessian at the zero initial point? It is because in order for the outputs of deep neural networks not explode, the singular values of the mapping of each layer are not supposed to be deviating too much from one. Indeed, it is because it is extremely challenging to keep Qnum of layersi=1 λi from exploding or vanishing without keeping all of the λi having unit norm. However, by design ResNet with shortcuts already have an identity mapping every few layers, which forces the mappings inside the shortcuts to have small operator norms. Hence, analyzing the network at zero initial point gives a decent characterization of the searching environment of the optimization algorithm.
+
+Our results also shows that the form of Hessian is more important than the existance of nonlinearities when training the networks. The behaviors of the networks we studied are consistent across both linear and nonlinear structures, where networks with clearer Hessians are much easier to achieve lower training errors.
+
+On the other hand, our experiments reveal that orthogonal initialization (Saxe et al., 2013) is suboptimal. Although better than Xavier initialization (Glorot & Bengio, 2010), the initial condition numbers of the networks still explode as the networks become deeper, which means the networks are still initialized on “bad” submanifolds that are hard to optimize using gradient descent.
+
+# 3 MODEL
+
+# 3.1 DEEP LINEAR NETWORKS
+
+Deep linear networks are feed-forward neural networks that only contain linear units, which means their input-output mappings are simply linear transformations. Apparently, increasing their depths will not affect the representational power of the networks. However, linear networks with depth deeper than one show nonlinear dynamics of training (Saxe et al., 2013). As a result, analyzing the training of deep linear networks gives us a better understanding of the training of non-linear networks.
+
+Much theoretical work has been done on deep linear networks. Kawaguchi (2016) extended the work of Choromanska et al. (2015a;b) and proved that with few assumptions, every local minimum point in deep linear networks is a global minimum point. This means that the difficulties in the training of deep linear networks mostly come from saddle points on the loss surfaces, which are also the main causes of slow learning in nonlinear networks (Pascanu et al., 2014).
+
+Saxe et al. (2013) studied the dynamics of training using gradient descent. They found that for a special class of initial conditions, which could be obtained from greedy layerwise pre-training, the training time for a deep linear network with an infinity depth can still be finite. Furthermore, they found that by setting the initial weights to random orthogonal matrices (produced by performing QR or SVD decompositions on random Gaussian matrices), the network will still have a depth independent learning time. They argue that it is caused by the eigenvalue and singular value spectra of the end-to-end linear transformation. When using orthogonal initialization, the overall transformation is an orthogonal matrix, which has all the singular values equal to 1. In the meantime, when using scaled Gaussian initialization, most of the singular values are close to zero, making the network unsuitable for backpropagating errors. However, this explanation is not sufficient to prove that the training difficulty of orthogonal initialized networks is depth-invariant. It only gives us an intuition on why orthogonal initialization performs better than scaled Gaussian initialization.
+
+Thus, we use deep linear networks to study the effect of shortcut connections. After adding the shortcuts, the overall model is still linear and the global minimum does not change.
+
+# 3.2 NETWORK STRUCTURE
+
+We first generalize a linear network by adding shortcuts to it to make it a linear residual network. We organize the network into $R$ residual units. The $r$ -th residual unit consists of $L _ { r }$ layers whose
+
+weights are $W ^ { r , 1 } , \ldots , W ^ { r , L _ { r } - 1 }$ , denoted as the transformation path, as well as a shortcut $S ^ { r }$ connecting from the first layer to the last one, denoted as the shortcut path. The input-output mapping can be written as
+
+$$
+y = \prod _ { r = 1 } ^ { R } ( \prod _ { l = 1 } ^ { L _ { r } - 1 } W ^ { r , l } + S ^ { r } ) x = W x ,
+$$
+
+where $x \in \mathbb { R } ^ { d _ { x } } , y \in \mathbb { R } ^ { d _ { y } } , W \in \mathbb { R } ^ { d _ { y } \times d _ { x } }$ . Here if $b \_ { a }$ , $\textstyle \prod _ { i = a } ^ { b } W ^ { i }$ denotes $W ^ { b } W ^ { ( b - 1 ) } \cdot \cdot \cdot W ^ { ( a + 1 ) } W ^ { a }$ , otherwise it denotes an identity mapping. The matrix $W$ represents the combination of all the linear transformations in the network. Note that by setting all the shortcuts to zeros, the network will go back to a $\begin{array} { r } { ( \sum _ { r } ( L _ { r } - 1 ) + 1 ) } \end{array}$ -layer plain linear network.
+
+Instead of analyzing the general form, we concentrate on a special kind of linear residual networks, where all the residual units are the same.
+
+Definition 2. A linear residual network is called an $n$ -shortcut linear network if
+
+1. its layers have the same dimension (so that $d _ { x } = d _ { y }$ );   
+2. its shortcuts are identity matrices;   
+3. its shortcuts have the same depth $n$ .
+
+The input-output mapping for such a network becomes
+
+$$
+y = \prod _ { r = 1 } ^ { R } ( \prod _ { l = 1 } ^ { n } W ^ { r , l } + I _ { d _ { x } } ) x = W x ,
+$$
+
+where $W ^ { r , l } \in \mathbb { R } ^ { d _ { x } \times d _ { x } }$ .
+
+Then we add some activation functions to the networks. We concentrate on the case where activation functions are on the transformation paths, which is also the case in the latest ResNet (He et al., 2016).
+
+Definition 3. An $n$ -shortcut linear network becomes an $n$ -shortcut network if element-wise activation functions $\sigma _ { \mathrm { p r e } } ( x ) , \sigma _ { \mathrm { m i d } } ( x ) , \sigma _ { \mathrm { p o s t } } ( x )$ are added at the transformation paths, where on a transformation path, $\sigma _ { \mathrm { p r e } } ( x )$ is added before the first weight matrix, $\sigma _ { \mathrm { m i d } } ( x )$ is added between two weight matrixes and $\sigma _ { \mathrm { p o s t } } ( x )$ is added after the last weight matrix.
+
+$$
+\sqrt { - \frac { p r e } { ( \ p r e ) } \psi _ { \psi } ^ { 1 } ( \ m i d ) \psi _ { \psi } ^ { 2 } ( \ m s t ) } ^ { \gamma } =
+$$
+
+Figure 1: An example of different position for nonlinearities in a residual unit of a 2-shortcut network.
+
+Note that $n$ -shortcut linear networks are special cases of $n$ -shortcut networks, where all the activation functions are identity mappings.
+
+# 3.3 OPTIMIZATION
+
+We denote the collection of all the variable weight parameters in an $n$ -shortcut linear network as w. Consider $m$ training samples $\{ x ^ { \mu } , y ^ { \mu } \} , \mu = 1 , \ldots , m$ . Using Frobenius loss, for an $n$ -shortcut linear network, we define the loss function as follows:
+
+$$
+L ( \mathbf { w } ) = \frac { 1 } { 2 m } \sum _ { \mu = 1 } ^ { m } \lVert y ^ { \mu } - W x ^ { \mu } \rVert _ { 2 } ^ { 2 } = \frac { 1 } { 2 m } \lVert Y - W X \rVert _ { F } ^ { 2 } ,
+$$
+
+where $x ^ { \mu } , y ^ { \mu }$ are the $\mu$ -th columns of $X , Y$ , and $\left\| \cdot \right\| _ { F }$ denotes the Frobenius norm. Using gradient descent with learning rate $\alpha$ , we have the weights updating rules as
+
+$$
+\Delta W ^ { r , l } = \alpha ( W _ { \mathrm { a f t e r } } ^ { r } W _ { \mathrm { a f t e r } } ^ { r , l } ) ^ { T } ( \Sigma ^ { Y X } - W \Sigma ^ { X X } ) ( W _ { \mathrm { b e f o r e } } ^ { r , l } W _ { \mathrm { b e f o r e } } ^ { r } ) ^ { T } ,
+$$
+
+where $\Sigma ^ { X X }$ and $\Sigma ^ { Y X }$ denote the input-input and the output-input correlation matrices, defined as
+
+$$
+\begin{array} { l } { { \displaystyle \Sigma ^ { X X } = \frac { 1 } { m } \sum _ { \mu = 1 } ^ { m } x ^ { \mu } ( x ^ { \mu } ) ^ { T } } } \\ { { \displaystyle \Sigma ^ { Y X } = \frac { 1 } { m } \sum _ { \mu = 1 } ^ { m } y ^ { \mu } ( x ^ { \mu } ) ^ { T } . } } \end{array}
+$$
+
+Here $W _ { \mathrm { b e f o r e } } ^ { r } , W _ { \mathrm { a f t e r } } ^ { r }$ denote the linear mappings before and after the $r$ -th residual unit, $W _ { \mathrm { b e f o r e } } ^ { r , l } , W _ { \mathrm { a f t e r } } ^ { r , l }$ denote the linear mappings before and after $W ^ { r , l }$ within the transformation path of the $r$ -th residual unit. In other words, the overall transformation can be represented as
+
+$$
+y = W _ { \mathrm { a f t e r } } ^ { r } ( W _ { \mathrm { a f t e r } } ^ { r , l } W ^ { r , l } W _ { \mathrm { b e f o r e } } ^ { r , l } + I _ { d _ { x } } ) W _ { \mathrm { b e f o r e } } ^ { r } x .
+$$
+
+# 4 THEORETICAL STUDY
+
+# 4.1 INITIAL POINT PROPERTIES
+
+Before we analyze the initial point properties of $n$ -shortcut networks, we have to choose the way to initialize them. ResNet uses MSRA initialization (He et al., 2015b). It is a kind of scaled Gaussian initialization that tries to keep the variances of signals along a transformation path, which is also the idea behind Xavier initialization (Glorot & Bengio, 2010). However, because of the shortcut paths, the output variance of the entire network will actually explode as the network becomes deeper. Batch normalization units partly solved this problem in ResNet, but still they cannot prevent the large output variance in a deep network.
+
+A simple idea is to zero initialize all the weights, so that the output variances of residual units stay the same along the network. It is worth noting that as found in He et al. (2015a), the deeper ResNet has smaller magnitudes of layer responses. This phenomenon has been confirmed in our experiments. As illustrated in Figure 2 and Figure 3, the deeper a residual network is, the small its average Frobenius norm of weight matrixes is, both during the traning process and when the training ends. Also, Hardt & Ma (2016) proves that if all the weight matrixes have small norms, a linear residual network will have no critical points other than the global optimum.
+
+All these evidences indicate that zero is spacial in a residual network: as the network becomes deeper, the training tends to end up around it. Thus, we are looking into the Hessian at zero. As the zero is a saddle point, in our experiments we use zero initialization with small random perturbations to escape from it. We first Xavier initialize the weight matrixes, and then multiply a small constant (0,01) to them.
+
+We begin with the definition of $k$ -th order stationary point.
+
+Definition 4. Suppose function $f ( x )$ admits $k$ -th order Taylor expansion at point $x _ { 0 }$ . We say that the point $x _ { 0 }$ is a $k$ -th order stationary point of $f ( x )$ if the corresponding $k$ -th order Taylor expansion of $f ( x )$ at $x = x _ { 0 }$ is a constant: $f ( \dot { x } ) \dot { = } f ( x _ { 0 } ) \dot { + } o ( \| x - x _ { 0 } \| _ { 2 } ^ { k } )$ .
+
+Now we state our main theorem, whose proof can be found in Appendix A.
+
+Theorem 1. Assume that $\sigma _ { \mathrm { m i d } } ( 0 ) = \sigma _ { \mathrm { p o s t } } ( 0 ) = 0$ and all of $\sigma _ { \mathrm { p r e } } ^ { ( k ) } ( 0 ) , \sigma _ { \mathrm { m i d } } ^ { ( k ) } ( 0 ) , \sigma _ { \mathrm { p o s t } } ^ { ( k ) } ( 0 ) , 1 \le k \le$ exist. For the loss function of an $n$ -shortcut network, at point zero,
+
+1. if $n \geq 2$ , it is an $( n - 1 ) t h$ -order stationary point. In particular, if $n \geq 3$ , the Hessian is $a$ zero matrix;
+
+![](images/beaf7b5c60eed4a22b5d4e41c424deddc2d59d92d4b8390a36b17fc0e3c7670c.jpg)  
+Figure 2: The average Frobenius norms of ResNets of different depths during the training process. The pre-ResNet implementation in https://github.com/facebook/fb.resnet.torch is used. The learning rate is initialized to 0.1, decreased to 0.01 at the $8 1 ^ { \mathrm { s t } }$ epoch (marked with circles) and decreased to 0.001 at the $1 2 2 ^ { \mathrm { n d } }$ epoch (marked with triangles). Each model is trained for 200 epochs.
+
+![](images/ceffb377ed6bcd64337887c300ae05f7c7ac5ec53bc70681c7e91661a0c31384.jpg)  
+Figure 3: The average Frobenius norms of 2-shortcut networks of different depths during the training process when zero initialized. Left: Without nonlinearities. Right: With ReLUs at mid positions.
+
+2. if $n = 2$ , the Hessian can be written as
+
+$$
+H = \left[ \begin{array} { c c c c c } { \mathbf { 0 } } & { A ^ { T } } & & & \\ { A } & { \mathbf { 0 } } & & & \\ & & { \mathbf { 0 } } & { A ^ { T } } & \\ & & & { A } & { \mathbf { 0 } } & \\ & & & & { \ddots } \end{array} \right] ,
+$$
+
+whose condition number is
+
+$$
+\mathrm { c o n d } ( H ) = \sqrt { \mathrm { c o n d } \big ( \big ( \Sigma ^ { X \sigma _ { \mathrm { p r e } } ( X ) } - \Sigma ^ { Y \sigma _ { \mathrm { p r e } } ( X ) } \big ) ^ { T } \big ( \Sigma ^ { X \sigma _ { \mathrm { p r e } } ( X ) } - \Sigma ^ { Y \sigma _ { \mathrm { p r e } } ( X ) } \big ) \big ) } ,
+$$
+
+where $A$ only depends on the training set and the activation functions. Except for degenerate cases, it is $a$ strict saddle point (Ge et al., 2015).
+
+3. if $n = 1$ , the Hessian can be written as
+
+$$
+H = { \left[ \begin{array} { l l l l l } { B } & { A ^ { T } } & { A ^ { T } } & { \cdots } & { A ^ { T } } \\ { A } & { B } & { A ^ { T } } & { \cdots } & { A ^ { T } } \\ { A } & { A } & { B } & & { \vdots } \\ { \vdots } & { \vdots } & & { \ddots } & { A ^ { T } } \\ { A } & { A } & { \cdots } & { A } & { B } \end{array} \right] }
+$$
+
+where $A , B$ only depend on the training set and the activation functions.
+
+Theorem 1 shows that the condition numbers of 2-shortcut networks are depth-invariant with a nice structure of eigenvalues. Indeed, the eigenvalues of the Hessian $H$ at the zero initial point are multiple copies of $\pm { \sqrt { \mathrm { e i g s } ( A ^ { T } A ) } }$ , and the number of copies is equal to the number of shortcut connections.
+
+The Hessian at zero initial point for the 1-shortcut linear network follows block Toeplitz structure, which has been well studied in the literature. In particular, its condition number tends to explode as the number of layers increase (Gray, 2006).
+
+The assumptions hold for most activation functions including tanh, symmetric sigmoid and ReLU (Nair & Hinton, 2010). Note that although ReLU does not have derivatives at zero, one may do a local polynomial approximation to yield $\bar { \sigma } ^ { ( k ) } , 1 \le k \le \operatorname* { m a x } ( n - 1 , 2 )$ .
+
+To get intuitive explanations of the theorems, imagine changing parameters in an $n$ -shortcut network. One has to change at least $n$ parameters to make any difference in the loss. So zero is an $( n - 1 ) \operatorname { t h } .$ - order stationary point. Notice that the higher the order of a stationary point, the more difficult for a first order method to escape from it.
+
+On the other hand, if $n = 2$ , one will have to change two parameters in the same residual unit but different weight matrices to affect the loss, leading to a clear block diagonal Hessian.
+
+# 4.2 LEARNING DYNAMICS
+
+To understand Equation (7) better, we can take $n$ -shortcut linear networks to two extremes. First, when $n = 1$ , let $\bar { V } ^ { r , 1 } = W ^ { r , 1 } + I _ { d _ { x } } , r = 1 , \ldots , R - 1$ . As $I _ { d _ { x } }$ is a constant, we have
+
+$$
+\Delta V ^ { r , 1 } = \alpha \big ( \prod _ { r ^ { \prime } = r + 1 } ^ { R - 1 } V ^ { r ^ { \prime } , 1 } \big ) ^ { T } \big ( \Sigma ^ { Y X } - ( \prod _ { r ^ { \prime } = 1 } ^ { R - 1 } V ^ { r ^ { \prime } , 1 } ) \Sigma ^ { X X } \big ) ( \prod _ { r ^ { \prime } = 1 } ^ { r - 1 } V ^ { r ^ { \prime } , 1 } ) ^ { T } ,
+$$
+
+which can be seen as a linear network with identity initialization, a special case of orthogonal initialization, if the original 1-shortcut network is zero initialized.
+
+On the other side, if the number of shortcut connections $R = 1$ , the shortcut will only change the distribution of the output training set from $Y$ to $Y - X$ . These two extremes are illustrated in Figure 4
+
+![](images/b6ad27a7d095370272a40d30d782876e04f599d80639bba16381a8d37e154f78.jpg)  
+Figure 4: Equivalents of two extremes of $n$ -shortcut linear networks. 1-shortcut linear networks are equivalent to linear networks with identity initialization, while skip-all shortcuts will only change the effective dataset outputs.
+
+# 4.3 LEARNING RESULTS
+
+The optimal weights of an $n$ -shortcut linear network can be easily computed via least squares, which leads to
+
+$$
+W = Y X ^ { T } ( X X ^ { T } ) ^ { - 1 } = \Sigma ^ { Y X } ( \Sigma ^ { X X } ) ^ { - 1 } ,
+$$
+
+and the minimum of the loss function is
+
+$$
+L _ { \operatorname* { m i n } } = \frac { 1 } { 2 m } \| Y - \Sigma ^ { Y X } ( \Sigma ^ { X X } ) ^ { - 1 } X \| _ { F } ^ { 2 } ,
+$$
+
+where $\left\| \cdot \right\| _ { F }$ denotes the Frobenius norm and $( \Sigma ^ { X X } ) ^ { - 1 }$ denotes any kind of generalized inverse of $\Sigma ^ { X X }$ . So given a training set, we can pre-compute its $L _ { \mathrm { m i n } }$ and use it to evaluate any $n$ -shortcut linear network.
+
+# 5 EXPERIMENTS
+
+We compare networks with Xavier initialization (Glorot & Bengio, 2010), networks with orthogonal initialization (Saxe et al., 2013) and 2-shortcut networks with zero initialization. The training dynamics of 1-shortcut networks are similar to that of linear networks with orthogonal initialization in our experiments. Setup details can be found in Appendix B.
+
+# 5.1 INITIAL POINT
+
+We first compute the initial condition numbers for different kinds of linear networks with different depths.
+
+As can be seen in Figure 5, 2-shortcut linear networks have constant condition numbers as expected. On the other hand, when using Xavier or orthogonal initialization in linear networks, the initial condition numbers will go to infinity as the depths become infinity, making the networks hard to train. This also explains why orthogonal initialization is helpful for a linear network, as its initial condition number grows slower than the Xavier initialization.
+
+# 5.2 LEARNING DYNAMICS
+
+Having a good beginning does not guarantee an easy trip on the loss surface. In order to depict the loss surfaces encountered from different initial points, we plot the maxima and $1 0 ^ { \mathrm { t h } }$ percentiles (instead of minima, as they are very unstable) of the absolute values of Hessians eigenvalues at different losses.
+
+As shown in Figure 6 and Figure 7, the condition numbers of 2-shortcut networks at different losses are always smaller, especially when the loss is large. Also, notice that the condition numbers roughly evolved to the same value for both orthogonal and 2-shortcut linear networks. This may be explained by the fact that the minimizers, as well as any point near them, have similar condition numbers.
+
+![](images/e7fd6d2242db1b2949e02ba010cb7e5cb5d9c549740871ede39a2991a1117cb8.jpg)  
+Figure 5: Initial condition numbers of Hessians for different linear networks as the depths of the networks increase. Means and standard deviations are estimated based on 10 runs.
+
+![](images/e491de132755164c6b09e1268f561d391860e12cc863ba5a0230cb1de6d43673.jpg)  
+Figure 6: Maxima and $1 0 ^ { \mathrm { t h } }$ percentiles of absolute values of eigenvalues at different losses when the depth is 16. For each run, eigenvalues at different losses are calculated using linear interpolation.
+
+![](images/ba43372fef7c3f9396fae16676451e3cdd27147ecb5a9938f72a36666ccac965.jpg)  
+Figure 7: Maxima and $1 0 ^ { \mathrm { t h } }$ percentiles of absolute values of eigenvalues at different losses when the depth is 16. Eigenvalues at different losses are calculated using linear interpolation.
+
+Another observation is the changes of negative eigenvalues ratios. Index (ratio of negative eigenvalues) is an important characteristic of a critical point. Usually for the critical points of a neural network, the larger the loss the larger the index (Dauphin et al., 2014). In our experiments, the index of a 2-shortcut network is always smaller, and drops dramatically at the beginning, as shown in Figure 8, left. This might make the networks tend to stop at low critical points.
+
+![](images/0f8f47ef870bf1849218165268309fb3a477f94337f8f5859b3d68f17569a922.jpg)  
+Figure 8: Left: ratio of negative eigenvalues at different losses when the depth is 16. For each run, indexes at different losses are calculated using linear interpolation. Right: the dynamics of gradient and index of a 2-shortcut linear network in a single run. The gradient reaches its maximum while the index drops dramatically, indicating moving toward negative curvature directions.
+
+This is because the initial point is near a saddle point, thus it tends to go towards negative curvature directions, eliminating some negative eigenvalues at the beginning. This phenomenon matches the observation that the gradient reaches its maximum when the index drops dramatically, as shown in Figure 8, right.
+
+# 5.3 LEARNING RESULTS
+
+We run different networks for 1000 epochs using different learning rates at log scale, and compare the average final losses of the optimal learning rates.
+
+![](images/64bafd2db8aa80844103d468a5de18786ce11bc7a0ffb813b0996a44b26f1092.jpg)  
+Figure 9: Left: Optimal Final losses of different linear networks. Right: Corresponding optimal learning rates. When the depth is 96, the final losses of Xavier with different learning rates are basically the same, so the optimal learning rate is omitted as it is very unstable.
+
+Figure 9 shows the results for linear networks. Just like their depth-invariant initial condition numbers, the final losses of 2-shortcut linear networks stay close to optimal as the networks become deeper. Higher learning rates can also be applied, resulting in fast learning in deep networks.
+
+Then we add ReLUs to the mid positions of the networks. To make a fair comparison, the numbers of ReLU units in different networks are the same when the depths are the same, so 1-shortcut and 3-shortcut networks are omitted. The result is shown in Figure 10.
+
+![](images/1428f5f735a5850cd487815f64fb147c4ee07c34d8c8ff465fceef3b2c47cf17.jpg)  
+Figure 10: Left: Optimal Final losses of different networks with ReLUs in mid positions. Right: Corresponding optimal learning rates. Note that as it is hard to compute the minimum losses with ReLUs, we plot the $\log _ { 1 0 }$ (final loss) instead of $\log _ { 1 0 }$ (final loss − optimal loss). When the depth is 64, the final losses of Xavier-ReLU and orthogonal-ReLU with different learning rates are basically the same, so the optimal learning rates are omitted as they are very unstable.
+
+Note that because of the nonlinearities, the optimal losses vary for different networks with different depths. It is usually thought that deeper networks can represent more complex models, leading to smaller optimal losses. However, our experiments show that linear networks with Xavier or orthogonal initialization have difficulties finding these optimal points, while 2-shortcut networks find these optimal points easily as they did without nonlinear units.
+
+# 6 FUTURE DIRECTIONS
+
+Further studies should concentrate on the behavior of shortcut connections on convolution networks, as well as the influences of batch normalization units (Ioffe & Szegedy, 2015) in ResNet. Meanwhile, it would be very interesting to extend the insights obtained in this paper to recurrent neural networks such as LSTM (Sainath et al., 2013).
+
+# REFERENCES
+
+Anima Anandkumar and Rong Ge. Efficient approaches for escaping higher order saddle points in non-convex optimization. arXiv preprint arXiv:1602.05908, 2016.
+
+Chris Bishop. Exact calculation of the hessian matrix for the multilayer perceptron. Neural Computation, 4(4):494–501, 1992.
+
+Anna Choromanska, Mikael Henaff, Michael Mathieu, Gerard Ben Arous, and Yann LeCun. The ´ loss surfaces of multilayer networks. In AISTATS, 2015a.
+
+Anna Choromanska, Yann LeCun, and Gerard Ben Arous. Open problem: The landscape of the ´ loss surfaces of multilayer networks. In Proceedings of The 28th Conference on Learning Theory, COLT 2015, Paris, France, July 3, volume 6, pp. 1756–1760, 2015b.
+
+Yann N Dauphin, Razvan Pascanu, Caglar Gulcehre, Kyunghyun Cho, Surya Ganguli, and Yoshua Bengio. Identifying and attacking the saddle point problem in high-dimensional non-convex optimization. In Advances in neural information processing systems, pp. 2933–2941, 2014.
+
+Rong Ge, Furong Huang, Chi Jin, and Yang Yuan. Escaping from saddle pointsonline stochastic gradient for tensor decomposition. In Proceedings of The 28th Conference on Learning Theory, pp. 797–842, 2015.
+
+Xavier Glorot and Yoshua Bengio. Understanding the difficulty of training deep feedforward neural networks. In Aistats, volume 9, pp. 249–256, 2010.
+
+Robert M Gray. Toeplitz and circulant matrices: A review. now publishers inc, 2006.
+
+Moritz Hardt and Tengyu Ma. Identity matters in deep learning. arXiv preprint arXiv:1611.04231, 2016.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. arXiv preprint arXiv:1512.03385, 2015a.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Delving deep into rectifiers: Surpassing human-level performance on imagenet classification. In Proceedings of the IEEE International Conference on Computer Vision, pp. 1026–1034, 2015b.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Identity mappings in deep residual networks. arXiv preprint arXiv:1603.05027, 2016.
+
+Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. arXiv preprint arXiv:1502.03167, 2015.
+
+Kenji Kawaguchi. Deep learning without poor local minima. arXiv preprint arXiv:1605.07110, 2016.
+
+Vinod Nair and Geoffrey E Hinton. Rectified linear units improve restricted boltzmann machines. In Proceedings of the 27th International Conference on Machine Learning (ICML-10), pp. 807–814, 2010.
+
+Arkadi Nemirovski. Efficient methods in convex programming. 2005.
+
+Razvan Pascanu, Yann N Dauphin, Surya Ganguli, and Yoshua Bengio. On the saddle point problem for non-convex optimization. arXiv preprint arXiv:1405.4604, 2014.
+
+T.N. Sainath, O. Vinyals, A. Senior, and H. Sak. Convolutional, Long short-term memory, fully connected deep neural networks. Journal of Chemical Information and Modeling, 53(9):1689– 1699, 2013. ISSN 1098-6596. doi: 10.1017/CBO9781107415324.004.
+
+Andrew M Saxe, James L McClelland, and Surya Ganguli. Exact solutions to the nonlinear dynamics of learning in deep linear neural networks. arXiv preprint arXiv:1312.6120, 2013.
+
+Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. arXiv preprint arXiv:1409.1556, 2014.
+
+Rupesh K Srivastava, Klaus Greff, and Jurgen Schmidhuber. Training very deep networks. In ¨ Advances in neural information processing systems, pp. 2377–2385, 2015a.
+
+Rupesh Kumar Srivastava, Klaus Greff, and Jurgen Schmidhuber. Highway networks. ¨ arXiv preprint arXiv:1505.00387, 2015b.
+
+Christian Szegedy, Sergey Ioffe, and Vincent Vanhoucke. Inception-v4, Inception-ResNet and the Impact of Residual Connections on Learning. feb 2016. URL http://arxiv.org/abs/ 1602.07261.
+
+Sasha Targ, Diogo Almeida, and Kevin Lyman. Resnet in resnet: Generalizing residual architectures. arXiv preprint arXiv:1603.08029, 2016.
+
+Andreas Veit, Michael Wilber, and Serge Belongie. Residual networks are exponential ensembles of relatively shallow networks. arXiv preprint arXiv:1605.06431, 2016.
+
+Sergey Zagoruyko and Nikos Komodakis. Wide residual networks. arXiv preprint arXiv:1605.07146, 2016.
+
+Ke Zhang, Miao Sun, Tony X Han, Xingfang Yuan, Liru Guo, and Tao Liu. Residual networks of residual networks: Multilevel residual networks. arXiv preprint arXiv:1608.02908, 2016.
+
+# A PROOFS OF THEOREMS
+
+Definition 5. The elements in Hessian of an $n$ -shortcut network is defined as
+
+$$
+H _ { \mathrm { i n d } ( w _ { 1 } ) , \mathrm { i n d } ( w _ { 2 } ) } = \frac { \partial ^ { 2 } L } { \partial w _ { 1 } \partial w _ { 2 } } ,
+$$
+
+where $L$ is the loss function, and the indices $\operatorname { i n d } ( \cdot )$ is ordered lexicographically following the four indices $( r , l , j , i )$ of the weight variable $\underset { \cdot } { w _ { i , j } ^ { r , l } }$ . In other words, the priority decreases along the index of shortcuts, index of weight matrix inside shortcuts, index of column, and index of row.
+
+Note that the collection of all the weight variables in the $n$ -shortcut network is denoted as w. We study the behavior of the loss function in the vicinity of ${ \bf w } = { \bf 0 }$ .
+
+Lemma 1. Assume that $w _ { 1 } \ = \ w _ { i _ { 1 } , j _ { 1 } } ^ { r _ { 1 } , l _ { 1 } } , \cdot \cdot \cdot , w _ { N } \ = \ w _ { i _ { N } , j _ { N } } ^ { r _ { N } , l _ { N } }$ are $N$ parameters of an $n$ -shortcut network. If ∂ L∂w1···∂wN $\begin{array} { r } { I f \frac { \partial ^ { 2 } L } { \partial w _ { 1 } \cdots \partial w _ { N } } \bigg | _ { \mathbf { w } = \mathbf { 0 } } } \end{array}$ is nonzero, there exists $r$ and $k _ { 1 } , \cdots , k _ { n }$ such that $r _ { k _ { m } } = r a n d l _ { k _ { m } } = m$ for $m = 1 , \cdots , n$ .
+
+Proof. Assume there does not exist such $r$ and $k _ { 1 } , \cdots , k _ { n }$ , then for all the shortcut units $r =$ $1 , \cdots , R$ , there exists a weight matrix $l$ such that none of $w _ { 1 } , \cdots , w _ { N }$ is in $W ^ { r , l }$ , so all the transformation paths are zero, which means $W = I _ { d _ { x } }$ . Then $\left. \frac { \partial ^ { 2 } L } { \partial w _ { 1 } \cdots \partial w _ { N } } \right| _ { { \bf w } = { \bf 0 } } = 0$ , leading to a contradiction. □
+
+Lemma 2. Assume that $w _ { 1 } = w _ { i _ { 1 } , j _ { 1 } } ^ { r _ { 1 } , l _ { 1 } } , w _ { 2 } = w _ { i _ { 2 } , j _ { 2 } } ^ { r _ { 2 } , l _ { 2 } } , r _ { 1 } \le r _ { 2 }$ . Let $L _ { 0 } ( w _ { 1 } , w _ { 2 } )$ denotes the loss function with all the parameters except 0 $w _ { 1 }$ and $w _ { 2 }$ set to $O _ { ; }$ , $w _ { 1 } ^ { \prime } = w _ { i _ { 1 } , j _ { 1 } } ^ { 1 , l _ { 1 } } , w _ { 2 } ^ { \prime } = w _ { i _ { 2 } , j _ { 2 } } ^ { 1 + \mathbb { 1 } ( r _ { 1 } \neq r _ { 2 } ) , l _ { 2 } }$ . Then $\begin{array} { r } { \frac { \partial ^ { 2 } L _ { 0 } ( w _ { 1 } , w _ { 2 } ) } { \partial w _ { 1 } \partial w _ { 2 } } | _ { ( w _ { 1 } , w _ { 2 } ) = 0 } = \frac { \partial ^ { 2 } L _ { 0 } ( w _ { 1 } ^ { \prime } , w _ { 2 } ^ { \prime } ) } { \partial w _ { 1 } ^ { \prime } \partial w _ { 2 } ^ { \prime } } | _ { ( w _ { 1 } ^ { \prime } , w _ { 2 } ^ { \prime } ) = 0 } . } \end{array}$
+
+Proof. As all the residual units expect unit $r _ { 1 }$ and $r _ { 2 }$ are identity transformations, reordering residual units while preserving the order of units $r _ { 1 }$ and $r _ { 2 }$ will not affect the overall transformation, i.e. $L _ { 0 } ( w _ { 1 } , w _ { 2 } ) | _ { w _ { 1 } = a , w _ { 2 } = b } ~ = ~ L _ { 0 } ^ { \prime } ( w _ { 1 } ^ { \prime } , w _ { 2 } ^ { \prime } ) | _ { w _ { 1 } ^ { \prime } = a , w _ { 2 } ^ { \prime } = b }$ . So $\frac { \partial ^ { 2 } L _ { 0 } ( w _ { 1 } , w _ { 2 } ) } { \partial w _ { 1 } \partial w _ { 2 } } | _ { ( w _ { 1 } , w _ { 2 } ) = { \bf 0 } } =$ $\frac { \partial ^ { 2 } L _ { 0 } ( w _ { 1 } ^ { \prime } , w _ { 2 } ^ { \prime } ) } { \partial w _ { 1 } ^ { \prime } \partial w _ { 2 } ^ { \prime } } \big | _ { ( w _ { 1 } ^ { \prime } , w _ { 2 } ^ { \prime } ) = { \bf 0 } }$ . □
+
+Proof of Theorem 1. Now we can prove Theorem 1 with the help of the previously established lemmas.
+
+1. Using Lemma 1, for an $n$ -shortcut network, at zero, all the $k$ -th order partial derivatives of the loss function are zero, where $k$ ranges from 1 to $n - 1$ . Hence, the initial point zero is a $( n - 1 )$ th-order stationary point of the loss function.
+
+2. Consider the Hessian in $n = 2$ case. Using Lemma 1 and Lemma 2, the form of Hessian can be directly written as Equation (11), as illustrated in Figure 11.
+
+So we have
+
+$$
+\mathrm { e i g s } ( H ) = \mathrm { e i g s } ( \left[ { \bf 0 } \quad A ^ { T } \right] ) = \pm \sqrt { \mathrm { e i g s } ( A ^ { T } A ) } .
+$$
+
+Thus $\operatorname { c o n d } ( H ) = { \sqrt { \operatorname { c o n d } ( A ^ { T } A ) } }$ , which is depth-invariant. Note that the dimension of $A$ is $d _ { x } ^ { 2 } \times d _ { x } ^ { 2 }$ .
+
+To get the expression of $A$ , consider two parameters that are in the same residual unit but different weight matrices, i.e. $w _ { 1 } = w _ { i _ { 1 } , j _ { 1 } } ^ { r , 2 } , w _ { 2 } = w _ { i _ { 2 } , j _ { 2 } } ^ { r , 1 }$ .
+
+![](images/963e9a8de93364de78d221fd32e403c39d4e55d5d393094e5790d48bdff4c5ee.jpg)  
+Figure 11: The Hessian in $n = 2$ case. It follows from Lemma 1 that only off-diagonal subblocks in each diagonal block, i.e., the blocks marked in orange (slash) and blue (chessboard), are non-zero. From Lemma 2, we conclude the translation invariance and that all blocks marked in orange (slash) (resp. blue (chessboard)) are the same. Given that the Hessian is symmetric, the blocks marked in blue and orange are transposes of each other, and thus it can be directly written as Equation (11).
+
+If $j _ { 1 } = i _ { 2 }$ , we have
+
+$$
+\begin{array} { l } { { A _ { ( j _ { 1 } - 1 ) d _ { x } + i _ { 1 } , ( j _ { 2 } - 1 ) d _ { x } + i _ { 2 } } = \displaystyle \frac { \partial ^ { 2 } { \cal L } } { \partial w _ { 1 } \partial w _ { 2 } } \Big | _ { { \bf w } = { \bf 0 } } } } \\  { { \phantom { A } = \displaystyle \frac { \partial ^ { 2 } \sum _ { \mu = 1 } ^ { m } \frac { 1 } { 2 m } ( y _ { i _ { 1 } } ^ { \mu } - x _ { i _ { 1 } } ^ { \mu } - \sigma _ { \mathrm { p o s t } } ( w _ { 1 } \sigma _ { \mathrm { m i d } } ( w _ { 2 } \sigma _ { \mathrm { p r e } } ( x _ { j _ { 2 } } ^ { \mu } ) ) ) ) ^ { 2 } } { \partial w _ { 1 } \partial w _ { 2 } } \Big | _ { { \bf w } = { \bf 0 } } } } \\  { { \phantom { A } = \displaystyle \frac { \sigma _ { \mathrm { m i d } } ^ { \prime } ( 0 ) \sigma _ { \mathrm { p o s t } } ^ { \prime } ( 0 ) } { m } \sum _ { \mu = 1 } ^ { m } \sigma _ { \mathrm { p r e } } ( x _ { j _ { 2 } } ^ { \mu } ) ( x _ { i _ { 1 } } ^ { \mu } - y _ { i _ { 1 } } ^ { \mu } ) . } } \end{array}
+$$
+
+Else, we have $A _ { ( j _ { 1 } - 1 ) d _ { x } + i _ { 1 } , ( j _ { 2 } - 1 ) d _ { x } + i _ { 2 } } = 0 .$
+
+Noting that $A _ { ( j _ { 1 } , \ldots , 1 ) d _ { x } + i _ { 1 } , ( j _ { 2 } - 1 ) d _ { x } + i _ { 2 } }$ in fact only depends on the two indices $i _ { 1 } , j _ { 2 }$ (with a small difference depending on whether $\begin{array} { r l r } { j _ { 1 } } & { { } = } & { i _ { 2 } ) } \end{array}$ , we make a $d _ { x } \mathrm { ~  ~ \times ~ }$ $d _ { x }$ matrix with rows indexed by $i _ { 1 }$ and columns indexed by $j _ { 2 }$ , and the entry at $( i _ { 1 } , j _ { 2 } )$ equal to $A _ { ( j _ { 1 } - 1 ) d _ { x } + i _ { 1 } , ( j _ { 2 } - 1 ) d _ { x } + i _ { 2 } }$ . Apparently, this matrix is equal to $\sigma _ { \mathrm { m i d } } ^ { \prime } ( 0 ) \sigma _ { \mathrm { p o s t } } ^ { \prime } ( 0 ) \bigl ( \Sigma ^ { X \sigma _ { \mathrm { p r e } } ( X ) } - \Sigma ^ { Y \sigma _ { \mathrm { p r e } } ( X ) } \bigr )$ when $j _ { 1 } ~ = ~ i _ { 2 }$ , and equal to the zero matrix when $j _ { 1 } \neq i _ { 2 }$ .
+
+To simplify the expression of $A$ , we rearrange the columns of $A$ by a permutation matrix, i.e.
+
+$$
+A ^ { \prime } = A P ,
+$$
+
+where $P _ { i j } = 1$ if and only if $\begin{array} { r } { i = ( ( j - 1 ) \bmod d _ { x } ) d _ { x } + \lceil \frac { j } { d _ { x } } \rceil } \end{array}$ . Basically it permutes the $i$ -th column of $A$ to the $j$ -th column.
+
+Then we have
+
+$$
+A = \sigma _ { \mathrm { m i d } } ^ { \prime } ( 0 ) \sigma _ { \mathrm { p o s t } } ^ { \prime } ( 0 ) \left[ \begin{array} { l l l l } { \Sigma ^ { X \sigma _ { \mathrm { p r e } } ( X ) } - \Sigma ^ { Y \sigma _ { \mathrm { p r e } } ( X ) } } & & & \\ & & { \ddots } & & \\ & & & { \Sigma ^ { X \sigma _ { \mathrm { p r e } } ( X ) } - \Sigma ^ { Y \sigma _ { \mathrm { p r e } } ( X ) } } \end{array} \right] P ^ { T } .
+$$
+
+So the eigenvalues of $H$ becomes
+
+$$
+\begin{array} { r } { \mathrm { e i g s } ( H ) = \pm \sigma _ { \mathrm { m i d } } ^ { \prime } ( 0 ) \sigma _ { \mathrm { p o s t } } ^ { \prime } ( 0 ) \sqrt { \mathrm { e i g s } \big ( ( \Sigma ^ { X \sigma _ { \mathrm { p r e } } } ( X ) - \Sigma ^ { Y \sigma _ { \mathrm { p r e } } } ( X ) \big ) T \big ( \Sigma ^ { X \sigma _ { \mathrm { p r e } } } ( X ) - \Sigma ^ { Y \sigma _ { \mathrm { p r e } } } ( X ) \big ) \big ) } , } \end{array}
+$$
+
+which leads to Equation (12).
+
+3. Now consider the Hessian in the $n = 1$ case. Using Lemma 2, the form of Hessian can be directly written as Equation (13).
+
+To get the expressions of $A$ and $B$ in $\sigma _ { \mathrm { p r e } } ( x ) = \sigma _ { \mathrm { p o s t } } ( x ) = x$ case, consider two parameters that are in the same residual units, i.e. $w _ { 1 } = w _ { i _ { 1 } , j _ { 1 } } ^ { r , 1 } , w _ { 2 } = w _ { i _ { 2 } , j _ { 2 } } ^ { r , 1 }$ .
+
+We have
+
+$$
+\begin{array} { r l } { B _ { ( j _ { 1 } - 1 ) d _ { x } + i _ { 1 } , ( j _ { 2 } - 1 ) d _ { x } + i _ { 2 } } = \frac { \partial ^ { 2 } { \cal L } } { \partial w _ { 1 } \partial w _ { 2 } } \Big | _ { { \bf w } = { \bf 0 } } } & { { } } \\ { \quad \quad } & { { } = \left\{ \begin{array} { l l } { \frac { 1 } { m } \sum _ { \mu = 1 } ^ { m } x _ { j _ { 1 } } ^ { \mu } x _ { j _ { 2 } } ^ { \mu } } & { i _ { 1 } = i _ { 2 } } \\ { 0 } & { i _ { 1 } \ne i _ { 2 } } \end{array} \right. } \end{array}
+$$
+
+Rearrange the order of variables using $P$ , we have
+
+$$
+\boldsymbol { B } = \boldsymbol { P } \left[ \begin{array} { l l l } { \boldsymbol { \Sigma } ^ { X X } } & & \\ & { \boldsymbol { \cdot } } & \\ & & { \boldsymbol { \cdot } \boldsymbol { \cdot } } \\ & & & { \boldsymbol { \Sigma } ^ { X X } } \end{array} \right] \boldsymbol { P } ^ { T } .
+$$
+
+Then consider two parameters that are in different residual units, i.e. $w _ { 1 } = w _ { i _ { 1 } , j _ { 1 } } ^ { r _ { 1 } , 1 } , w _ { 2 } =$   
+$w _ { i _ { 2 } , j _ { 2 } } ^ { r _ { 2 } , 1 } , r _ { 1 } > r _ { 2 }$ .
+
+We have
+
+$$
+\begin{array} { l l } { { A _ { ( j _ { 1 } - 1 ) d _ { x } + i _ { 1 } , ( j _ { 2 } - 1 ) d _ { x } + i _ { 2 } } = \displaystyle \frac { \partial ^ { 2 } { \cal L } } { \partial w _ { 1 } \partial w _ { 2 } } \Big | _ { { \bf w } = { \bf 0 } } } } \\ { { \ } } \\ { { \quad = \left\{ \begin{array} { l l } { { \frac { 1 } { m } \sum _ { \mu = 1 } ^ { m } ( x _ { i _ { 1 } } ^ { \mu } - y _ { i _ { 1 } } ^ { \mu } ) x _ { j _ { 2 } } ^ { \mu } + x _ { j _ { 1 } } ^ { \mu } x _ { j _ { 2 } } ^ { \mu } } } & { { j _ { 1 } = i _ { 2 } , i _ { 1 } = i _ { 2 } } } \\ { { \frac { 1 } { m } \sum _ { \mu = 1 } ^ { m } ( x _ { i _ { 1 } } ^ { \mu } - y _ { i _ { 1 } } ^ { \mu } ) x _ { j _ { 2 } } ^ { \mu } } } & { { j _ { 1 } = i _ { 2 } , i _ { 1 } \neq i _ { 2 } } } \\ { { \frac { 1 } { m } \sum _ { \mu = 1 } ^ { m } x _ { j _ { 1 } } ^ { \mu } x _ { j _ { 2 } } ^ { \mu } } } & { { j _ { 1 } \neq i _ { 2 } , i _ { 1 } = i _ { 2 } } } \\ { { 0 } } & { { j _ { 1 } \neq i _ { 2 } , i _ { 1 } \neq i _ { 2 } } } \end{array} \right. } } \end{array}
+$$
+
+In the same way, we can rewrite $A$ as
+
+$$
+\boldsymbol { A } = \left[ \begin{array} { l l l } { \boldsymbol { \Sigma } ^ { X X } - \boldsymbol { \Sigma } ^ { Y X } } & & \\ & { \boldsymbol { \cdot } } & \\ & & { \boldsymbol { \cdot } \boldsymbol { \cdot } } & \\ & & { \boldsymbol { \Sigma } ^ { X X } - \boldsymbol { \Sigma } ^ { Y X } } \end{array} \right] \boldsymbol { P } ^ { T } + \boldsymbol { B } .
+$$
+
+# B EXPERIMENT SETUP
+
+We took the experiments on whitened versions of MNIST. 10 greatest principal components are kept for the dataset inputs. The dataset outputs are represented using one-hot encoding. The network was trained using gradient descent. For every epoch, the Hessians of the networks were calculated using the method proposed in (Bishop, 1992). As the $| \lambda | _ { \operatorname* { m i n } }$ of Hessian is usually very unstable, we calculated $\frac { | \lambda | _ { \operatorname* { m a x } } } { | \lambda | _ { ( 0 . 1 ) } }$ to represent condition number instead, where $| \lambda | _ { ( 0 . 1 ) }$ is the $1 0 ^ { \mathrm { t h } }$ percentile of the absolute values of eigenvalues.
+
+As pre, mid or post positions are not defined in linear networks without shortcuts, when comparing Xavier or orthogonal initialized linear networks to 2-shortcut networks, we added ReLUs at the same positions in linear networks as in 2-shortcuts networks.

parse/train/SJAr0QFxe/SJAr0QFxe_content_list.json

@@ -0,0 +1,2214 @@
+[
+    {
+        "type": "text",
+        "text": "DEMYSTIFYING RESNET ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            99,
+            473,
+            121
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Jiantao Jiao, Yanjun Han, Tsachy Weissman ",
+        "text_level": 1,
+        "bbox": [
+            508,
+            145,
+            818,
+            160
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Sihan Li   \nDepartment of Electronic Engineering   \nTsinghua University   \nBeijing 100084, China   \nlisihan13@mails.tsinghua.edu.cn   \nDepartment of Electrical Engineering   \nStanford University   \nStanford, CA 94305, USA   \n{jiantao,yjhan,tsachy}@stanford.edu ",
+        "bbox": [
+            183,
+            145,
+            486,
+            214
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            506,
+            160,
+            846,
+            215
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            252,
+            544,
+            266
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We provide a theoretical explanation for the great performance of ResNet via the study of deep linear networks and some nonlinear variants. We show that with or without nonlinearities, by adding shortcuts that have depth two, the condition number of the Hessian of the loss function at the zero initial point is depthinvariant, which makes training very deep models no more difficult than shallow ones. Shortcuts of higher depth result in an extremely flat (high-order) stationary point initially, from which the optimization algorithm is hard to escape. The 1- shortcut, however, is essentially equivalent to no shortcuts. Extensive experiments are provided accompanying our theoretical results. We show that initializing the network to small weights with 2-shortcuts achieves significantly better results than random Gaussian (Xavier) initialization, orthogonal initialization, and shortcuts of deeper depth, from various perspectives ranging from final loss, learning dynamics and stability, to the behavior of the Hessian along the learning process. ",
+        "bbox": [
+            233,
+            281,
+            764,
+            462
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            487,
+            336,
+            502
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Residual network (ResNet) was first proposed in He et al. (2015a) and extended in He et al. (2016). It followed a principled approach to add shortcut connections every two layers to a VGG-style network (Simonyan & Zisserman, 2014). The new network becomes easier to train, and achieves both lower training and test errors. Using the new structure, He et al. (2015a) managed to train a network with 1001 layers, which was virtually impossible before. Unlike Highway Network (Srivastava et al., 2015a;b) which not only has shortcut paths but also borrows the idea of gates from LSTM (Sainath et al., 2013), ResNet does not have gates. Later He et al. (2016) found that by keeping a clean shortcut path, residual networks will perform even better. ",
+        "bbox": [
+            174,
+            517,
+            825,
+            628
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Many attempts have been made to improve ResNet to a further extent. “ResNet in ResNet” (Targ et al., 2016) adds more convolution layers and data paths to each layer, making it capable of representing several types of residual units. “ResNets of ResNets” (Zhang et al., 2016) construct multilevel shortcut connections, which means there exist shortcuts that skip multiple residual units. Wide Residual Networks (Zagoruyko & Komodakis, 2016) makes the residual network shorter but wider, and achieves state of the art results on several datasets while using a shallower network. Moreover, some existing models are also reported to be improved by shortcut connections, including Inceptionv4 (Szegedy et al., 2016), in which shortcut connections make the deep network easier to train. ",
+        "bbox": [
+            174,
+            636,
+            825,
+            747
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Why are residual networks so easy to train? He et al. (2015a) suggests that layers in residual networks are learning residual mappings, making them easier to represent identity mappings, which prevents the networks from degradation when the depths of the networks increase. However, Veit et al. (2016) claims that ResNets are actually ensembles of shallow networks, which means they do not solve the problem of training deep networks completely. ",
+        "bbox": [
+            174,
+            753,
+            823,
+            824
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We propose a theoretical explanation for the great performance of ResNet. We concur with He et al. (2015a) that the key contribution of ResNet should be some special structure of the loss function that makes training very deep models no more difficult than shallow ones. Analysis, however, seems non-trivial. Quoting He et al. (2015a): ",
+        "bbox": [
+            176,
+            830,
+            823,
+            886
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "“Deeper non-bottleneck ResNets (e.g., Fig. 5 left) also gain accuracy from increased depth (as shown on CIFAR-10), but are not as economical as the bottleneck ResNets. So the usage of bottleneck designs is mainly due to practical considerations. We further note that the degradation problem of plain nets is also witnessed for the bottleneck designs. ",
+        "bbox": [
+            205,
+            99,
+            792,
+            155
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Their empirical observations are inspiring. First, the 1-shortcuts mentioned in the first paragraph do not work. Second, noting that the non-bottleneck ResNets have 2-shortcuts, but the bottleneck ResNets use 3-shortcuts, one sees that shortcuts with depth three also do not work. Hence, a reasonable theoretical explanation must be able to distinguish the 2-shortcut from shortcuts of other depths, and clearly demonstrate why the 2-shortcuts are special and are able to ease the optimization process so significantly for deep models, while shortcuts of other depths may not do the job. ",
+        "bbox": [
+            173,
+            174,
+            825,
+            258
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Aiming at explaining the performance of 2-shortcuts, we need to eliminate other variables that may contribute to the success of ResNet. Indeed, one may argue that the deep structure of ResNet may give it better representation power (lower approximation error), which contributes to lower training errors. To eliminate this effect, we focus on deep linear networks, where deeper models do not have better approximation properties. The special role of 2-shortcuts naturally arises in the study. ",
+        "bbox": [
+            174,
+            265,
+            825,
+            335
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 MAIN RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            354,
+            333,
+            371
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our work reveals that non-degenerate depth-invariant initial condition numbers, a unique property of residual networks with 2-shortcuts, contributed to the success of ResNet. In fact, in a linear network that will be defined rigorously later, the condition number of Hessian of the Frobenius loss function at the zero initial point is ",
+        "bbox": [
+            174,
+            386,
+            825,
+            443
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5be7ac018348d5302ec0d45cf57679b3c5aeee8031b4976536fc3191af7d5017.jpg",
+        "text": "$$\n\\operatorname { c o n d } ( H ) = { \\sqrt { \\operatorname { c o n d } ( ( \\Sigma ^ { X X } - \\Sigma ^ { Y X } ) ^ { T } ( \\Sigma ^ { X X } - \\Sigma ^ { Y X } ) ) } } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            313,
+            459,
+            683,
+            487
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "which is independent of the number of layers. Here $\\Sigma ^ { X X }$ and $\\Sigma ^ { Y X }$ denote the input-input and the output-input correlation matrices, defined in Section 3.3. The condition number of a possibly non-PSD matrix is defined as: ",
+        "bbox": [
+            176,
+            489,
+            825,
+            532
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Definition 1. The condition number of a matrix $A$ is defined as ",
+        "bbox": [
+            173,
+            536,
+            591,
+            551
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8a2cf4ebe7e14ccf62c1b6d1e2abecd5351a3c34e492c8bae90704af18023ef3.jpg",
+        "text": "$$\n\\operatorname { c o n d } ( A ) = \\frac { \\sigma _ { \\operatorname* { m a x } } ( A ) } { \\sigma _ { \\operatorname* { m i n } } ( A ) } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            423,
+            554,
+            575,
+            589
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $\\sigma _ { \\mathrm { m a x } } ( A )$ and $\\sigma _ { \\mathrm { m i n } } ( A )$ are the maximum and minimum of singular values of $A$ . In particular, if $A$ is normal, i.e. $A ^ { T } A \\stackrel { \\cdot } { = } A A ^ { T }$ , the definition can be simplified to 1 ",
+        "bbox": [
+            174,
+            594,
+            825,
+            623
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/df628740e71bddeb77454d447f4e3736a90f10a14998985894b8400079e55c60.jpg",
+        "text": "$$\n\\mathrm { c o n d } ( A ) = { \\frac { | \\lambda ( A ) | _ { \\operatorname* { m a x } } } { | \\lambda ( A ) | _ { \\operatorname* { m i n } } } } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            416,
+            628,
+            578,
+            664
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $| \\lambda ( A ) | _ { \\mathrm { m a x } }$ and $| \\lambda ( A ) | _ { \\mathrm { m i n } }$ are the maximum and minimum of the absolute values of eigenvalues of $A$ . ",
+        "bbox": [
+            176,
+            670,
+            823,
+            698
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Moreover, the zero initial point for ResNet with 2-shortcuts is in fact a so-called strict saddle point (Ge et al., 2015), which are proved to be easy to escape from. ",
+        "bbox": [
+            174,
+            709,
+            821,
+            738
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Why shortcuts of other depths do not work? We show that the Hessian at the zero initial point for the 1-shortcut ResNet has condition number growing unboundedly for deep nets. As is well known in convex optimization theory, large condition numbers can have enormous adversarial impact on the convergence of first order methods (Nemirovski, 2005). Hence, it is quite clear that starting training at a point with a huge condition number would make the algorithm very difficult to escape from the initial point, making 1-shortcut ResNet no better than conventional approaches. ",
+        "bbox": [
+            173,
+            744,
+            825,
+            829
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "For shortcuts with depth deeper than two, the Hessian at the zero initial point is a zero matrix, making it a higher-order stationary point. Intuitively, the higher order the stationary point is, the harder it is to escape from it. Indeed, it is supported both in theory (Anandkumar & Ge, 2016) and by our experiments. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            159
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "One may still ask: why are we interested in the Hessian at the zero initial point? It is because in order for the outputs of deep neural networks not explode, the singular values of the mapping of each layer are not supposed to be deviating too much from one. Indeed, it is because it is extremely challenging to keep Qnum of layersi=1 λi from exploding or vanishing without keeping all of the λi having unit norm. However, by design ResNet with shortcuts already have an identity mapping every few layers, which forces the mappings inside the shortcuts to have small operator norms. Hence, analyzing the network at zero initial point gives a decent characterization of the searching environment of the optimization algorithm. ",
+        "bbox": [
+            174,
+            166,
+            825,
+            280
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our results also shows that the form of Hessian is more important than the existance of nonlinearities when training the networks. The behaviors of the networks we studied are consistent across both linear and nonlinear structures, where networks with clearer Hessians are much easier to achieve lower training errors. ",
+        "bbox": [
+            176,
+            287,
+            825,
+            343
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "On the other hand, our experiments reveal that orthogonal initialization (Saxe et al., 2013) is suboptimal. Although better than Xavier initialization (Glorot & Bengio, 2010), the initial condition numbers of the networks still explode as the networks become deeper, which means the networks are still initialized on “bad” submanifolds that are hard to optimize using gradient descent. ",
+        "bbox": [
+            174,
+            349,
+            823,
+            406
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 MODEL ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            425,
+            267,
+            441
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 DEEP LINEAR NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            458,
+            392,
+            472
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Deep linear networks are feed-forward neural networks that only contain linear units, which means their input-output mappings are simply linear transformations. Apparently, increasing their depths will not affect the representational power of the networks. However, linear networks with depth deeper than one show nonlinear dynamics of training (Saxe et al., 2013). As a result, analyzing the training of deep linear networks gives us a better understanding of the training of non-linear networks. ",
+        "bbox": [
+            174,
+            483,
+            823,
+            566
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Much theoretical work has been done on deep linear networks. Kawaguchi (2016) extended the work of Choromanska et al. (2015a;b) and proved that with few assumptions, every local minimum point in deep linear networks is a global minimum point. This means that the difficulties in the training of deep linear networks mostly come from saddle points on the loss surfaces, which are also the main causes of slow learning in nonlinear networks (Pascanu et al., 2014). ",
+        "bbox": [
+            174,
+            574,
+            825,
+            643
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Saxe et al. (2013) studied the dynamics of training using gradient descent. They found that for a special class of initial conditions, which could be obtained from greedy layerwise pre-training, the training time for a deep linear network with an infinity depth can still be finite. Furthermore, they found that by setting the initial weights to random orthogonal matrices (produced by performing QR or SVD decompositions on random Gaussian matrices), the network will still have a depth independent learning time. They argue that it is caused by the eigenvalue and singular value spectra of the end-to-end linear transformation. When using orthogonal initialization, the overall transformation is an orthogonal matrix, which has all the singular values equal to 1. In the meantime, when using scaled Gaussian initialization, most of the singular values are close to zero, making the network unsuitable for backpropagating errors. However, this explanation is not sufficient to prove that the training difficulty of orthogonal initialized networks is depth-invariant. It only gives us an intuition on why orthogonal initialization performs better than scaled Gaussian initialization. ",
+        "bbox": [
+            174,
+            651,
+            825,
+            818
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Thus, we use deep linear networks to study the effect of shortcut connections. After adding the shortcuts, the overall model is still linear and the global minimum does not change. ",
+        "bbox": [
+            174,
+            824,
+            821,
+            853
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2 NETWORK STRUCTURE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            869,
+            375,
+            883
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We first generalize a linear network by adding shortcuts to it to make it a linear residual network. We organize the network into $R$ residual units. The $r$ -th residual unit consists of $L _ { r }$ layers whose ",
+        "bbox": [
+            176,
+            895,
+            823,
+            922
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "weights are $W ^ { r , 1 } , \\ldots , W ^ { r , L _ { r } - 1 }$ , denoted as the transformation path, as well as a shortcut $S ^ { r }$ connecting from the first layer to the last one, denoted as the shortcut path. The input-output mapping can be written as ",
+        "bbox": [
+            173,
+            102,
+            825,
+            146
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ca913de6fdb8650d9bcc9b0d7529650a960161a96e38ef77bc815aab35858b84.jpg",
+        "text": "$$\ny = \\prod _ { r = 1 } ^ { R } ( \\prod _ { l = 1 } ^ { L _ { r } - 1 } W ^ { r , l } + S ^ { r } ) x = W x ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            379,
+            164,
+            617,
+            208
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $x \\in \\mathbb { R } ^ { d _ { x } } , y \\in \\mathbb { R } ^ { d _ { y } } , W \\in \\mathbb { R } ^ { d _ { y } \\times d _ { x } }$ . Here if $b \\_ { a }$ , $\\textstyle \\prod _ { i = a } ^ { b } W ^ { i }$ denotes $W ^ { b } W ^ { ( b - 1 ) } \\cdot \\cdot \\cdot W ^ { ( a + 1 ) } W ^ { a }$ , otherwise it denotes an identity mapping. The matrix $W$ represents the combination of all the linear transformations in the network. Note that by setting all the shortcuts to zeros, the network will go back to a $\\begin{array} { r } { ( \\sum _ { r } ( L _ { r } - 1 ) + 1 ) } \\end{array}$ -layer plain linear network. ",
+        "bbox": [
+            173,
+            220,
+            825,
+            284
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Instead of analyzing the general form, we concentrate on a special kind of linear residual networks, where all the residual units are the same. ",
+        "bbox": [
+            173,
+            287,
+            825,
+            318
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Definition 2. A linear residual network is called an $n$ -shortcut linear network if ",
+        "bbox": [
+            173,
+            321,
+            700,
+            337
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "1. its layers have the same dimension (so that $d _ { x } = d _ { y }$ );   \n2. its shortcuts are identity matrices;   \n3. its shortcuts have the same depth $n$ . ",
+        "bbox": [
+            210,
+            348,
+            583,
+            414
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The input-output mapping for such a network becomes ",
+        "bbox": [
+            174,
+            424,
+            534,
+            440
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/391fc67ead60be613969e4cf24cf13553ca6e7063a8477814b0e54a73b20f3cc.jpg",
+        "text": "$$\ny = \\prod _ { r = 1 } ^ { R } ( \\prod _ { l = 1 } ^ { n } W ^ { r , l } + I _ { d _ { x } } ) x = W x ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            382,
+            458,
+            614,
+            502
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $W ^ { r , l } \\in \\mathbb { R } ^ { d _ { x } \\times d _ { x } }$ . ",
+        "bbox": [
+            174,
+            513,
+            326,
+            529
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Then we add some activation functions to the networks. We concentrate on the case where activation functions are on the transformation paths, which is also the case in the latest ResNet (He et al., 2016). ",
+        "bbox": [
+            171,
+            541,
+            825,
+            570
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Definition 3. An $n$ -shortcut linear network becomes an $n$ -shortcut network if element-wise activation functions $\\sigma _ { \\mathrm { p r e } } ( x ) , \\sigma _ { \\mathrm { m i d } } ( x ) , \\sigma _ { \\mathrm { p o s t } } ( x )$ are added at the transformation paths, where on a transformation path, $\\sigma _ { \\mathrm { p r e } } ( x )$ is added before the first weight matrix, $\\sigma _ { \\mathrm { m i d } } ( x )$ is added between two weight matrixes and $\\sigma _ { \\mathrm { p o s t } } ( x )$ is added after the last weight matrix. ",
+        "bbox": [
+            173,
+            575,
+            826,
+            632
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/cbb1ee508a8a1ba8a6bbac2fa43a8ca4030c234910719ee7f7e330a9226efb10.jpg",
+        "text": "$$\n\\sqrt { - \\frac { p r e } { ( \\ p r e ) } \\psi _ { \\psi } ^ { 1 } ( \\ m i d ) \\psi _ { \\psi } ^ { 2 } ( \\ m s t ) } ^ { \\gamma } =\n$$",
+        "text_format": "latex",
+        "bbox": [
+            330,
+            651,
+            663,
+            699
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "",
+        "image_caption": [
+            "Figure 1: An example of different position for nonlinearities in a residual unit of a 2-shortcut network. "
+        ],
+        "image_footnote": [],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Note that $n$ -shortcut linear networks are special cases of $n$ -shortcut networks, where all the activation functions are identity mappings. ",
+        "bbox": [
+            171,
+            751,
+            823,
+            781
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.3 OPTIMIZATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            797,
+            320,
+            813
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We denote the collection of all the variable weight parameters in an $n$ -shortcut linear network as w. Consider $m$ training samples $\\{ x ^ { \\mu } , y ^ { \\mu } \\} , \\mu = 1 , \\ldots , m$ . Using Frobenius loss, for an $n$ -shortcut linear network, we define the loss function as follows: ",
+        "bbox": [
+            173,
+            824,
+            826,
+            867
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0e695dc95bf0442f61b45a4ed4ce2e444e6793d0d0d4a8299cdf083badff7c94.jpg",
+        "text": "$$\nL ( \\mathbf { w } ) = \\frac { 1 } { 2 m } \\sum _ { \\mu = 1 } ^ { m } \\lVert y ^ { \\mu } - W x ^ { \\mu } \\rVert _ { 2 } ^ { 2 } = \\frac { 1 } { 2 m } \\lVert Y - W X \\rVert _ { F } ^ { 2 } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            320,
+            886,
+            676,
+            928
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $x ^ { \\mu } , y ^ { \\mu }$ are the $\\mu$ -th columns of $X , Y$ , and $\\left\\| \\cdot \\right\\| _ { F }$ denotes the Frobenius norm. Using gradient descent with learning rate $\\alpha$ , we have the weights updating rules as ",
+        "bbox": [
+            169,
+            103,
+            825,
+            133
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c4961f1234313797d891cd8aea6a1998a0fa4a6fafb53d4ca87bea5fee3aa392.jpg",
+        "text": "$$\n\\Delta W ^ { r , l } = \\alpha ( W _ { \\mathrm { a f t e r } } ^ { r } W _ { \\mathrm { a f t e r } } ^ { r , l } ) ^ { T } ( \\Sigma ^ { Y X } - W \\Sigma ^ { X X } ) ( W _ { \\mathrm { b e f o r e } } ^ { r , l } W _ { \\mathrm { b e f o r e } } ^ { r } ) ^ { T } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            277,
+            150,
+            718,
+            171
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\Sigma ^ { X X }$ and $\\Sigma ^ { Y X }$ denote the input-input and the output-input correlation matrices, defined as ",
+        "bbox": [
+            174,
+            184,
+            813,
+            200
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d6bfb3d7fa158672df312266b6af12e0b364f477437eab2457dafd3a651e84ac.jpg",
+        "text": "$$\n\\begin{array} { l } { { \\displaystyle \\Sigma ^ { X X } = \\frac { 1 } { m } \\sum _ { \\mu = 1 } ^ { m } x ^ { \\mu } ( x ^ { \\mu } ) ^ { T } } } \\\\ { { \\displaystyle \\Sigma ^ { Y X } = \\frac { 1 } { m } \\sum _ { \\mu = 1 } ^ { m } y ^ { \\mu } ( x ^ { \\mu } ) ^ { T } . } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            411,
+            207,
+            584,
+            294
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Here $W _ { \\mathrm { b e f o r e } } ^ { r } , W _ { \\mathrm { a f t e r } } ^ { r }$ denote the linear mappings before and after the $r$ -th residual unit, $W _ { \\mathrm { b e f o r e } } ^ { r , l } , W _ { \\mathrm { a f t e r } } ^ { r , l }$ denote the linear mappings before and after $W ^ { r , l }$ within the transformation path of the $r$ -th residual unit. In other words, the overall transformation can be represented as ",
+        "bbox": [
+            173,
+            306,
+            825,
+            353
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5489a0d9e0d96bbc1211a7cad9ab918888291a7d58c37eb393732533b3f2a58d.jpg",
+        "text": "$$\ny = W _ { \\mathrm { a f t e r } } ^ { r } ( W _ { \\mathrm { a f t e r } } ^ { r , l } W ^ { r , l } W _ { \\mathrm { b e f o r e } } ^ { r , l } + I _ { d _ { x } } ) W _ { \\mathrm { b e f o r e } } ^ { r } x .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            338,
+            372,
+            660,
+            392
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 THEORETICAL STUDY ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            411,
+            387,
+            428
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 INITIAL POINT PROPERTIES",
+        "text_level": 1,
+        "bbox": [
+            174,
+            444,
+            403,
+            458
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Before we analyze the initial point properties of $n$ -shortcut networks, we have to choose the way to initialize them. ResNet uses MSRA initialization (He et al., 2015b). It is a kind of scaled Gaussian initialization that tries to keep the variances of signals along a transformation path, which is also the idea behind Xavier initialization (Glorot & Bengio, 2010). However, because of the shortcut paths, the output variance of the entire network will actually explode as the network becomes deeper. Batch normalization units partly solved this problem in ResNet, but still they cannot prevent the large output variance in a deep network. ",
+        "bbox": [
+            173,
+            469,
+            825,
+            569
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "A simple idea is to zero initialize all the weights, so that the output variances of residual units stay the same along the network. It is worth noting that as found in He et al. (2015a), the deeper ResNet has smaller magnitudes of layer responses. This phenomenon has been confirmed in our experiments. As illustrated in Figure 2 and Figure 3, the deeper a residual network is, the small its average Frobenius norm of weight matrixes is, both during the traning process and when the training ends. Also, Hardt & Ma (2016) proves that if all the weight matrixes have small norms, a linear residual network will have no critical points other than the global optimum. ",
+        "bbox": [
+            173,
+            574,
+            825,
+            672
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "All these evidences indicate that zero is spacial in a residual network: as the network becomes deeper, the training tends to end up around it. Thus, we are looking into the Hessian at zero. As the zero is a saddle point, in our experiments we use zero initialization with small random perturbations to escape from it. We first Xavier initialize the weight matrixes, and then multiply a small constant (0,01) to them. ",
+        "bbox": [
+            173,
+            679,
+            825,
+            750
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We begin with the definition of $k$ -th order stationary point. ",
+        "bbox": [
+            173,
+            756,
+            558,
+            771
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Definition 4. Suppose function $f ( x )$ admits $k$ -th order Taylor expansion at point $x _ { 0 }$ . We say that the point $x _ { 0 }$ is a $k$ -th order stationary point of $f ( x )$ if the corresponding $k$ -th order Taylor expansion of $f ( x )$ at $x = x _ { 0 }$ is a constant: $f ( \\dot { x } ) \\dot { = } f ( x _ { 0 } ) \\dot { + } o ( \\| x - x _ { 0 } \\| _ { 2 } ^ { k } )$ . ",
+        "bbox": [
+            173,
+            775,
+            825,
+            819
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Now we state our main theorem, whose proof can be found in Appendix A. ",
+        "bbox": [
+            174,
+            829,
+            666,
+            844
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Theorem 1. Assume that $\\sigma _ { \\mathrm { m i d } } ( 0 ) = \\sigma _ { \\mathrm { p o s t } } ( 0 ) = 0$ and all of $\\sigma _ { \\mathrm { p r e } } ^ { ( k ) } ( 0 ) , \\sigma _ { \\mathrm { m i d } } ^ { ( k ) } ( 0 ) , \\sigma _ { \\mathrm { p o s t } } ^ { ( k ) } ( 0 ) , 1 \\le k \\le$ exist. For the loss function of an $n$ -shortcut network, at point zero, ",
+        "bbox": [
+            173,
+            849,
+            823,
+            883
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "1. if $n \\geq 2$ , it is an $( n - 1 ) t h$ -order stationary point. In particular, if $n \\geq 3$ , the Hessian is $a$ zero matrix; ",
+        "bbox": [
+            210,
+            895,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/beaf7b5c60eed4a22b5d4e41c424deddc2d59d92d4b8390a36b17fc0e3c7670c.jpg",
+        "image_caption": [
+            "Figure 2: The average Frobenius norms of ResNets of different depths during the training process. The pre-ResNet implementation in https://github.com/facebook/fb.resnet.torch is used. The learning rate is initialized to 0.1, decreased to 0.01 at the $8 1 ^ { \\mathrm { s t } }$ epoch (marked with circles) and decreased to 0.001 at the $1 2 2 ^ { \\mathrm { n d } }$ epoch (marked with triangles). Each model is trained for 200 epochs. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            290,
+            178,
+            684,
+            390
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/ceffb377ed6bcd64337887c300ae05f7c7ac5ec53bc70681c7e91661a0c31384.jpg",
+        "image_caption": [
+            "Figure 3: The average Frobenius norms of 2-shortcut networks of different depths during the training process when zero initialized. Left: Without nonlinearities. Right: With ReLUs at mid positions. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            601,
+            826,
+            806
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "2. if $n = 2$ , the Hessian can be written as ",
+        "bbox": [
+            212,
+            103,
+            490,
+            118
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/89fbd9e33588b8471f5a518223f0e3eef39a69806f98ba1e51276b2b48383305.jpg",
+        "text": "$$\nH = \\left[ \\begin{array} { c c c c c } { \\mathbf { 0 } } & { A ^ { T } } & & & \\\\ { A } & { \\mathbf { 0 } } & & & \\\\ & & { \\mathbf { 0 } } & { A ^ { T } } & \\\\ & & & { A } & { \\mathbf { 0 } } & \\\\ & & & & { \\ddots } \\end{array} \\right] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            415,
+            119,
+            640,
+            204
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "whose condition number is ",
+        "bbox": [
+            232,
+            213,
+            411,
+            228
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2eef555cb274369beea323e937d454124f43485499757dc158bc7e13b126bcac.jpg",
+        "text": "$$\n\\mathrm { c o n d } ( H ) = \\sqrt { \\mathrm { c o n d } \\big ( \\big ( \\Sigma ^ { X \\sigma _ { \\mathrm { p r e } } ( X ) } - \\Sigma ^ { Y \\sigma _ { \\mathrm { p r e } } ( X ) } \\big ) ^ { T } \\big ( \\Sigma ^ { X \\sigma _ { \\mathrm { p r e } } ( X ) } - \\Sigma ^ { Y \\sigma _ { \\mathrm { p r e } } ( X ) } \\big ) \\big ) } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            261,
+            228,
+            766,
+            256
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "where $A$ only depends on the training set and the activation functions. Except for degenerate cases, it is $a$ strict saddle point (Ge et al., 2015). ",
+        "bbox": [
+            232,
+            265,
+            823,
+            294
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3. if $n = 1$ , the Hessian can be written as ",
+        "bbox": [
+            212,
+            301,
+            488,
+            316
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f721435391b5626efe4f3febc54b296b8135b4821de34f6309130ccce2edd206.jpg",
+        "text": "$$\nH = { \\left[ \\begin{array} { l l l l l } { B } & { A ^ { T } } & { A ^ { T } } & { \\cdots } & { A ^ { T } } \\\\ { A } & { B } & { A ^ { T } } & { \\cdots } & { A ^ { T } } \\\\ { A } & { A } & { B } & & { \\vdots } \\\\ { \\vdots } & { \\vdots } & & { \\ddots } & { A ^ { T } } \\\\ { A } & { A } & { \\cdots } & { A } & { B } \\end{array} \\right] }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            413,
+            332,
+            642,
+            429
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "where $A , B$ only depend on the training set and the activation functions. ",
+        "bbox": [
+            232,
+            428,
+            702,
+            443
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Theorem 1 shows that the condition numbers of 2-shortcut networks are depth-invariant with a nice structure of eigenvalues. Indeed, the eigenvalues of the Hessian $H$ at the zero initial point are multiple copies of $\\pm { \\sqrt { \\mathrm { e i g s } ( A ^ { T } A ) } }$ , and the number of copies is equal to the number of shortcut connections. ",
+        "bbox": [
+            173,
+            450,
+            826,
+            510
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The Hessian at zero initial point for the 1-shortcut linear network follows block Toeplitz structure, which has been well studied in the literature. In particular, its condition number tends to explode as the number of layers increase (Gray, 2006). ",
+        "bbox": [
+            176,
+            516,
+            823,
+            559
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The assumptions hold for most activation functions including tanh, symmetric sigmoid and ReLU (Nair & Hinton, 2010). Note that although ReLU does not have derivatives at zero, one may do a local polynomial approximation to yield $\\bar { \\sigma } ^ { ( k ) } , 1 \\le k \\le \\operatorname* { m a x } ( n - 1 , 2 )$ . ",
+        "bbox": [
+            174,
+            565,
+            825,
+            611
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To get intuitive explanations of the theorems, imagine changing parameters in an $n$ -shortcut network. One has to change at least $n$ parameters to make any difference in the loss. So zero is an $( n - 1 ) \\operatorname { t h } .$ - order stationary point. Notice that the higher the order of a stationary point, the more difficult for a first order method to escape from it. ",
+        "bbox": [
+            173,
+            616,
+            825,
+            672
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "On the other hand, if $n = 2$ , one will have to change two parameters in the same residual unit but different weight matrices to affect the loss, leading to a clear block diagonal Hessian. ",
+        "bbox": [
+            171,
+            679,
+            825,
+            708
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 LEARNING DYNAMICS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            723,
+            369,
+            738
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To understand Equation (7) better, we can take $n$ -shortcut linear networks to two extremes. First, when $n = 1$ , let $\\bar { V } ^ { r , 1 } = W ^ { r , 1 } + I _ { d _ { x } } , r = 1 , \\ldots , R - 1$ . As $I _ { d _ { x } }$ is a constant, we have ",
+        "bbox": [
+            174,
+            750,
+            825,
+            780
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c5963fe8ecba5a06be7b50c3ac9f80af684ff7c4aaa739740873f813c152af3b.jpg",
+        "text": "$$\n\\Delta V ^ { r , 1 } = \\alpha \\big ( \\prod _ { r ^ { \\prime } = r + 1 } ^ { R - 1 } V ^ { r ^ { \\prime } , 1 } \\big ) ^ { T } \\big ( \\Sigma ^ { Y X } - ( \\prod _ { r ^ { \\prime } = 1 } ^ { R - 1 } V ^ { r ^ { \\prime } , 1 } ) \\Sigma ^ { X X } \\big ) ( \\prod _ { r ^ { \\prime } = 1 } ^ { r - 1 } V ^ { r ^ { \\prime } , 1 } ) ^ { T } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            269,
+            794,
+            727,
+            839
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "which can be seen as a linear network with identity initialization, a special case of orthogonal initialization, if the original 1-shortcut network is zero initialized. ",
+        "bbox": [
+            176,
+            845,
+            820,
+            875
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "On the other side, if the number of shortcut connections $R = 1$ , the shortcut will only change the distribution of the output training set from $Y$ to $Y - X$ . These two extremes are illustrated in Figure 4 ",
+        "bbox": [
+            174,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/b6ad27a7d095370272a40d30d782876e04f599d80639bba16381a8d37e154f78.jpg",
+        "image_caption": [
+            "Figure 4: Equivalents of two extremes of $n$ -shortcut linear networks. 1-shortcut linear networks are equivalent to linear networks with identity initialization, while skip-all shortcuts will only change the effective dataset outputs. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            267,
+            97,
+            730,
+            204
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.3 LEARNING RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            285,
+            354,
+            299
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The optimal weights of an $n$ -shortcut linear network can be easily computed via least squares, which leads to ",
+        "bbox": [
+            174,
+            310,
+            825,
+            338
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1401ad68ed469914d9a94f17b82400fbbe52f9d22f4f0c5b4cadf285293c71da.jpg",
+        "text": "$$\nW = Y X ^ { T } ( X X ^ { T } ) ^ { - 1 } = \\Sigma ^ { Y X } ( \\Sigma ^ { X X } ) ^ { - 1 } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            359,
+            357,
+            637,
+            377
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "and the minimum of the loss function is ",
+        "bbox": [
+            174,
+            387,
+            436,
+            402
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/cef865db3c3aa335afde7e729d2fcf56848e0319e8ff59f458fa0d48de50efc9.jpg",
+        "text": "$$\nL _ { \\operatorname* { m i n } } = \\frac { 1 } { 2 m } \\| Y - \\Sigma ^ { Y X } ( \\Sigma ^ { X X } ) ^ { - 1 } X \\| _ { F } ^ { 2 } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            366,
+            419,
+            630,
+            450
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "where $\\left\\| \\cdot \\right\\| _ { F }$ denotes the Frobenius norm and $( \\Sigma ^ { X X } ) ^ { - 1 }$ denotes any kind of generalized inverse of $\\Sigma ^ { X X }$ . So given a training set, we can pre-compute its $L _ { \\mathrm { m i n } }$ and use it to evaluate any $n$ -shortcut linear network. ",
+        "bbox": [
+            174,
+            460,
+            825,
+            503
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            523,
+            326,
+            540
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We compare networks with Xavier initialization (Glorot & Bengio, 2010), networks with orthogonal initialization (Saxe et al., 2013) and 2-shortcut networks with zero initialization. The training dynamics of 1-shortcut networks are similar to that of linear networks with orthogonal initialization in our experiments. Setup details can be found in Appendix B. ",
+        "bbox": [
+            174,
+            556,
+            825,
+            612
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.1 INITIAL POINT ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            630,
+            316,
+            643
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We first compute the initial condition numbers for different kinds of linear networks with different depths. ",
+        "bbox": [
+            173,
+            655,
+            823,
+            684
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "As can be seen in Figure 5, 2-shortcut linear networks have constant condition numbers as expected. On the other hand, when using Xavier or orthogonal initialization in linear networks, the initial condition numbers will go to infinity as the depths become infinity, making the networks hard to train. This also explains why orthogonal initialization is helpful for a linear network, as its initial condition number grows slower than the Xavier initialization. ",
+        "bbox": [
+            174,
+            691,
+            825,
+            761
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.2 LEARNING DYNAMICS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            779,
+            369,
+            792
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Having a good beginning does not guarantee an easy trip on the loss surface. In order to depict the loss surfaces encountered from different initial points, we plot the maxima and $1 0 ^ { \\mathrm { t h } }$ percentiles (instead of minima, as they are very unstable) of the absolute values of Hessians eigenvalues at different losses. ",
+        "bbox": [
+            174,
+            805,
+            825,
+            861
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "As shown in Figure 6 and Figure 7, the condition numbers of 2-shortcut networks at different losses are always smaller, especially when the loss is large. Also, notice that the condition numbers roughly evolved to the same value for both orthogonal and 2-shortcut linear networks. This may be explained by the fact that the minimizers, as well as any point near them, have similar condition numbers. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/e7fd6d2242db1b2949e02ba010cb7e5cb5d9c549740871ede39a2991a1117cb8.jpg",
+        "image_caption": [
+            "Figure 5: Initial condition numbers of Hessians for different linear networks as the depths of the networks increase. Means and standard deviations are estimated based on 10 runs. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            236,
+            103,
+            758,
+            297
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/e491de132755164c6b09e1268f561d391860e12cc863ba5a0230cb1de6d43673.jpg",
+        "image_caption": [
+            "Figure 6: Maxima and $1 0 ^ { \\mathrm { t h } }$ percentiles of absolute values of eigenvalues at different losses when the depth is 16. For each run, eigenvalues at different losses are calculated using linear interpolation. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            267,
+            349,
+            728,
+            589
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/ba43372fef7c3f9396fae16676451e3cdd27147ecb5a9938f72a36666ccac965.jpg",
+        "image_caption": [
+            "Figure 7: Maxima and $1 0 ^ { \\mathrm { t h } }$ percentiles of absolute values of eigenvalues at different losses when the depth is 16. Eigenvalues at different losses are calculated using linear interpolation. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            282,
+            657,
+            683,
+            873
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Another observation is the changes of negative eigenvalues ratios. Index (ratio of negative eigenvalues) is an important characteristic of a critical point. Usually for the critical points of a neural network, the larger the loss the larger the index (Dauphin et al., 2014). In our experiments, the index of a 2-shortcut network is always smaller, and drops dramatically at the beginning, as shown in Figure 8, left. This might make the networks tend to stop at low critical points. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/0f8f47ef870bf1849218165268309fb3a477f94337f8f5859b3d68f17569a922.jpg",
+        "image_caption": [
+            "Figure 8: Left: ratio of negative eigenvalues at different losses when the depth is 16. For each run, indexes at different losses are calculated using linear interpolation. Right: the dynamics of gradient and index of a 2-shortcut linear network in a single run. The gradient reaches its maximum while the index drops dramatically, indicating moving toward negative curvature directions. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            236,
+            185,
+            761,
+            358
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "This is because the initial point is near a saddle point, thus it tends to go towards negative curvature directions, eliminating some negative eigenvalues at the beginning. This phenomenon matches the observation that the gradient reaches its maximum when the index drops dramatically, as shown in Figure 8, right. ",
+        "bbox": [
+            173,
+            440,
+            825,
+            497
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5.3 LEARNING RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            515,
+            354,
+            529
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We run different networks for 1000 epochs using different learning rates at log scale, and compare the average final losses of the optimal learning rates. ",
+        "bbox": [
+            171,
+            540,
+            825,
+            569
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/64bafd2db8aa80844103d468a5de18786ce11bc7a0ffb813b0996a44b26f1092.jpg",
+        "image_caption": [
+            "Figure 9: Left: Optimal Final losses of different linear networks. Right: Corresponding optimal learning rates. When the depth is 96, the final losses of Xavier with different learning rates are basically the same, so the optimal learning rate is omitted as it is very unstable. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            248,
+            587,
+            741,
+            762
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Figure 9 shows the results for linear networks. Just like their depth-invariant initial condition numbers, the final losses of 2-shortcut linear networks stay close to optimal as the networks become deeper. Higher learning rates can also be applied, resulting in fast learning in deep networks. ",
+        "bbox": [
+            173,
+            832,
+            825,
+            875
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Then we add ReLUs to the mid positions of the networks. To make a fair comparison, the numbers of ReLU units in different networks are the same when the depths are the same, so 1-shortcut and 3-shortcut networks are omitted. The result is shown in Figure 10. ",
+        "bbox": [
+            174,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/1428f5f735a5850cd487815f64fb147c4ee07c34d8c8ff465fceef3b2c47cf17.jpg",
+        "image_caption": [
+            "Figure 10: Left: Optimal Final losses of different networks with ReLUs in mid positions. Right: Corresponding optimal learning rates. Note that as it is hard to compute the minimum losses with ReLUs, we plot the $\\log _ { 1 0 }$ (final loss) instead of $\\log _ { 1 0 }$ (final loss − optimal loss). When the depth is 64, the final losses of Xavier-ReLU and orthogonal-ReLU with different learning rates are basically the same, so the optimal learning rates are omitted as they are very unstable. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            235,
+            98,
+            759,
+            270
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Note that because of the nonlinearities, the optimal losses vary for different networks with different depths. It is usually thought that deeper networks can represent more complex models, leading to smaller optimal losses. However, our experiments show that linear networks with Xavier or orthogonal initialization have difficulties finding these optimal points, while 2-shortcut networks find these optimal points easily as they did without nonlinear units. ",
+        "bbox": [
+            174,
+            380,
+            825,
+            450
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "6 FUTURE DIRECTIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            470,
+            385,
+            486
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Further studies should concentrate on the behavior of shortcut connections on convolution networks, as well as the influences of batch normalization units (Ioffe & Szegedy, 2015) in ResNet. Meanwhile, it would be very interesting to extend the insights obtained in this paper to recurrent neural networks such as LSTM (Sainath et al., 2013). ",
+        "bbox": [
+            174,
+            502,
+            825,
+            558
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            579,
+            285,
+            594
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Anima Anandkumar and Rong Ge. Efficient approaches for escaping higher order saddle points in non-convex optimization. arXiv preprint arXiv:1602.05908, 2016. ",
+        "bbox": [
+            171,
+            602,
+            823,
+            631
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Chris Bishop. Exact calculation of the hessian matrix for the multilayer perceptron. Neural Computation, 4(4):494–501, 1992. ",
+        "bbox": [
+            173,
+            640,
+            821,
+            669
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Anna Choromanska, Mikael Henaff, Michael Mathieu, Gerard Ben Arous, and Yann LeCun. The ´ loss surfaces of multilayer networks. In AISTATS, 2015a. ",
+        "bbox": [
+            169,
+            678,
+            825,
+            708
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Anna Choromanska, Yann LeCun, and Gerard Ben Arous. Open problem: The landscape of the ´ loss surfaces of multilayer networks. In Proceedings of The 28th Conference on Learning Theory, COLT 2015, Paris, France, July 3, volume 6, pp. 1756–1760, 2015b. ",
+        "bbox": [
+            174,
+            715,
+            823,
+            760
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yann N Dauphin, Razvan Pascanu, Caglar Gulcehre, Kyunghyun Cho, Surya Ganguli, and Yoshua Bengio. Identifying and attacking the saddle point problem in high-dimensional non-convex optimization. In Advances in neural information processing systems, pp. 2933–2941, 2014. ",
+        "bbox": [
+            178,
+            767,
+            823,
+            810
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Rong Ge, Furong Huang, Chi Jin, and Yang Yuan. Escaping from saddle pointsonline stochastic gradient for tensor decomposition. In Proceedings of The 28th Conference on Learning Theory, pp. 797–842, 2015. ",
+        "bbox": [
+            173,
+            819,
+            823,
+            862
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Xavier Glorot and Yoshua Bengio. Understanding the difficulty of training deep feedforward neural networks. In Aistats, volume 9, pp. 249–256, 2010. ",
+        "bbox": [
+            173,
+            871,
+            823,
+            900
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Robert M Gray. Toeplitz and circulant matrices: A review. now publishers inc, 2006. ",
+        "bbox": [
+            173,
+            909,
+            732,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Moritz Hardt and Tengyu Ma. Identity matters in deep learning. arXiv preprint arXiv:1611.04231, 2016. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. arXiv preprint arXiv:1512.03385, 2015a. ",
+        "bbox": [
+            173,
+            143,
+            820,
+            174
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Delving deep into rectifiers: Surpassing human-level performance on imagenet classification. In Proceedings of the IEEE International Conference on Computer Vision, pp. 1026–1034, 2015b. ",
+        "bbox": [
+            173,
+            185,
+            826,
+            228
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Identity mappings in deep residual networks. arXiv preprint arXiv:1603.05027, 2016. ",
+        "bbox": [
+            173,
+            241,
+            825,
+            270
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. arXiv preprint arXiv:1502.03167, 2015. ",
+        "bbox": [
+            176,
+            282,
+            823,
+            311
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Kenji Kawaguchi. Deep learning without poor local minima. arXiv preprint arXiv:1605.07110, 2016. ",
+        "bbox": [
+            174,
+            323,
+            823,
+            352
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Vinod Nair and Geoffrey E Hinton. Rectified linear units improve restricted boltzmann machines. In Proceedings of the 27th International Conference on Machine Learning (ICML-10), pp. 807–814, 2010. ",
+        "bbox": [
+            176,
+            364,
+            823,
+            407
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Arkadi Nemirovski. Efficient methods in convex programming. 2005. ",
+        "bbox": [
+            173,
+            419,
+            633,
+            435
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Razvan Pascanu, Yann N Dauphin, Surya Ganguli, and Yoshua Bengio. On the saddle point problem for non-convex optimization. arXiv preprint arXiv:1405.4604, 2014. ",
+        "bbox": [
+            173,
+            446,
+            825,
+            477
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "T.N. Sainath, O. Vinyals, A. Senior, and H. Sak. Convolutional, Long short-term memory, fully connected deep neural networks. Journal of Chemical Information and Modeling, 53(9):1689– 1699, 2013. ISSN 1098-6596. doi: 10.1017/CBO9781107415324.004. ",
+        "bbox": [
+            174,
+            488,
+            825,
+            531
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Andrew M Saxe, James L McClelland, and Surya Ganguli. Exact solutions to the nonlinear dynamics of learning in deep linear neural networks. arXiv preprint arXiv:1312.6120, 2013. ",
+        "bbox": [
+            171,
+            542,
+            825,
+            573
+        ],
+        "page_idx": 11
+    },
+    {
+        "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,
+            584,
+            823,
+            614
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Rupesh K Srivastava, Klaus Greff, and Jurgen Schmidhuber. Training very deep networks. In ¨ Advances in neural information processing systems, pp. 2377–2385, 2015a. ",
+        "bbox": [
+            171,
+            626,
+            825,
+            656
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Rupesh Kumar Srivastava, Klaus Greff, and Jurgen Schmidhuber. Highway networks. ¨ arXiv preprint arXiv:1505.00387, 2015b. ",
+        "bbox": [
+            171,
+            666,
+            823,
+            696
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Christian Szegedy, Sergey Ioffe, and Vincent Vanhoucke. Inception-v4, Inception-ResNet and the Impact of Residual Connections on Learning. feb 2016. URL http://arxiv.org/abs/ 1602.07261. ",
+        "bbox": [
+            173,
+            708,
+            825,
+            752
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Sasha Targ, Diogo Almeida, and Kevin Lyman. Resnet in resnet: Generalizing residual architectures. arXiv preprint arXiv:1603.08029, 2016. ",
+        "bbox": [
+            171,
+            763,
+            823,
+            792
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Andreas Veit, Michael Wilber, and Serge Belongie. Residual networks are exponential ensembles of relatively shallow networks. arXiv preprint arXiv:1605.06431, 2016. ",
+        "bbox": [
+            169,
+            805,
+            823,
+            834
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Sergey Zagoruyko and Nikos Komodakis. Wide residual networks. arXiv preprint arXiv:1605.07146, 2016. ",
+        "bbox": [
+            173,
+            845,
+            825,
+            876
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ke Zhang, Miao Sun, Tony X Han, Xingfang Yuan, Liru Guo, and Tao Liu. Residual networks of residual networks: Multilevel residual networks. arXiv preprint arXiv:1608.02908, 2016. ",
+        "bbox": [
+            173,
+            887,
+            825,
+            916
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A PROOFS OF THEOREMS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            401,
+            118
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Definition 5. The elements in Hessian of an $n$ -shortcut network is defined as ",
+        "bbox": [
+            171,
+            136,
+            681,
+            151
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9a8683a6eb3b43e1a3e96029991fe2870b437a287cba4c5d1e0c566603c3390c.jpg",
+        "text": "$$\nH _ { \\mathrm { i n d } ( w _ { 1 } ) , \\mathrm { i n d } ( w _ { 2 } ) } = \\frac { \\partial ^ { 2 } L } { \\partial w _ { 1 } \\partial w _ { 2 } } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            400,
+            159,
+            598,
+            193
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "where $L$ is the loss function, and the indices $\\operatorname { i n d } ( \\cdot )$ is ordered lexicographically following the four indices $( r , l , j , i )$ of the weight variable $\\underset { \\cdot } { w _ { i , j } ^ { r , l } }$ . In other words, the priority decreases along the index of shortcuts, index of weight matrix inside shortcuts, index of column, and index of row. ",
+        "bbox": [
+            173,
+            202,
+            826,
+            248
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Note that the collection of all the weight variables in the $n$ -shortcut network is denoted as w. We study the behavior of the loss function in the vicinity of ${ \\bf w } = { \\bf 0 }$ . ",
+        "bbox": [
+            174,
+            261,
+            823,
+            290
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Lemma 1. Assume that $w _ { 1 } \\ = \\ w _ { i _ { 1 } , j _ { 1 } } ^ { r _ { 1 } , l _ { 1 } } , \\cdot \\cdot \\cdot , w _ { N } \\ = \\ w _ { i _ { N } , j _ { N } } ^ { r _ { N } , l _ { N } }$ are $N$ parameters of an $n$ -shortcut network. If ∂ L∂w1···∂wN $\\begin{array} { r } { I f \\frac { \\partial ^ { 2 } L } { \\partial w _ { 1 } \\cdots \\partial w _ { N } } \\bigg | _ { \\mathbf { w } = \\mathbf { 0 } } } \\end{array}$ is nonzero, there exists $r$ and $k _ { 1 } , \\cdots , k _ { n }$ such that $r _ { k _ { m } } = r a n d l _ { k _ { m } } = m$ for $m = 1 , \\cdots , n$ . ",
+        "bbox": [
+            173,
+            296,
+            825,
+            353
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Proof. Assume there does not exist such $r$ and $k _ { 1 } , \\cdots , k _ { n }$ , then for all the shortcut units $r =$ $1 , \\cdots , R$ , there exists a weight matrix $l$ such that none of $w _ { 1 } , \\cdots , w _ { N }$ is in $W ^ { r , l }$ , so all the transformation paths are zero, which means $W = I _ { d _ { x } }$ . Then $\\left. \\frac { \\partial ^ { 2 } L } { \\partial w _ { 1 } \\cdots \\partial w _ { N } } \\right| _ { { \\bf w } = { \\bf 0 } } = 0$ , leading to a contradiction. □ ",
+        "bbox": [
+            173,
+            380,
+            825,
+            446
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Lemma 2. Assume that $w _ { 1 } = w _ { i _ { 1 } , j _ { 1 } } ^ { r _ { 1 } , l _ { 1 } } , w _ { 2 } = w _ { i _ { 2 } , j _ { 2 } } ^ { r _ { 2 } , l _ { 2 } } , r _ { 1 } \\le r _ { 2 }$ . Let $L _ { 0 } ( w _ { 1 } , w _ { 2 } )$ denotes the loss function with all the parameters except 0 $w _ { 1 }$ and $w _ { 2 }$ set to $O _ { ; }$ , $w _ { 1 } ^ { \\prime } = w _ { i _ { 1 } , j _ { 1 } } ^ { 1 , l _ { 1 } } , w _ { 2 } ^ { \\prime } = w _ { i _ { 2 } , j _ { 2 } } ^ { 1 + \\mathbb { 1 } ( r _ { 1 } \\neq r _ { 2 } ) , l _ { 2 } }$ . Then $\\begin{array} { r } { \\frac { \\partial ^ { 2 } L _ { 0 } ( w _ { 1 } , w _ { 2 } ) } { \\partial w _ { 1 } \\partial w _ { 2 } } | _ { ( w _ { 1 } , w _ { 2 } ) = 0 } = \\frac { \\partial ^ { 2 } L _ { 0 } ( w _ { 1 } ^ { \\prime } , w _ { 2 } ^ { \\prime } ) } { \\partial w _ { 1 } ^ { \\prime } \\partial w _ { 2 } ^ { \\prime } } | _ { ( w _ { 1 } ^ { \\prime } , w _ { 2 } ^ { \\prime } ) = 0 } . } \\end{array}$ ",
+        "bbox": [
+            171,
+            464,
+            825,
+            527
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Proof. As all the residual units expect unit $r _ { 1 }$ and $r _ { 2 }$ are identity transformations, reordering residual units while preserving the order of units $r _ { 1 }$ and $r _ { 2 }$ will not affect the overall transformation, i.e. $L _ { 0 } ( w _ { 1 } , w _ { 2 } ) | _ { w _ { 1 } = a , w _ { 2 } = b } ~ = ~ L _ { 0 } ^ { \\prime } ( w _ { 1 } ^ { \\prime } , w _ { 2 } ^ { \\prime } ) | _ { w _ { 1 } ^ { \\prime } = a , w _ { 2 } ^ { \\prime } = b }$ . So $\\frac { \\partial ^ { 2 } L _ { 0 } ( w _ { 1 } , w _ { 2 } ) } { \\partial w _ { 1 } \\partial w _ { 2 } } | _ { ( w _ { 1 } , w _ { 2 } ) = { \\bf 0 } } =$ $\\frac { \\partial ^ { 2 } L _ { 0 } ( w _ { 1 } ^ { \\prime } , w _ { 2 } ^ { \\prime } ) } { \\partial w _ { 1 } ^ { \\prime } \\partial w _ { 2 } ^ { \\prime } } \\big | _ { ( w _ { 1 } ^ { \\prime } , w _ { 2 } ^ { \\prime } ) = { \\bf 0 } }$ . □ ",
+        "bbox": [
+            173,
+            553,
+            825,
+            626
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Proof of Theorem 1. Now we can prove Theorem 1 with the help of the previously established lemmas. ",
+        "bbox": [
+            173,
+            651,
+            823,
+            681
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "1. Using Lemma 1, for an $n$ -shortcut network, at zero, all the $k$ -th order partial derivatives of the loss function are zero, where $k$ ranges from 1 to $n - 1$ . Hence, the initial point zero is a $( n - 1 )$ th-order stationary point of the loss function. ",
+        "bbox": [
+            212,
+            705,
+            825,
+            750
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "2. Consider the Hessian in $n = 2$ case. Using Lemma 1 and Lemma 2, the form of Hessian can be directly written as Equation (11), as illustrated in Figure 11. ",
+        "bbox": [
+            210,
+            760,
+            826,
+            790
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "So we have ",
+        "bbox": [
+            232,
+            796,
+            310,
+            809
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b4b51c441527bc160800eabf72ebbd96866f9c7c8221bfba52ef11b0ae52ca0e.jpg",
+        "text": "$$\n\\mathrm { e i g s } ( H ) = \\mathrm { e i g s } ( \\left[ { \\bf 0 } \\quad A ^ { T } \\right] ) = \\pm \\sqrt { \\mathrm { e i g s } ( A ^ { T } A ) } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            369,
+            810,
+            686,
+            845
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Thus $\\operatorname { c o n d } ( H ) = { \\sqrt { \\operatorname { c o n d } ( A ^ { T } A ) } }$ , which is depth-invariant. Note that the dimension of $A$ is $d _ { x } ^ { 2 } \\times d _ { x } ^ { 2 }$ . ",
+        "bbox": [
+            228,
+            856,
+            823,
+            888
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "To get the expression of $A$ , consider two parameters that are in the same residual unit but different weight matrices, i.e. $w _ { 1 } = w _ { i _ { 1 } , j _ { 1 } } ^ { r , 2 } , w _ { 2 } = w _ { i _ { 2 } , j _ { 2 } } ^ { r , 1 }$ . ",
+        "bbox": [
+            232,
+            893,
+            823,
+            928
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/963e9a8de93364de78d221fd32e403c39d4e55d5d393094e5790d48bdff4c5ee.jpg",
+        "image_caption": [
+            "Figure 11: The Hessian in $n = 2$ case. It follows from Lemma 1 that only off-diagonal subblocks in each diagonal block, i.e., the blocks marked in orange (slash) and blue (chessboard), are non-zero. From Lemma 2, we conclude the translation invariance and that all blocks marked in orange (slash) (resp. blue (chessboard)) are the same. Given that the Hessian is symmetric, the blocks marked in blue and orange are transposes of each other, and thus it can be directly written as Equation (11). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            334,
+            99,
+            660,
+            337
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "If $j _ { 1 } = i _ { 2 }$ , we have ",
+        "bbox": [
+            232,
+            450,
+            361,
+            467
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/eb9d79cc26ee6a5e16a1ff070e624c73d3a929e7d9347cef05dacb2a4bbdfd0c.jpg",
+        "text": "$$\n\\begin{array} { l } { { A _ { ( j _ { 1 } - 1 ) d _ { x } + i _ { 1 } , ( j _ { 2 } - 1 ) d _ { x } + i _ { 2 } } = \\displaystyle \\frac { \\partial ^ { 2 } { \\cal L } } { \\partial w _ { 1 } \\partial w _ { 2 } } \\Big | _ { { \\bf w } = { \\bf 0 } } } } \\\\  { { \\phantom { A } = \\displaystyle \\frac { \\partial ^ { 2 } \\sum _ { \\mu = 1 } ^ { m } \\frac { 1 } { 2 m } ( y _ { i _ { 1 } } ^ { \\mu } - x _ { i _ { 1 } } ^ { \\mu } - \\sigma _ { \\mathrm { p o s t } } ( w _ { 1 } \\sigma _ { \\mathrm { m i d } } ( w _ { 2 } \\sigma _ { \\mathrm { p r e } } ( x _ { j _ { 2 } } ^ { \\mu } ) ) ) ) ^ { 2 } } { \\partial w _ { 1 } \\partial w _ { 2 } } \\Big | _ { { \\bf w } = { \\bf 0 } } } } \\\\  { { \\phantom { A } = \\displaystyle \\frac { \\sigma _ { \\mathrm { m i d } } ^ { \\prime } ( 0 ) \\sigma _ { \\mathrm { p o s t } } ^ { \\prime } ( 0 ) } { m } \\sum _ { \\mu = 1 } ^ { m } \\sigma _ { \\mathrm { p r e } } ( x _ { j _ { 2 } } ^ { \\mu } ) ( x _ { i _ { 1 } } ^ { \\mu } - y _ { i _ { 1 } } ^ { \\mu } ) . } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            230,
+            476,
+            839,
+            592
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Else, we have $A _ { ( j _ { 1 } - 1 ) d _ { x } + i _ { 1 } , ( j _ { 2 } - 1 ) d _ { x } + i _ { 2 } } = 0 .$ ",
+        "bbox": [
+            233,
+            617,
+            526,
+            633
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Noting that $A _ { ( j _ { 1 } , \\ldots , 1 ) d _ { x } + i _ { 1 } , ( j _ { 2 } - 1 ) d _ { x } + i _ { 2 } }$ in fact only depends on the two indices $i _ { 1 } , j _ { 2 }$ (with a small difference depending on whether $\\begin{array} { r l r } { j _ { 1 } } & { { } = } & { i _ { 2 } ) } \\end{array}$ , we make a $d _ { x } \\mathrm { ~  ~ \\times ~ }$ $d _ { x }$ matrix with rows indexed by $i _ { 1 }$ and columns indexed by $j _ { 2 }$ , and the entry at $( i _ { 1 } , j _ { 2 } )$ equal to $A _ { ( j _ { 1 } - 1 ) d _ { x } + i _ { 1 } , ( j _ { 2 } - 1 ) d _ { x } + i _ { 2 } }$ . Apparently, this matrix is equal to $\\sigma _ { \\mathrm { m i d } } ^ { \\prime } ( 0 ) \\sigma _ { \\mathrm { p o s t } } ^ { \\prime } ( 0 ) \\bigl ( \\Sigma ^ { X \\sigma _ { \\mathrm { p r e } } ( X ) } - \\Sigma ^ { Y \\sigma _ { \\mathrm { p r e } } ( X ) } \\bigr )$ when $j _ { 1 } ~ = ~ i _ { 2 }$ , and equal to the zero matrix when $j _ { 1 } \\neq i _ { 2 }$ . ",
+        "bbox": [
+            232,
+            637,
+            825,
+            726
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "To simplify the expression of $A$ , we rearrange the columns of $A$ by a permutation matrix, i.e. ",
+        "bbox": [
+            232,
+            731,
+            823,
+            760
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2bd4e49843f5c12f7d6377c31b3c8c1fb065a0157b1b77f6de5d6489ebdaf139.jpg",
+        "text": "$$\nA ^ { \\prime } = A P ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            491,
+            765,
+            562,
+            781
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "where $P _ { i j } = 1$ if and only if $\\begin{array} { r } { i = ( ( j - 1 ) \\bmod d _ { x } ) d _ { x } + \\lceil \\frac { j } { d _ { x } } \\rceil } \\end{array}$ . Basically it permutes the $i$ -th column of $A$ to the $j$ -th column. ",
+        "bbox": [
+            233,
+            792,
+            825,
+            824
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Then we have ",
+        "bbox": [
+            232,
+            830,
+            326,
+            844
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/514587deae8fa7e43680c78c25b359ef9e0147c9e08c18a6e65d542c53e39132.jpg",
+        "text": "$$\nA = \\sigma _ { \\mathrm { m i d } } ^ { \\prime } ( 0 ) \\sigma _ { \\mathrm { p o s t } } ^ { \\prime } ( 0 ) \\left[ \\begin{array} { l l l l } { \\Sigma ^ { X \\sigma _ { \\mathrm { p r e } } ( X ) } - \\Sigma ^ { Y \\sigma _ { \\mathrm { p r e } } ( X ) } } & & & \\\\ & & { \\ddots } & & \\\\ & & & { \\Sigma ^ { X \\sigma _ { \\mathrm { p r e } } ( X ) } - \\Sigma ^ { Y \\sigma _ { \\mathrm { p r e } } ( X ) } } \\end{array} \\right] P ^ { T } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            243,
+            852,
+            812,
+            912
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "So the eigenvalues of $H$ becomes ",
+        "bbox": [
+            232,
+            103,
+            455,
+            118
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1ed912af0a23c570e7e7f109cd56e77ba9225abb559c120dbfc41e02aee0ba34.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathrm { e i g s } ( H ) = \\pm \\sigma _ { \\mathrm { m i d } } ^ { \\prime } ( 0 ) \\sigma _ { \\mathrm { p o s t } } ^ { \\prime } ( 0 ) \\sqrt { \\mathrm { e i g s } \\big ( ( \\Sigma ^ { X \\sigma _ { \\mathrm { p r e } } } ( X ) - \\Sigma ^ { Y \\sigma _ { \\mathrm { p r e } } } ( X ) \\big ) T \\big ( \\Sigma ^ { X \\sigma _ { \\mathrm { p r e } } } ( X ) - \\Sigma ^ { Y \\sigma _ { \\mathrm { p r e } } } ( X ) \\big ) \\big ) } , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            232,
+            122,
+            841,
+            150
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "which leads to Equation (12). ",
+        "bbox": [
+            232,
+            167,
+            426,
+            183
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "3. Now consider the Hessian in the $n = 1$ case. Using Lemma 2, the form of Hessian can be directly written as Equation (13). ",
+        "bbox": [
+            215,
+            191,
+            825,
+            220
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "To get the expressions of $A$ and $B$ in $\\sigma _ { \\mathrm { p r e } } ( x ) = \\sigma _ { \\mathrm { p o s t } } ( x ) = x$ case, consider two parameters that are in the same residual units, i.e. $w _ { 1 } = w _ { i _ { 1 } , j _ { 1 } } ^ { r , 1 } , w _ { 2 } = w _ { i _ { 2 } , j _ { 2 } } ^ { r , 1 }$ . ",
+        "bbox": [
+            233,
+            227,
+            821,
+            261
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "We have ",
+        "bbox": [
+            232,
+            265,
+            290,
+            279
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "equation",
+        "img_path": "images/75d60021e55cbd68975eeadaba6e8ff69927220fcfbdbc83b28689be179868db.jpg",
+        "text": "$$\n\\begin{array} { r l } { B _ { ( j _ { 1 } - 1 ) d _ { x } + i _ { 1 } , ( j _ { 2 } - 1 ) d _ { x } + i _ { 2 } } = \\frac { \\partial ^ { 2 } { \\cal L } } { \\partial w _ { 1 } \\partial w _ { 2 } } \\Big | _ { { \\bf w } = { \\bf 0 } } } & { { } } \\\\ { \\quad \\quad } & { { } = \\left\\{ \\begin{array} { l l } { \\frac { 1 } { m } \\sum _ { \\mu = 1 } ^ { m } x _ { j _ { 1 } } ^ { \\mu } x _ { j _ { 2 } } ^ { \\mu } } & { i _ { 1 } = i _ { 2 } } \\\\ { 0 } & { i _ { 1 } \\ne i _ { 2 } } \\end{array} \\right. } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            339,
+            280,
+            717,
+            358
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Rearrange the order of variables using $P$ , we have ",
+        "bbox": [
+            232,
+            367,
+            562,
+            382
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a7ae31f3048a87f39acf87fcc3dfe62c6f676d83166d604992a9ed00bf6e71b8.jpg",
+        "text": "$$\n\\boldsymbol { B } = \\boldsymbol { P } \\left[ \\begin{array} { l l l } { \\boldsymbol { \\Sigma } ^ { X X } } & & \\\\ & { \\boldsymbol { \\cdot } } & \\\\ & & { \\boldsymbol { \\cdot } \\boldsymbol { \\cdot } } \\\\ & & & { \\boldsymbol { \\Sigma } ^ { X X } } \\end{array} \\right] \\boldsymbol { P } ^ { T } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            413,
+            385,
+            643,
+            444
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Then consider two parameters that are in different residual units, i.e. $w _ { 1 } = w _ { i _ { 1 } , j _ { 1 } } ^ { r _ { 1 } , 1 } , w _ { 2 } =$   \n$w _ { i _ { 2 } , j _ { 2 } } ^ { r _ { 2 } , 1 } , r _ { 1 } > r _ { 2 }$ . ",
+        "bbox": [
+            232,
+            457,
+            825,
+            491
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "We have ",
+        "bbox": [
+            232,
+            497,
+            290,
+            511
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5240f03d250e96f294808e98f973b48a5907680f163958d86582ec377e45da8d.jpg",
+        "text": "$$\n\\begin{array} { l l } { { A _ { ( j _ { 1 } - 1 ) d _ { x } + i _ { 1 } , ( j _ { 2 } - 1 ) d _ { x } + i _ { 2 } } = \\displaystyle \\frac { \\partial ^ { 2 } { \\cal L } } { \\partial w _ { 1 } \\partial w _ { 2 } } \\Big | _ { { \\bf w } = { \\bf 0 } } } } \\\\ { { \\ } } \\\\ { { \\quad = \\left\\{ \\begin{array} { l l } { { \\frac { 1 } { m } \\sum _ { \\mu = 1 } ^ { m } ( x _ { i _ { 1 } } ^ { \\mu } - y _ { i _ { 1 } } ^ { \\mu } ) x _ { j _ { 2 } } ^ { \\mu } + x _ { j _ { 1 } } ^ { \\mu } x _ { j _ { 2 } } ^ { \\mu } } } & { { j _ { 1 } = i _ { 2 } , i _ { 1 } = i _ { 2 } } } \\\\ { { \\frac { 1 } { m } \\sum _ { \\mu = 1 } ^ { m } ( x _ { i _ { 1 } } ^ { \\mu } - y _ { i _ { 1 } } ^ { \\mu } ) x _ { j _ { 2 } } ^ { \\mu } } } & { { j _ { 1 } = i _ { 2 } , i _ { 1 } \\neq i _ { 2 } } } \\\\ { { \\frac { 1 } { m } \\sum _ { \\mu = 1 } ^ { m } x _ { j _ { 1 } } ^ { \\mu } x _ { j _ { 2 } } ^ { \\mu } } } & { { j _ { 1 } \\neq i _ { 2 } , i _ { 1 } = i _ { 2 } } } \\\\ { { 0 } } & { { j _ { 1 } \\neq i _ { 2 } , i _ { 1 } \\neq i _ { 2 } } } \\end{array} \\right. } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            238,
+            511,
+            787,
+            619
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "In the same way, we can rewrite $A$ as ",
+        "bbox": [
+            232,
+            630,
+            478,
+            645
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fb3ea221226d2a049a0b50aebef28e6d74889673848be71c7cba19a17cc8f18d.jpg",
+        "text": "$$\n\\boldsymbol { A } = \\left[ \\begin{array} { l l l } { \\boldsymbol { \\Sigma } ^ { X X } - \\boldsymbol { \\Sigma } ^ { Y X } } & & \\\\ & { \\boldsymbol { \\cdot } } & \\\\ & & { \\boldsymbol { \\cdot } \\boldsymbol { \\cdot } } & \\\\ & & { \\boldsymbol { \\Sigma } ^ { X X } - \\boldsymbol { \\Sigma } ^ { Y X } } \\end{array} \\right] \\boldsymbol { P } ^ { T } + \\boldsymbol { B } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            349,
+            647,
+            705,
+            707
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "B EXPERIMENT SETUP ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            751,
+            379,
+            767
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "We took the experiments on whitened versions of MNIST. 10 greatest principal components are kept for the dataset inputs. The dataset outputs are represented using one-hot encoding. The network was trained using gradient descent. For every epoch, the Hessians of the networks were calculated using the method proposed in (Bishop, 1992). As the $| \\lambda | _ { \\operatorname* { m i n } }$ of Hessian is usually very unstable, we calculated $\\frac { | \\lambda | _ { \\operatorname* { m a x } } } { | \\lambda | _ { ( 0 . 1 ) } }$ to represent condition number instead, where $| \\lambda | _ { ( 0 . 1 ) }$ is the $1 0 ^ { \\mathrm { t h } }$ percentile of the absolute values of eigenvalues. ",
+        "bbox": [
+            173,
+            780,
+            825,
+            872
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "As pre, mid or post positions are not defined in linear networks without shortcuts, when comparing Xavier or orthogonal initialized linear networks to 2-shortcut networks, we added ReLUs at the same positions in linear networks as in 2-shortcuts networks. ",
+        "bbox": [
+            173,
+            878,
+            823,
+            921
+        ],
+        "page_idx": 14
+    }
+]

parse/train/o966_Is_nPA/o966_Is_nPA.md

@@ -0,0 +1,415 @@
+# NEURAL PRUNING VIA GROWING REGULARIZATION
+
+Huan Wang, Can Qin, Yulun Zhang∗, Yun Fu Northeastern University, Boston, MA, USA {wang.huan, qin.ca}@northeastern.edu, yulun100@gmail.com, yunfu@ece.neu.edu
+
+# ABSTRACT
+
+Regularization has long been utilized to learn sparsity in deep neural network pruning. However, its role is mainly explored in the small penalty strength regime. In this work, we extend its application to a new scenario where the regularization grows large gradually to tackle two central problems of pruning: pruning schedule and weight importance scoring. (1) The former topic is newly brought up in this work, which we find critical to the pruning performance while receives little research attention. Specifically, we propose an $L _ { 2 }$ regularization variant with rising penalty factors and show it can bring significant accuracy gains compared with its one-shot counterpart, even when the same weights are removed. (2) The growing penalty scheme also brings us an approach to exploit the Hessian information for more accurate pruning without knowing their specific values, thus not bothered by the common Hessian approximation problems. Empirically, the proposed algorithms are easy to implement and scalable to large datasets and networks in both structured and unstructured pruning. Their effectiveness is demonstrated with modern deep neural networks on the CIFAR and ImageNet datasets, achieving competitive results compared to many state-of-the-art algorithms. Our code and trained models are publicly available at https://github.com/mingsuntse/regularization-pruning.
+
+# 1 INTRODUCTION
+
+As deep neural networks advance in recent years LeCun et al. (2015); Schmidhuber (2015), their remarkable effectiveness comes at a cost of rising storage, memory footprint, computing resources and energy consumption Cheng et al. (2017); Deng et al. (2020). Neural network pruning Han et al. (2015; 2016); Li et al. (2017); Wen et al. (2016); He et al. (2017); Gale et al. (2019) is deemed as a promising force to alleviate this problem. Since its early debut Mozer & Smolensky (1989); Reed (1993), the central problem of neural network pruning has been (arguably) how to choose weights to discard, i.e., the weight importance scoring problem LeCun et al. (1990); Hassibi & Stork (1993); Molchanov et al. (2017b; 2019); Wang et al. (2019a); He et al. (2020).
+
+The approaches to the scoring problem generally fall into two groups: importance-based and regularization-based Reed (1993). The former focuses on directly proposing certain theoretically sound importance criterion so that we can prune the unimportant weights once for all. Thus, the pruning process is typically one-shot. In contrast, regularization-based approaches typically select unimportant weights through training with a penalty term Han et al. (2015); Wen et al. (2016); Liu et al. (2017). However, the penalty strength is usually maintained in a small regime to avoid damaging the model expressivity. Whereas, a large penalty strength can be helpful, specifically in two aspects. (1) A large penalty can push unimportant weights rather close to zero, then the pruning later barely hurts the performance even if the simple weight magnitude is adopted as criterion. (2) It is well-known that different weights of a neural network lie on the regions with different local quadratic structures, i.e., Hessian information. Many methods try to tap into this to build a more accurate scoring LeCun et al. (1990); Hassibi & Stork (1993); Wang et al. (2019a); Singh & Alistarh (2020). However, for deep networks, it is especially hard to estimate Hessian. Sometimes, even the computing itself can be intractable without resorting to proper approximation Wang et al. (2019a). On this problem, we ask: Is it possible to exploit the Hessian information without knowing their specific values? This is the second scenario where a growing regularization can help. We will show under a growing regularization, the weight magnitude will naturally separate because of their different underlying local quadratic structure, therein we can pick the unimportant weights more faithfully even using the simple magnitude-based criterion. Corresponding to these two aspects, we will present two algorithms based on a growing $L _ { 2 }$ regularization paradigm, in which the first highlights a better pruning schedule1 and the second explores a better pruning criterion.
+
+Our contributions. (1) We propose a simple yet effective growing regularization scheme, which can help transfer the model expressivity to the remaining part during pruning. The encouraging performance inspires us that the pruning schedule may be as critical as the weight importance criterion and deserve more research attention. (2) We further adopt growing regularization to exploit Hessian implicitly, without knowing their specific values. The method can help choose the unimportant weights more faithfully with a theoretically sound basis. In this regard, our paper is the first to show the connection between magnitude-based pruning and Hessian-based pruning, pointing out that the latter can be turned into the first one through our proposed growing regularization scheme. (3) The proposed two algorithms are easy to implement and scalable to large-scale datasets and networks. We show their effectiveness compared with many state-of-the-arts. Especially, the methods can work seamlessly for both filter pruning and unstructured pruning.
+
+# 2 RELATED WORK
+
+Regularization-based pruning. The first group of relevant works is those applying regularization to learn sparsity. The most famous probably is to use $L _ { 0 }$ or $L _ { 1 }$ regularization Louizos et al. (2018); Liu et al. (2017); Ye et al. (2018) due to their sparsity-inducing nature. In addition, the common $L _ { 2 }$ regularization is also explored for approximated sparsity Han et al. (2015; 2016). The early papers focus more on unstructured pruning, which is beneficial to model compression yet not to acceleration. For structured pruning in favor of acceleration, Group-wise Brain Damage Lebedev & Lempitsky (2016) and SSL Wen et al. (2016) propose to use Group LASSO Yuan & Lin (2006) to learn regular sparsity, where the penalty strength is still kept in small scale because the penalty is uniformly applied to all the weights. To resolve this, Ding et al. (2018) and Wang et al. (2019c) propose to employ different penalty factors for different weights, enabling large regularization.
+
+Importance-based pruning. Importance-based pruning tries to establish certain advanced importance criteria that can reflect the true relative importance among weights as faithfully as possible. The pruned weights are usually decided immediately by some proposed formula instead of by training (although the whole pruning process can involve training, e.g., iterative pruning). The most widely used criterion is the magnitude-based: weight absolute value for unstructured pruningHan et al. (2015; 2016) or $L _ { 1 } / L _ { 2 }$ -norm for structured pruning Li et al. (2017). This heuristic criterion was proposed a long time ago Reed (1993) and has been argued to be inaccurate. In this respect, improvement mainly comes from using Hessian information to obtain a more accurate approximation of the increased loss when a weight is removed LeCun et al. (1990); Hassibi & Stork (1993). Hessian is intractable to compute for large networks, so some methods (e.g., EigenDamage Wang et al. (2019a), WoodFisher Singh & Alistarh (2020)) employ cheap approximation (such as K-FAC Fisher Martens & Grosse (2015)) to make the 2nd-order criteria tractable on deep networks.
+
+Note that, there is no a hard boundary between the importance-based and regularization-based. Many papers present their schemes in the combination of the two Ding et al. (2018); Wang et al. (2019c). The difference mainly lies in their emphasis: Regularization-based method focuses more on an advanced penalty scheme so that the subsequent pruning criterion can be simple; while the importance-based one focus more on an advanced importance criterion itself. Meanwhile, regularization paradigm always involves iterative training, while the importance-based can be one-shot LeCun et al. (1990); Hassibi & Stork (1993); Wang et al. (2019a) (no training for picking weights to prune) or involve iterative training Molchanov et al. (2017b; 2019); Ding et al. (2019a;b).
+
+Other model compression methods. Apart from pruning, there are also many other model compression approaches, e.g., quantization Courbariaux & Bengio (2016); Courbariaux et al. (2016); Rastegari et al. (2016), knowledge distillation Bucilua et al. ˇ (2006); Hinton et al. (2014), lowrank decomposition Denton et al. (2014); Jaderberg et al. (2014); Lebedev et al. (2014); Zhang et al. (2015), and efficient architecture design or search Howard et al. (2017); Sandler et al. (2018); Howard et al. (2019); Zhang et al. (2018); Tan & Le (2019); Zoph & Le (2017); Elsken et al. (2019). They are orthogonal to network pruning and can work with the proposed methods to compress more.
+
+# 3 PROPOSED METHOD
+
+# 3.1 PROBLEM FORMULATION
+
+Pruning can be formulated as a transformation $T ( * )$ that takes a pretrained big model w as input and output a small model $\mathbf { w } _ { 1 }$ , typically followed by a fine-tuning process $F ( * )$ , which gives us the final output $\mathbf { w } _ { 2 } = F ( \mathbf { w } _ { 1 } )$ . We do not focus on $F ( * )$ since it is simply a standard neural network training process, but focus on the process of $\mathbf { w } _ { 1 } = T ( \mathbf { w } )$ . The effect of pruning can be further specified into two sub-transformations: (1) $M = T _ { 1 } ( \mathbf { w } )$ , which obtains a binary mask vector $M$ that decides which weights will be removed; (2) $T _ { 2 } ( \mathbf { w } )$ , which adjusts the values of remaining weights. That is,
+
+$$
+\mathbf { w } _ { 1 } = T ( \mathbf { w } ) = T _ { 1 } ( \mathbf { w } ) \odot T _ { 2 } ( \mathbf { w } ) = M \odot T _ { 2 } ( \mathbf { w } ) .
+$$
+
+For one-shot pruning, there is no iterative training at $T _ { 1 }$ . It depends on a specific algorithm to decide whether to adjust the remaining weights. For example, OBD LeCun et al. (1990) and $L _ { 1 }$ - norm pruning Li et al. (2017) do not adjust the kept weights (i.e., $T _ { 2 }$ is the identity function) while OBS Hassibi & Stork (1993) does. For learning-based pruning, both $T _ { 1 }$ and $T _ { 2 }$ involve iterative training and the kept weights will always be adjusted.
+
+In the following, we will present our algorithms in the filter pruning scenario since we mainly focus on model acceleration instead of compression in this work. Nevertheless, the methodology can seamlessly translate to the unstructured pruning case. The difference lies in how we define the weight group: For filter pruning, a 4-d tensor convolutional filter (or 2-d tensor for fully-connected layers) is regarded as a weight group, while for unstructured pruning, a single weight makes a group.
+
+# 3.2 PRUNING SCHEDULE: GREG-1
+
+Our first method (GReg-1) is a variant of $L _ { 1 }$ -norm pruning Li et al. (2017). It obtains the mask $M$ by $L _ { 1 }$ -norm sorting but adjusts the kept weights via regularization. Specifically, given a pre-trained model w and layer pruning ratio $r _ { l }$ , we sort the filters by $L _ { 1 }$ -norm and set the mask to zero for those with the least norms. Then, unlike Li et al. (2017) which removes the unimportant weights immediately (i.e., one-shot fashion), we impose a growing $L _ { 2 }$ penalty to drive them to zero first:
+
+$$
+\lambda _ { j } = \lambda _ { j } + \delta \lambda , j \in \{ j \mid M [ j ] = 0 \} ,
+$$
+
+where $\lambda _ { j }$ is the penalty factor for $j$ -th weight; $\delta \lambda$ is the granularity in which we add up the penalty. Clearly, a smaller $\delta \lambda$ means this regularization process smoother. Besides, $\lambda _ { j }$ is only updated every $K _ { u }$ iterations, which is a buffer time to let the network adapt to the new regularization. This algorithm is to explore whether the way we remove them (i.e., pruning schedule) leads to a difference given the same weights to prune. Simple as it is, the scheme can bring significant accuracy gains especially under a large pruning ratio (Tab. 1). Note that, we intentionally set $\delta \lambda$ the same for all the unimportant weights to keep the core idea simple. Natural extensions of using different penalty factors for different weights (such as those in Ding et al. (2018); Wang et al. (2019c)) may be worth exploring but out of the scope of this work.
+
+When $\lambda _ { j }$ reaches a pre-set ceiling $\tau$ , we terminate the training and prune those with the least $L _ { 1 }$ - norms, then fine-tune. Notably, the pruning will barely hurt the accuracy since the unimportant weights have been compressed to typically less than $\frac { 1 } { 1 0 0 0 }$ the magnitude of remaining weights.
+
+# 3.3 IMPORTANCE CRITERION: GREG-2
+
+Our second algorithm is to further take advantage of the growing regularization scheme, not for pruning schedule but scoring. The training of neural networks is prone to overfitting, so regularization is normally employed. $L _ { 2 }$ regularization (or referred to as weight decay) is a standard technique for deep network training. Given a dataset $\mathcal { D }$ , model parameters $\mathbf { w }$ , the total loss will typically be
+
+$$
+\mathcal { E } ( \mathbf { w } , \mathcal { D } ) = \mathcal { L } ( \mathbf { w } , \mathcal { D } ) + \frac { 1 } { 2 } \lambda \| \mathbf { w } \| _ { 2 } ^ { 2 } ,
+$$
+
+where $\mathcal { L }$ is the task loss function. When the training converges, there should be
+
+$$
+\lambda w _ { i } ^ { * } + \frac { \partial \mathcal { L } } { \partial w _ { i } } | _ { w _ { i } = w _ { i } ^ { * } } = 0 ,
+$$
+
+where $\boldsymbol { w } _ { i } ^ { * }$ indicates the $i$ -th weight at its local minimum. Eq. (4) shows that, for each specific weight element, its equilibrium position is determined by two forces: loss gradient (i.e., guidance from the task) and regularization gradient (i.e., guidance from our prior). Our idea is to slightly increase the $\lambda$ to break the equilibrium and see how it results in a new one. A general impression is: If $\lambda$ goes a little higher, the penalty force will drive the weights further towards origin and it will not stop unless proper loss gradient comes to halt it and then a new equilibrium is reached at $\hat { w } _ { i } ^ { * }$ . Considering different weights have different scales, we define a ratio $r _ { i } = \hat { w } _ { i } ^ { * } / w _ { i } ^ { * }$ to describe how much the weight magnitude changes after increasing the penalty factor. Our interest lies in how the $r _ { i }$ differs from one another and how it relates to the underlying Hessian information.
+
+Deep neural networks are well-known over-parameterized and highly non-convex. To obtain a feasible analysis, we adopt a local quadratic approximation of the loss function based on Taylor series expansion Strang (1991) following common practices LeCun et al. (1990); Hassibi & Stork (1993); Wang et al. (2019a). Then when the model is converged, the error $\mathcal { E }$ can be described by the converged weights $\mathbf { w } ^ { * }$ and the underlying Hessian matrix $\mathbf { H }$ (note $\mathbf { H }$ is p.s.d. since the model is converged). After increasing the penalty $\lambda$ by $\delta \lambda$ , the new converged weights can be proved to be
+
+$$
+\hat { \mathbf { w } } ^ { * } = ( \mathbf { H } + \delta \lambda \mathbf { I } ) ^ { - 1 } \mathbf { H } \mathbf { w } ^ { * } ,
+$$
+
+where $\mathbf { I }$ stands for the identity matrix. Here we meet with the common problem of estimating Hessian and its inverse, which are well-known to be intractable for deep neural networks. We explore two simplified cases to help us move forward.
+
+(1) $\mathbf { H }$ is diagonal, which is a common simplification for Hessian LeCun et al. (1990), implying that the weights are independent of each other. For $w _ { i } ^ { * }$ with second derivative $h _ { i i }$ . With $L _ { 2 }$ penalty increased by $\delta \lambda$ $( \delta \lambda > 0 )$ , the new converged weights can be proved to be
+
+$$
+\hat { w } _ { i } ^ { * } = \frac { h _ { i i } } { h _ { i i } + \delta \lambda } w _ { i } ^ { * } , \Rightarrow r _ { i } = \frac { \hat { w } _ { i } ^ { * } } { w _ { i } ^ { * } } = \frac { 1 } { \delta \lambda / h _ { i i } + 1 } ,
+$$
+
+where $r _ { i } \in [ 0 , 1 )$ since $h _ { i i } \geq 0$ and $\delta \lambda > 0$ . As seen, larger $h _ { i i }$ results in larger $r _ { i }$ (closer to 1), meaning that the weight is relatively less moved towards the origin. Our second algorithm primarily builds upon this finding, which implies when we add a penalty perturbation to the converged network, the way that different weights respond can reflect their underlying Hessian information.
+
+(2) In practice, we know $\mathbf { H }$ is rarely diagonal. How the dependency among weights affects the finding abovecase, namely, $\begin{array} { r } { \mathbf { w } ^ { * } = \binom { w _ { 1 } ^ { * } } { w _ { 2 } ^ { * } } , \mathbf { H } = \binom { h _ { 1 1 } h _ { 1 2 } } { h _ { 1 2 } h _ { 2 2 } } , \hat { \mathbf { H } } = \binom { h _ { 1 1 } + \delta \lambda } { h _ { 1 2 } } _ { h _ { 2 2 } + \delta \lambda } } \end{array}$ an in Eq. (5. The new c e explore the 2-derged weights can be analytically solved below, where the approximation equality is because that $\delta \lambda$
+
+$$
+\left\{ \hat { w } _ { 1 } ^ { * } \right\} = \frac { 1 } { | \hat { \mathbf { H } } | } \left\{ \begin{array} { l l } { ( h _ { 1 1 } h _ { 2 2 } + h _ { 1 1 } \delta \lambda - h _ { 1 2 } ^ { 2 } ) w _ { 1 } ^ { * } + \delta \lambda h _ { 1 2 } w _ { 2 } ^ { * } } \\  ( h _ { 1 1 } h _ { 2 2 } + h _ { 2 2 } \delta \lambda - h _ { 1 2 } ^ { 2 } ) w _ { 2 } ^ { * } + \delta \lambda h _ { 1 2 } w _ { 1 } ^ { * } \right\} \approx \frac { 1 } { | \hat { \mathbf { H } } | } \left\{ \begin{array} { l l } { ( h _ { 1 1 } h _ { 2 2 } + h _ { 1 1 } \delta \lambda - h _ { 1 2 } ^ { 2 } ) w _ { 1 } ^ { * } } \\ { ( h _ { 1 1 } h _ { 2 2 } + h _ { 2 2 } \delta \lambda - h _ { 1 2 } ^ { 2 } ) w _ { 2 } ^ { * } + \delta \lambda h _ { 1 2 } w _ { 1 } ^ { * } } \end{array} \right\} , \end{array}
+$$
+
+$$
+\Rightarrow r _ { 1 } = \frac { 1 } { \left| \hat { \mathbf { H } } \right| } ( h _ { 1 1 } h _ { 2 2 } + h _ { 1 1 } \delta \lambda - h _ { 1 2 } ^ { 2 } ) , r _ { 2 } = \frac { 1 } { \left| \hat { \mathbf { H } } \right| } ( h _ { 1 1 } h _ { 2 2 } + h _ { 2 2 } \delta \lambda - h _ { 1 2 } ^ { 2 } ) .
+$$
+
+As seen, $h _ { 1 1 } > h _ { 2 2 }$ also leads to $r _ { 1 } > r _ { 2 }$ , in line with the finding above. The existence of weight dependency (i.e., the $h _ { 1 2 }$ ) actually does not affect the conclusion since it is included in both ratios.
+
+These theoretical analyses show us that when the penalty is increased at the same pace, because of different local curvature structures, the weights actually respond differently – weights with larger curvature will be less moved. As such, the magnitude discrepancy among weights will be magnified as $\lambda$ grows. Ultimately, the weights will naturally separate (see Fig. 1 for an empirical validation). When the discrepancy is large enough, even the simple $L _ { 1 }$ -norm can make an accurate criterion. Notably, the whole process happens itself with the uniformly rising $L _ { 2 }$ penalty, no need to know the Hessian values, thus not bothered by any issue arising from Hessian approximation in relevant prior arts LeCun et al. (1990); Hassibi & Stork (1993); Wang et al. (2019a); Singh & Alistarh (2020).
+
+In terms of the specific algorithm, all the penalty factor is increased at the same pace,
+
+$$
+\lambda _ { j } = \lambda _ { j } + \delta \lambda , { \mathrm { ~ f o r ~ a l l ~ } } j .
+$$
+
+# Algorithm 1 GReg-1 and GReg-2 Algorithms
+
+1: Input: Pre-trained model w, pruning ratio for $l$ -th layer $r _ { l } , l = 1 \sim L$ , original weight decay $\gamma$   
+2: Input: Regularization ceiling $\tau$ , ceiling for picking $\cdot$ , interval $K _ { u } , K _ { s }$ , granularity $\delta \lambda$ .   
+3: Init: Iteration $i = 0$ . $\lambda _ { j } = 0$ for all filter $j$ . Set kept filter indexes $S _ { l } ^ { k }$ to $\mathcal { D }$ for each layer $l$ .   
+4: Init: Set pruned filter indexes $S _ { l } ^ { p }$ by $L _ { 1 }$ -norm sorting, set $S _ { l } ^ { p }$ to full set, for each layer $l$ .   
+5: while $\lambda _ { j } \overset { \cdot } { \leq } \tau , j \in S _ { l } ^ { p }$ do   
+6: if i % $K _ { u } = 0$ then   
+7: if $\cdot$ and $\lambda _ { j } > \tau ^ { \prime } , j \in S _ { l } ^ { p }$ then   
+8: Set $S _ { l } ^ { p }$ by $\cdot$ -norm scoring, $S _ { l } ^ { k }$ as the complementary set of $S _ { l } ^ { p }$ , for each layer $\cdot$ .   
+9: end if   
+10: $\lambda _ { j } = \lambda _ { j } + \delta \lambda$ for $j \in S _ { l } ^ { p }$ , $\lambda _ { j } = - \gamma$ for $j \in S _ { l } ^ { k }$ , for each layer $l$   
+11: end if   
+12: Weight update by stochastic gradient descent (where the regularization is enforced).   
+13: $i = i + 1$ .   
+14: end while   
+15: Train for another $K _ { s }$ iterations to stabilize. Then prune by $L _ { 1 }$ -norms and get model $\mathbf { w } _ { 1 }$ .   
+16: Fine-tune $\mathbf { w } _ { 1 }$ to regain accuracy.   
+17: Output: Pruned model $\mathbf { w } _ { 2 }$ .
+
+When $\lambda _ { j }$ reaches some ceiling $\tau ^ { \prime }$ , the magnitude gap turns large enough to let $L _ { 1 }$ -norm do scoring faithfully. After this, the procedures are similar to those in GReg-1: $\lambda$ for the unimportant weights are further increased. One extra step is to bring back the kept weights to the normal magnitude. Although they are the “survivors” during the previous competition under a large penalty, their expressivity are also hurt. To be exact, we adopt negative penalty factor for the kept weights to encourage them to recover. When the $\lambda$ for unimportant weights reaches the threshold $\tau$ (akin to that of GReg-1), the training is terminated. $L _ { 1 }$ -pruning is conducted and then fine-tune to regain accuracy. To this end, the proposed two algorithms can be summarized in Algorithm 1.
+
+Pruning ratios. We employ pre-specified pruning ratios in this work to keep the core method neat (see Appendix for more discussion). Exploring layer-wise sensitivity is out of the scope of this work, but clearly any method that finds more proper pruning ratios can readily work with our approaches.
+
+Discussion: differences from IncReg. Although our work shares a general spirit of growing regularization with IncReg Wang et al. (2019c;b), our work is actually starkly different from theirs in many axes:
+
+• Motivation. The motivations for using the growing regularization are different. Wang et al. (2019c;b) adopt growing regularization to select the unimportant weights by training. Namely, they focus on the importance criterion problem. In contrast, we use growing regularization to investigate the pruning schedule problem (for GReg-1) or exploit the underlying Hessian information (for GReg-2). The importance criterion is simply $L _ { 1 }$ -norm.   
+Algorithm design. Wang et al. (2019c;b) assign different regularization factors to different weight groups based on their relative importance, while we assign them with the same factors. For GReg-1, this may not be a substantial difference, while for GReg-2, the difference is fundamental because the theoretical analysis of GReg-2 (Sec. 3.3) relies on the fact that regularization factors are kept the same for different weights.   
+Theoretical analysis. The algorithm in Wang et al. (2019c;b) is generally heuristic-based, while our work provides rigorous theoretical analyses (Sec. 3.3) to support the proposed algorithm GReg-2.   
+• Empirical performance. Both our methods are significantly better than Wang et al. (2019c;b) on the large-scale ImageNet dataset, which will be shown in the experiment section (Tab. 3).
+
+Discussion: other regularization forms. The proposed methods in this work adopts $L _ { 2 }$ regularization. Here we discuss the possibility to generalize the method to other regularization forms ( $L 1$ and $L _ { 0 }$ ). (1) For GReg-1, it can be easily generalized to other regularization forms like $L _ { 1 }$ . For GReg-2, since the theoretical basis in Sec. 3.3 relies on the local quadratic approximation, $L _ { 2 }$ regularization meets this requirement while $L _ { 1 }$ does not. Therefore, GReg-2 cannot be (easily) generalized to the
+
+Table 1: Comparison between pruning schedules: one-shot pruning vs. our proposed GReg-1. Each setting is randomly run for 3 times, mean and std accuracies reported.   
+
+<table><tr><td colspan="6">ResNet56 + CIFAR10: Baseline accuracy 93.36%, #Params: 0.8530M,FLOPs: 0.1255G</td></tr><tr><td>Pruning ratio r (%)</td><td>50</td><td>70</td><td>90</td><td>92.5</td><td>95</td></tr><tr><td>Sparsity (%)/ Speedup</td><td>49.82/1.99×</td><td>70.57/3.59×</td><td>90.39/11.41×</td><td>93.43/14.76×</td><td>95.19/19.31×</td></tr><tr><td>Acc.(%,L1+one-shot)</td><td>92.97±0.15</td><td>91.88±0.09</td><td>87.34±0.21</td><td>87.31±0.28</td><td>82.79±0.22</td></tr><tr><td>Acc.(%,GReg-1,ours)</td><td>93.06±0.09</td><td>92.23±0.21</td><td>89.49±0.23</td><td>88.39±0.15</td><td>85.97±0.16</td></tr><tr><td>Acc. gain (%)</td><td>0.09</td><td>0.35</td><td>2.15</td><td>1.08</td><td>3.18</td></tr><tr><td colspan="6">VGG19 + CIFAR100: Baseline accuracy 74.02%,#Params: 20.0812M,FLOPs: 0.3982G</td></tr><tr><td>Pruning ratio r (%)</td><td>50</td><td>60</td><td>70</td><td>80</td><td>90</td></tr><tr><td>Sparsity(%)/Speedup</td><td>74.87/3.60×</td><td>84.00/5.41×</td><td>90.98/8.84×</td><td>95.95/17.30×</td><td>98.96/44.22×</td></tr><tr><td>Acc.(%,L1+one-shot)</td><td>71.49±0.14</td><td>70.27±0.12</td><td>66.05±0.04</td><td>61.59±0.03</td><td>51.36±0.11</td></tr><tr><td>Acc.(%,GReg-1,ours)</td><td>71.50±0.12</td><td>70.33±0.12</td><td>67.35±0.15</td><td>63.55±0.29</td><td>57.09±0.03</td></tr><tr><td>Acc. gain (%)</td><td>0.01</td><td>0.06</td><td>1.30</td><td>1.96</td><td>5.73</td></tr></table>
+
+$L _ { 1 }$ regularization as far as we can see currently. (2) For $L _ { 0 }$ regularization, it is well-known NP-hard.   
+In practice, it is typically converted to the $L _ { 1 }$ regularization case, which we just discussed.
+
+# 4 EXPERIMENTAL RESULTS
+
+Datasets and networks. We first conduct analyses on the CIFAR10/100 datasets Krizhevsky (2009) with ResNet56 He et al. (2016)/VGG19 Simonyan & Zisserman (2015). Then we evaluate our methods on the large-scale ImageNet dataset Deng et al. (2009) with ResNet34 and 50 He et al. (2016). For CIFAR datasets, we train our baseline models with accuracies comparable to those in the original papers. For ImageNet, we take the official PyTorch Paszke et al. (2019) pre-trained models2 as baseline to maintain comparability with other methods.
+
+Training settings. To control the irrelevant factors as we can, for comparison methods that release their pruning ratios, we will adopt their ratios; otherwise, we will use our specified ones. We compare the speedup (measured by FLOPs reduction) since we mainly target model acceleration rather than compression. Detailed training settings (e.g., hyper-parameters and layer pruning ratios) are summarized in the Appendix.
+
+# 4.1 RESNET56/VGG19 ON CIFAR-10/100
+
+Pruning schedule: GReg-1. First, we explore the effect of different pruning schedules on the performance of pruning. Specifically, we conduct two sets of experiments for comparison: (1) prune by $L _ { 1 }$ -norm sorting and fine-tune Li et al. (2017) (shorted as $^ { \cdot \cdot } L _ { 1 } +$ one-shot”); (2) employ the proposed growing regularization scheme (“GReg-1”) and fine-tune. We use a uniform pruning ratio scheme here: Pruning ratio $r$ is the same for all $l$ -th conv layer (the first layer is not pruned following common practice Gale et al. (2019)). For ResNet56, since it has the residual addition restriction, we only prune the first conv layer in a block as previous works do Li et al. (2017). For comprehensive comparisons, the pruning ratios vary in a large spectrum, covering acceleration ratios from around $2 \times$ to $4 4 \times$ . Note that we do not intend to obtain the best performance here but systematically explore the effect of different pruning schedules, so we employ relatively simple settings (e.g., the uniform pruning ratios). For fair comparisons, the fine-tuning scheme (e.g., number of epochs, learning rate schedule, etc.) is the same for different methods. Therefore, the key comparison here is to see which method can deliver a better base model before fine-tuning.
+
+The results are shown in Tab. 1. We have the following observations: (1) On the whole, the proposed GReg-1 consistently outperforms $L _ { 1 }$ +one-shot. It is important to reiterate that the two settings have exactly the same pruned weights, so the only difference is how they are removed. The accuracy gaps show that apart from importance scoring, pruning schedule is also a critical factor. In the Appendix D, we present more results to demonstrate this finding actually is general, not merely limited to the case of $L _ { 1 }$ -norm criterion. The proposed regularization-based pruning schedule is consistently more favorable than the one-shot counterpart. (2) The larger pruning ratio, the more pronounced of the gain. This is reasonable since when more weights are pruned, the network cannot recover by its inherent plasticity Mittal et al. (2018), then the regularization-based way is more helpful because it helps the model transfer its expressive power to the remaining part. When the pruning ratio is relatively small (such as ResNet56, $r = 5 0 \%$ ) , the plasticity of the model is enough to heal, so the benefit from GReg-1 is less significant compared with the one-shot counterpart.
+
+![](images/ac428ab6cf517902459262b7ec3fb69d47cf04a2e15dd1400507d10a01bda824.jpg)  
+Figure 1: Row 1: Illustration of weight separation as $L _ { 2 }$ penalty grows. Row 2: Normalized filter $L _ { 1 }$ -norm over iterations for ResNet50 layer2.3.conv1 (please see the Appendix for VGG19 plots).
+
+Table 2: Comparison of different methods on the CIFAR10 and CIFAR100 datasets.   
+
+<table><tr><td>Method</td><td>Network/Dataset</td><td>Base acc.(%) Pruned acc. (%) Acc. drop Speedup</td><td></td><td></td><td></td></tr><tr><td>CP He et al. (2017)</td><td rowspan="6">ResNet56/CIFAR10</td><td>92.80</td><td>91.80</td><td>1.00</td><td>2.00×</td></tr><tr><td>AMC He et al. (2018b)</td><td>92.80</td><td>91.90</td><td>0.90</td><td>2.00×</td></tr><tr><td>SFP He et al. (2018a)</td><td>93.59</td><td>93.36</td><td>0.23</td><td>2.11×</td></tr><tr><td>AFP Ding et al. (2018)</td><td>93.93</td><td>92.94</td><td>0.99</td><td>2.56×</td></tr><tr><td>C-SGD Ding et al. (2019a)</td><td>93.39</td><td>93.44</td><td>-0.05</td><td>2.55×</td></tr><tr><td>GReg-1 (ours)</td><td>93.36</td><td>93.18</td><td>0.18</td><td>2.55×</td></tr><tr><td>GReg-2 (ours)</td><td></td><td>93.36</td><td>93.36</td><td>0.00</td><td>2.55×</td></tr><tr><td>Kron-OBD Wang et al. (2019a)</td><td rowspan="5"></td><td>73.34</td><td>60.70</td><td>12.64</td><td>5.73×</td></tr><tr><td>Kron-OBS Wang et al. (2019a)</td><td>73.34</td><td>60.66</td><td>12.68</td><td>6.09×</td></tr><tr><td>EigenDamage Wang et al. (2019a） VGG19/CIFAR100</td><td>73.34</td><td>65.18</td><td>8.16</td><td>8.80×</td></tr><tr><td>GReg-1 (ours)</td><td>74.02</td><td>67.55</td><td>6.67</td><td>8.84×</td></tr><tr><td>GReg-2 (ours)</td><td>74.02</td><td>67.75</td><td>6.47</td><td>8.84×</td></tr></table>
+
+Importance criterion: GReg-2. Here we empirically validate our finding in Sec. 3.3, that is, with uniformly rising $L _ { 2 }$ penalty, the weights should naturally separate. We claim, if $h _ { 1 1 } > h _ { 2 2 }$ , there should be $r _ { 1 } ~ > ~ r _ { 2 }$ , where $\begin{array} { r } { r _ { 1 } = \frac { \tilde { \hat { w _ { 1 } } } } { w _ { 1 } } , r _ { 2 } = \frac { \hat { w _ { 2 } } } { w _ { 2 } } } \end{array}$ (the \* mark indicating the local minimum is omitted here for readability). $r _ { 1 } ~ > ~ r _ { 2 }$ leads to $\frac { \bar { w } _ { 1 } } { w _ { 1 } } ~ > ~ \frac { \bar { w } _ { 2 } } { w _ { 2 } }$ , namely, $\begin{array} { r } { r _ { 1 } \ = \ \frac { \hat { w _ { 1 } } } { \hat { w _ { 2 } } } \ > \ \frac { w _ { 1 } } { w _ { 2 } } } \end{array}$ This shows that, after the $L _ { 2 }$ penalty grows a little, the new magnitude ratio of weight 1 over weight 2 will be magnified if $h _ { 1 1 } > h _ { 2 2 }$ $( w _ { 1 } , w _ { 2 }$ are positive in the analysis here, while the conclusion still holds if either of them is negative). In Fig. 1 (Row 1), we plot the standard deviation (divided by the means for normalization since the magnitude varies over iterations) of filter $L _ { 1 }$ -norms as the regularization grows. As seen, the normalized $L _ { 1 }$ -norm stddev grows larger and larger as $\lambda$ grows. This phenomenon consistently appears across different models and datasets. To figuratively understand how the increasing penalty affects the relative magnitude over time, in Fig. 1 (Row 2), we plot the relative $L _ { 1 }$ -norms (divided by the max $L _ { 1 }$ -norm for normalization) at different iterations. As shown, it is hard to tell which filters are really important by the initial filter magnitude (Iter 0), but under a large penalty later, their discrepancy turns more and more obvious and finally it is very easy to identify which filters are more important. Since the magnitude gap is so large, the simple $L _ { 1 }$ -norm can make a sufficiently faithful criterion.
+
+CIFAR benchmarks. Finally, we compare the proposed algorithms with existing methods on the CIFAR datasets (Tab. 2). Here we adopt non-uniform pruning ratios (see the Appendix for specific numbers) for the best accuracy-FLOPs trade-off. On CIFAR10, compared with AMC He et al.
+
+Table 3: Acceleration comparison on ImageNet. FLOPs: ResNet34: 3.66G, ResNet50: 4.09G.   
+
+<table><tr><td>Method</td><td>Network</td><td></td><td>Base top-1(%） Pruned top-1(%） Top-1 drop Speedup</td><td></td><td></td></tr><tr><td>L1 (pruned-B) Li et al. (2017) Taylor-FO Molchanov et al. (2019)</td><td rowspan="3">ResNet34</td><td>73.23 73.31</td><td>72.17 72.83</td><td>1.06 0.48</td><td>1.32× 1.29×</td></tr><tr><td>GReg-1 (ours)</td><td>73.31</td><td>73.54</td><td>-0.23</td><td>1.32×</td></tr><tr><td>GReg-2 (ours)</td><td>73.31</td><td>73.61</td><td>-0.30</td><td>1.32×</td></tr><tr><td>ProvableFPLiebenwein et al. (2020) GReg-1 (ours)</td><td>ResNet50</td><td>76.13 76.13</td><td>75.21 76.27</td><td>0.92 -0.14</td><td>1.43× 1.49×</td></tr><tr><td rowspan="2">AOFP Ding et al. (2019b) GReg-1 (ours)*</td><td rowspan="2">ResNet50</td><td>75.34</td><td>75.63</td><td>-0.29</td><td>1.49×</td></tr><tr><td>75.40</td><td>76.13</td><td>-0.73</td><td>1.49×</td></tr><tr><td>IncReg Wang et al. (2019b) SFP He et al. (2018a)</td><td></td><td>75.60 76.15</td><td>72.47 74.61</td><td>3.13 1.54</td><td>2.00× 1.72×</td></tr><tr><td>HRank Lin et al. (2020a) Taylor-FO Molchanov et al. (2019)</td><td rowspan="3">ResNet50</td><td>76.15</td><td>74.98</td><td>1.17</td><td>1.78×</td></tr><tr><td>Factorized Li et al. (2019)</td><td>76.18 76.15</td><td>74.50</td><td>1.68</td><td>1.82×</td></tr><tr><td></td><td></td><td>74.55</td><td>1.60</td><td>2.33×</td></tr><tr><td>DCP Zhuang et al. (2018) CCP-AC Peng et al. (2019)</td><td rowspan="3"></td><td>76.01</td><td>74.95</td><td>1.06</td><td>2.25×</td></tr><tr><td></td><td>76.15</td><td>75.32</td><td>0.83</td><td>2.18×</td></tr><tr><td>GReg-1 (ours)</td><td>76.13</td><td>75.16</td><td>0.97</td><td>2.31×</td></tr><tr><td>GReg-2 (ours) C-SGD-50 Ding et al. (2019a)</td><td rowspan="3">ResNet50</td><td>76.13</td><td>75.36</td><td>0.77</td><td>2.31×</td></tr><tr><td></td><td>75.34</td><td>74.54</td><td>0.80</td><td>2.26×</td></tr><tr><td>AOFP Ding et al. (2019b)</td><td>75.34</td><td>75.11</td><td>0.23</td><td>2.31×</td></tr><tr><td>GReg-2 (ours)*</td><td rowspan="3">ResNet50</td><td>75.40</td><td>75.22</td><td>0.18</td><td>2.31×</td></tr><tr><td>LFPC He et al. (2020)</td><td>76.15</td><td>74.46</td><td>1.69</td><td>2.55×</td></tr><tr><td>GReg-1 (ours)</td><td>76.13</td><td>74.85</td><td>1.28</td><td>2.56×</td></tr><tr><td>GReg-2 (ours)</td><td rowspan="3"></td><td>76.13</td><td>74.93</td><td>1.20</td><td>2.56×</td></tr><tr><td>IncReg Wang et al. (2019b)</td><td>75.60</td><td>71.07</td><td>4.53</td><td>3.00×</td></tr><tr><td>Taylor-FO Molchanov et al. (2019)</td><td>76.18</td><td>71.69</td><td></td><td>3.05×</td></tr><tr><td>GReg-1 (ours)</td><td rowspan="3">ResNet50</td><td></td><td></td><td>4.49</td><td></td></tr><tr><td></td><td>76.13</td><td>73.75</td><td>2.38</td><td>3.06×</td></tr><tr><td>GReg-2 (ours)</td><td>76.13</td><td>73.90</td><td>2.23</td><td>3.06×</td></tr></table>
+
+Since the base models of C-SGD and AOFP have a much lower accuracy than ours, for fair comparison, we rain our own base models with similar accuracy.
+
+Table 4: Compression comparison on ImageNet with ResNet50. #Parameters: 25.56M.   
+
+<table><tr><td>Method</td><td>Base top-1 (%)</td><td>Pruned top-1(%） Top-1 drop</td><td></td><td>Sparsity (%)</td></tr><tr><td>GSM Ding et al. (2019c)</td><td>75.72</td><td>74.30</td><td>1.42</td><td>80.00</td></tr><tr><td>Variational Dropout Molchanov et al. (2O17a)</td><td>76.69</td><td>75.28</td><td>1.41</td><td>80.00</td></tr><tr><td>DPF Lin et al. (2020b)</td><td>75.95</td><td>74.55</td><td>1.40</td><td>82.60</td></tr><tr><td>WoodFisher Singh &amp; Alistarh (2020)</td><td>75.98</td><td>75.20</td><td>0.78</td><td>82.70</td></tr><tr><td>GReg-1 (ours)</td><td>76.13</td><td>75.45</td><td>0.68</td><td>82.70</td></tr><tr><td>GReg-2 (ours)</td><td>76.13</td><td>75.27</td><td>0.86</td><td>82.70</td></tr></table>
+
+(2018b), though it adopts better layer-wise pruning ratios via reinforcement-learning, our algorithms can still deliver more favorable performance using sub-optimal human-specified ratios. AFP Ding et al. (2018) is another work exploring large regularization, while they do not adopt the growing scheme as we do. Its performance is also less favorable on CIFAR10 as shown in the table. Although our methods perform a little worse than C-SGD Ding et al. (2019a) on CIFAR10, on the large-scale ImageNet dataset, we will show our methods are significantly better than C-SGD.
+
+Notably, on CIFAR100, Kron-OBD/OBS (an extension by Wang et al. (2019a) of the original OBD/OBS from unstructured pruning to structured pruning) are believed to be more accurate than $L _ { 1 }$ -norm in terms of capturing relative weight importance LeCun et al. (1990); Hassibi & Stork (1993); Wang et al. (2019a). Yet, they are significantly outperformed by our GReg-1 based on the simple $L _ { 1 }$ -norm scoring. This may inspire us that an average pruning schedule (like the one-shot fashion) can offset the gain from a more advanced importance scoring scheme.
+
+# 4.2 RESNET34/50 ON IMAGENET
+
+Then we evaluate our methods on the standard large-scale ImageNet benchmarks with ResNets He et al. (2016). We refer to the official PyTorch ImageNet training example3 to make sure the implementation (such as data augmentation, weight decay, momentum, etc.) is standard. Please refer to the summarized training setting in the Appendix for details.
+
+The results are shown in Tab. 3. Methods with similar speedup are grouped together for easy comparison. In general, our method achieves comparable or better performance across various speedups on ResNet34 and 50. Concretely, (1) On both ResNet34 and 50, when the speedup is small (less than $2 \times$ ), only our methods (and AOFP Ding et al. (2019b) for ResNet50) can even improve the top-1 accuracy. This phenomenon is broadly found by previous works Wen et al. (2016); Wang et al. (2018); He et al. (2017) but mainly on small datasets like CIFAR, while we make it on the much challenging ImageNet benchmark. (2) Similar to the results on CIFAR (Tab. 1), when the speedup is larger, the advantage of our method is more obvious. For example, ours GReg-2 only outperforms Taylor-FO Molchanov et al. (2019) by $0 . 8 6 \%$ top-1 accuracy at the $\sim 2 \times$ setting, while at $\sim 3 \times$ , GReg-2 is better by $2 . 2 1 \%$ top-1 accuracy. (3) Many methods work on the weight importance criterion problem, including some very recent ones (ProvableFP Liebenwein et al. (2020), LFPC He et al. (2020)). Yet as shown, our simple variant of $L _ { 1 }$ -norm pruning can still be a strong competitor in terms of accuracy-FLOPs trade-off. This reiterates one of our key ideas in this work that the pruning schedule may be as important as weight importance scoring and worth more research attention.
+
+Unstructured pruning. Although we mainly target filter pruning in this work, the proposed methods actually can be applied to unstructured pruning as effectively. In Tab. 4, we present the results of unstructured pruning on ResNet50. WoodFisher Singh & Alistarh (2020) is the state-of-the-art Hessian-based unstructured pruning approach. Notably, without any Hessian approximation, our GReg-2 can achieve comparable performance with it (better absolute accuracy, yet slightly worse accuracy drop). Besides, the simple magnitude pruning variant GReg-1 delivers more favorable result, implying that a better pruning schedule also matters in the unstructured pruning case.
+
+# 5 CONCLUSION
+
+Regularization is long deemed as a sparsity-learning tool in neural network pruning, which usually works in the small strength regime. In this work, we present two algorithms that exploit regularization in a new fashion that the penalty factor is uniformly raised to a large level. Two central problems regarding deep neural pruning are tackled by the proposed methods, pruning schedule and weight importance criterion. The proposed approaches rely on few impractical assumptions, have a sound theoretical basis, and are scalable to large datasets and networks. Apart from the methodology itself, the encouraging results on CIFAR and ImageNet also justify our general ideas in this paper: (1) In addition to weight importance scoring, pruning schedule is another pivotal factor in deep neural pruning which may deserve more research attention. (2) Without any Hessian approximation, we can still tap into its power for pruning with the help of growing $L _ { 2 }$ regularization.
+
+# ACKNOWLEDGEMENTS
+
+The work is supported by the National Science Foundation Award ECCS-1916839 and the U.S. Army Research Office Award W911NF-17-1-0367.
+
+# REFERENCES
+
+Cristian Bucilua, Rich Caruana, and Alexandru Niculescu-Mizil. Model compression. In ˇ SIGKDD, 2006. 2
+
+Yu Cheng, Duo Wang, Pan Zhou, and Tao Zhang. A survey of model compression and acceleration for deep neural networks. arXiv preprint arXiv:1710.09282, 2017. 1
+
+M. Courbariaux and Y. Bengio. BinaryNet: Training deep neural networks with weights and activations constrained to $+ 1$ or $- 1$ . arXiv preprint arXiv:1602.02830, 2016. 2
+
+Matthieu Courbariaux, Itay Hubara, Daniel Soudry, Ran El-Yaniv, and Yoshua Bengio. Binarized neural networks: Training deep neural networks with weights and activations constrained to $+ 1$ or -1. arXiv preprint arXiv:1602.02830, 2016. 2
+
+Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. In CVPR, 2009. 6   
+Lei Deng, Guoqi Li, Song Han, Luping Shi, and Yuan Xie. Model compression and hardware acceleration for neural networks: A comprehensive survey. Proceedings of the IEEE, 108(4): 485–532, 2020. 1   
+Emily L Denton, Wojciech Zaremba, Joan Bruna, Yann LeCun, and Rob Fergus. Exploiting linear structure within convolutional networks for efficient evaluation. In NeurIPS, 2014. 3   
+Xiaohan Ding, Guiguang Ding, Jungong Han, and Sheng Tang. Auto-balanced filter pruning for efficient convolutional neural networks. In AAAI, 2018. 2, 3, 7, 8   
+Xiaohan Ding, Guiguang Ding, Yuchen Guo, and Jungong Han. Centripetal sgd for pruning very deep convolutional networks with complicated structure. In CVPR, 2019a. 2, 7, 8   
+Xiaohan Ding, Guiguang Ding, Yuchen Guo, Jungong Han, and Chenggang Yan. Approximated oracle filter pruning for destructive cnn width optimization. In ICML, 2019b. 2, 8, 9, 13   
+Xiaohan Ding, Xiangxin Zhou, Yuchen Guo, Jungong Han, Ji Liu, et al. Global sparse momentum sgd for pruning very deep neural networks. In NeurIPS, 2019c. 8   
+Thomas Elsken, Jan Hendrik Metzen, and Frank Hutter. Neural architecture search: A survey. JMLR, 20(55):1–21, 2019. 3   
+Trevor Gale, Erich Elsen, and Sara Hooker. The state of sparsity in deep neural networks. arXiv preprint arXiv:1902.09574, 2019. 1, 6   
+Song Han, Jeff Pool, John Tran, and William J Dally. Learning both weights and connections for efficient neural network. In NeurIPS, 2015. 1, 2   
+Song Han, Huizi Mao, and William J Dally. Deep compression: Compressing deep neural networks with pruning, trained quantization and huffman coding. In ICLR, 2016. 1, 2   
+B. Hassibi and D. G. Stork. Second order derivatives for network pruning: Optimal brain surgeon. In NeurIPS, 1993. 1, 2, 3, 4, 8   
+K. He, X. Zhang, S. Ren, and J. Sun. Deep residual learning for image recognition. In CVPR, 2016. 6, 8   
+Yang He, Guoliang Kang, Xuanyi Dong, Yanwei Fu, and Yi Yang. Soft filter pruning for accelerating deep convolutional neural networks. In IJCAI, 2018a. 7, 8   
+Yang He, Yuhang Ding, Ping Liu, Linchao Zhu, Hanwang Zhang, and Yi Yang. Learning filter pruning criteria for deep convolutional neural networks acceleration. In CVPR, 2020. 1, 8, 9   
+Yihui He, Xiangyu Zhang, and Jian Sun. Channel pruning for accelerating very deep neural networks. In ICCV, 2017. 1, 7, 9, 13   
+Yihui He, Ji Lin, Zhijian Liu, Hanrui Wang, Li-Jia Li, and Song Han. AMC: Automl for model compression and acceleration on mobile devices. In ECCV, 2018b. 7   
+Geoffrey Hinton, Oriol Vinyals, and Jeff Dean. Distilling the knowledge in a neural network. In NeurIPS Workshop, 2014. 2   
+Andrew Howard, Mark Sandler, Grace Chu, Liang-Chieh Chen, Bo Chen, Mingxing Tan, Weijun Wang, Yukun Zhu, Ruoming Pang, Vijay Vasudevan, et al. Searching for mobilenetv3. arXiv preprint arXiv:1905.02244, 2019. 3   
+Andrew G Howard, Menglong Zhu, Bo Chen, Dmitry Kalenichenko, Weijun Wang, Tobias Weyand, Marco Andreetto, and Hartwig Adam. Mobilenets: Efficient convolutional neural networks for mobile vision applications. arXiv preprint arXiv:1704.04861, 2017. 3   
+Max Jaderberg, Andrea Vedaldi, and Andrew Zisserman. Speeding up convolutional neural networks with low rank expansions. In BMVC, 2014. 3
+
+Alex Krizhevsky. Learning multiple layers of features from tiny images. Technical report, Citeseer, 2009. 6
+
+V. Lebedev and V. Lempitsky. Fast convnets using group-wise brain damage. In CVPR, 2016. 2
+
+Vadim Lebedev, Yaroslav Ganin, Maksim Rakhuba, Ivan Oseledets, and Victor Lempitsky. Speeding-up convolutional neural networks using fine-tuned cp-decomposition. arXiv preprint arXiv:1412.6553, 2014. 3
+
+Y. LeCun, J. S. Denker, and S. A. Solla. Optimal brain damage. In NeurIPS, 1990. 1, 2, 3, 4, 8, 13, 14, 15
+
+Yann LeCun, Yoshua Bengio, and Geoffrey Hinton. Deep learning. Nature, 521(7553):436, 2015. 1
+
+Hao Li, Asim Kadav, Igor Durdanovic, Hanan Samet, and Hans Peter Graf. Pruning filters for efficient convnets. In ICLR, 2017. 1, 2, 3, 6, 8, 14
+
+Tuanhui Li, Baoyuan Wu, Yujiu Yang, Yanbo Fan, Yong Zhang, and Wei Liu. Compressing convolutional neural networks via factorized convolutional filters. In CVPR, 2019. 8
+
+Lucas Liebenwein, Cenk Baykal, Harry Lang, Dan Feldman, and Daniela Rus. Provable filter pruning for efficient neural networks. In ICLR, 2020. 8, 9
+
+Mingbao Lin, Rongrong Ji, Yan Wang, Yichen Zhang, Baochang Zhang, Yonghong Tian, and Ling Shao. Hrank: Filter pruning using high-rank feature map. In CVPR, 2020a. 8
+
+Tao Lin, Sebastian U Stich, Luis Barba, Daniil Dmitriev, and Martin Jaggi. Dynamic model pruning with feedback. In ICLR, 2020b. 8
+
+Zhuang Liu, Jianguo Li, Zhiqiang Shen, Gao Huang, Shoumeng Yan, and Changshui Zhang. Learning efficient convolutional networks through network slimming. In ICCV, 2017. 1, 2
+
+Zhuang Liu, Mingjie Sun, Tinghui Zhou, Gao Huang, and Trevor Darrell. Rethinking the value of network pruning. In ICLR, 2019. 14
+
+Christos Louizos, Max Welling, and Diederik P Kingma. Learning sparse neural networks through l 0 regularization. In ICLR, 2018. 2
+
+James Martens and Roger Grosse. Optimizing neural networks with kronecker-factored approximate curvature. In ICML, 2015. 2
+
+Deepak Mittal, Shweta Bhardwaj, Mitesh M Khapra, and Balaraman Ravindran. Recovering from random pruning: On the plasticity of deep convolutional neural networks. In WACV, 2018. 7
+
+Dmitry Molchanov, Arsenii Ashukha, and Dmitry Vetrov. Variational dropout sparsifies deep neural networks. In ICML, 2017a. 8
+
+P. Molchanov, S. Tyree, and T. Karras. Pruning convolutional neural networks for resource efficient inference. In ICLR, 2017b. 1, 2
+
+Pavlo Molchanov, Arun Mallya, Stephen Tyree, Iuri Frosio, and Jan Kautz. Importance estimation for neural network pruning. In CVPR, 2019. 1, 2, 8, 9
+
+Michael C Mozer and Paul Smolensky. Skeletonization: A technique for trimming the fat from a network via relevance assessment. In NeurIPS, 1989. 1
+
+Adam Paszke, Sam Gross, Francisco Massa, Adam Lerer, James Bradbury, Gregory Chanan, Trevor Killeen, Zeming Lin, Natalia Gimelshein, Luca Antiga, et al. Pytorch: An imperative style, highperformance deep learning library. In NeurIPS, 2019. 6
+
+Hanyu Peng, Jiaxiang Wu, Shifeng Chen, and Junzhou Huang. Collaborative channel pruning for deep networks. In ICML, 2019. 8
+
+Mohammad Rastegari, Vicente Ordonez, Joseph Redmon, and Ali Farhadi. Xnor-net: Imagenet classification using binary convolutional neural networks. In ECCV, 2016. 2
+
+R. Reed. Pruning algorithms – a survey. IEEE Transactions on Neural Networks, 4(5):740–747, 1993. 1, 2
+
+Mark Sandler, Andrew Howard, Menglong Zhu, Andrey Zhmoginov, and Liang-Chieh Chen. Mobilenetv2: Inverted residuals and linear bottlenecks. In CVPR, 2018. 3
+
+Jurgen Schmidhuber. Deep learning in neural networks: An overview. ¨ Neural networks, 61:85–117, 2015. 1
+
+Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. In ICLR, 2015. 6
+
+Sidak Pal Singh and Dan Alistarh. Woodfisher: Efficient second-order approximations for model compression. In NeurIPS, 2020. 1, 2, 4, 8, 9, 13
+
+Gilbert Strang. Calculus. Wellesley-Cambridge Press, 1991. 4
+
+Mingxing Tan and Quoc Le. Efficientnet: Rethinking model scaling for convolutional neural networks. In ICML, 2019. 3
+
+Chaoqi Wang, Roger Grosse, Sanja Fidler, and Guodong Zhang. Eigendamage: Structured pruning in the kronecker-factored eigenbasis. In ICML, 2019a. 1, 2, 4, 7, 8
+
+Huan Wang, Qiming Zhang, Yuehai Wang, and Haoji Hu. Structured probabilistic pruning for convolutional neural network acceleration. In BMVC, 2018. 9
+
+Huan Wang, Xinyi Hu, Qiming Zhang, Yuehai Wang, Lu Yu, and Haoji Hu. Structured pruning for efficient convolutional neural networks via incremental regularization. IEEE Journal of Selected Topics in Signal Processing, 14(4):775–788, 2019b. 5, 8
+
+Huan Wang, Qiming Zhang, Yuehai Wang, Lu Yu, and Haoji Hu. Structured pruning for efficient convnets via incremental regularization. In IJCNN, 2019c. 2, 3, 5
+
+Wei Wen, Chunpeng Wu, Yandan Wang, Yiran Chen, and Hai Li. Learning structured sparsity in deep neural networks. In NeurIPS, 2016. 1, 2, 9, 13
+
+Jianbo Ye, Xin Lu, Zhe Lin, and James Z Wang. Rethinking the smaller-norm-less-informative assumption in channel pruning of convolution layers. In ICLR, 2018. 2
+
+Ming Yuan and Yi Lin. Model selection and estimation in regression with grouped variables. Journal of the Royal Statistical Society, 68(1):49–67, 2006. 2
+
+Xiangyu Zhang, Jianhua Zou, Xiang Ming, Kaiming He, and Jian Sun. Efficient and accurate approximations of nonlinear convolutional networks. In CVPR, 2015. 3
+
+Xiangyu Zhang, Xinyu Zhou, Mengxiao Lin, and Jian Sun. Shufflenet: An extremely efficient convolutional neural network for mobile devices. In CVPR, 2018. 3
+
+Zhuangwei Zhuang, Mingkui Tan, Bohan Zhuang, Jing Liu, Yong Guo, Qingyao Wu, Junzhou Huang, and Jinhui Zhu. Discrimination-aware channel pruning for deep neural networks. In NeurIPS, 2018. 8
+
+Barret Zoph and Quoc Le. Neural architecture search with reinforcement learning. In ICLR, 2017. 3
+
+# A APPENDIX
+
+# A.1 EXPERIMENTAL SETTING DETAILS
+
+Training setting summary. About the networks evaluated, we intentionally avoid AlexNet and VGG on the ImageNet benchmark because the single-branch architecture is no longer representative of the modern deep network architectures with residuals (but still keep VGG19 on the CIFAR analysis to make sure the findings are not limited to one specific architecture). Apart from some key settings stated in the paper, a more detailed training setting summary is shown as Tab. 5.
+
+Table 5: Training setting summary. For the SGD solver, in the parentheses are the momentum and weight decay. For ImageNet, batch size 64 is used for pruning instead of the standard 256, which is because we want to save the training time.   
+
+<table><tr><td rowspan=1 colspan=1>Dataset</td><td rowspan=1 colspan=1>CIFAR</td><td rowspan=1 colspan=1>ImageNet</td></tr><tr><td rowspan=1 colspan=1>Solver</td><td rowspan=1 colspan=1>SGD (0.9, 5e-4)</td><td rowspan=1 colspan=1>SGD (0.9, 1e-4)</td></tr><tr><td rowspan=1 colspan=1>LR policy (prune)</td><td rowspan=1 colspan=2>Fixed (1e-3)</td></tr><tr><td rowspan=1 colspan=1>LR policy (finetune)</td><td rowspan=1 colspan=1>Multi-step (0:1e-2,60:1e-3,90:1e-4)</td><td rowspan=1 colspan=1>Multi-step (0:1e-2, 60:1e-3,90:1e-4)Multi-step (0:1e-2, 30:1e-3, 60:1e-4,75:1e-5)</td></tr><tr><td rowspan=1 colspan=1>Total epoch (finetune)</td><td rowspan=1 colspan=1>120</td><td rowspan=1 colspan=1>90</td></tr><tr><td rowspan=1 colspan=1>Batch size (prune)</td><td rowspan=1 colspan=1>256</td><td rowspan=1 colspan=1>64</td></tr><tr><td rowspan=1 colspan=1>Batch size (finetune)</td><td rowspan=1 colspan=2>256</td></tr></table>
+
+Pruning ratios. Although several recent methods Ding et al. (2019b); Singh & Alistarh (2020) can automatically decide pruning ratios, in this paper we opt to consider pruning independent with the pruning ratio choosing. The main consideration is that pruning ratio is broadly believed to reflect the redundancy of different layers LeCun et al. (1990); Wen et al. (2016); He et al. (2017), which is an inherent characteristic of the model, thus should not be coupled with the subsequent pruning algorithms.
+
+Before we list the specific pruning ratios, we explain how we set them. (1) For a ResNet, if it has $N$ stages, we will use a list of $N$ floats to represent its pruning ratios for the $N$ stages. For example, ResNet56 has 4 stages in conv layers, then “[0, 0.5, 0.5, 0.5]” means “for the first stage (which is also the first conv layer), the pruning ratio is 0; the other three stages have pruning ratio of $0 . 5 '$ . Besides, since we do not prune the last conv in a residual block, which means for a two-layer residual block (for ResNet56), we only prune the first layer; for a three-layer bottleneck block (for ResNet34 and 50), we only prune the first and second layers. (2) For VGG19, we use the following pruning ratio setting. For example, “[0:0, 1-9:0.3, 10-15:0.5]” means “for the first layer (index starting from 0), the pruning ratio is 0; for layer 1 to 9, the pruning ratio is 0.3; for layer 10 to 15, the pruning ratio is $0 . 5 '$ .
+
+With these, the specific pruning ratio for each of our experiments in the paper are listed in Tab. 6. We do not have strong rules to set them, except one, which is setting the pruning ratios of higher stages smaller, because the FLOPs of higher layers are relatively smaller (due to the fact that the spatial feature map sizes are smaller) and we are targeting more acceleration than compression. Of course, this scheme only is quite crude, yet as our results (Tab. 3 and 4) show, even with these crude settings, the performances are still competitive.
+
+# B PROOF OF EQ. 5
+
+When a quadratic function $\mathcal { E }$ converges at $\mathbf { w } ^ { * }$ with Hessian matrix $\mathbf { H }$ , it can be formulated as
+
+$$
+\mathcal { E } = ( \mathbf { w } - \mathbf { w } ^ { * } ) ^ { T } \mathbf { H } ( \mathbf { w } - \mathbf { w } ^ { * } ) + C ,
+$$
+
+where $C$ is a constant. Now a new function is made by increasing the $L _ { 2 }$ penalty by small amount $\delta \lambda$ , namely,
+
+$$
+\begin{array} { r } { \hat { \mathcal { E } } = \mathcal { E } + \delta \lambda \mathbf { w } ^ { T } \mathbf { I } \mathbf { w } . } \end{array}
+$$
+
+Let the new converged values be $\hat { \mathbf { w } } ^ { * }$ , then similar to Eq. 10, $\hat { \mathcal { E } }$ can be formulated as
+
+$$
+\hat { \mathcal { E } } = ( \mathbf { w } - \hat { \mathbf { w } } ^ { * } ) ^ { T } \hat { \mathbf { H } } ( \mathbf { w } - \hat { \mathbf { w } } ^ { * } ) + \hat { C } , \mathrm { w h e r e } \hat { \mathbf { H } } = \mathbf { H } + \delta \lambda \mathbf { I } .
+$$
+
+Table 6: Pruning ratio summary.   
+
+<table><tr><td rowspan=1 colspan=1>Dataset</td><td rowspan=1 colspan=1>Network</td><td rowspan=1 colspan=1>Speedup</td><td rowspan=1 colspan=1>Pruned top-1 accuracy (%)</td><td rowspan=1 colspan=1>Pruning ratio</td></tr><tr><td rowspan=1 colspan=1>CIFAR10CIFAR100</td><td rowspan=1 colspan=1>ResNet56VGG19</td><td rowspan=1 colspan=1>2.55×8.84×</td><td rowspan=1 colspan=1>93.3667.56</td><td rowspan=1 colspan=1>[0, 0.75, 0.75, 0.32, 0][1-15:0.7]</td></tr><tr><td rowspan=4 colspan=1>ImageNetImageNetImageNetImageNetImageNet</td><td rowspan=2 colspan=1>ResNet34ResNet50ResNet50</td><td rowspan=1 colspan=1>1.32×</td><td rowspan=2 colspan=1>73.4476.2475.16</td><td rowspan=4 colspan=1>[0, 0.50, 0.60, 0.40, 0, 0]*[0, 0.30, 0.30, 0.30, 0.14, 0][0, 0.60, 0.60, 0.60, 0.21, 0][0, 0.74, 0.74, 0.60, 0.21, 0][0, 0.68, 0.68, 0.68, 0.50, 0]</td></tr><tr><td rowspan=1 colspan=1>1.49×2.31×</td></tr><tr><td rowspan=2 colspan=1>ResNet50ResNet50</td><td rowspan=1 colspan=1>2.56×</td><td rowspan=2 colspan=1>74.7573.50</td></tr><tr><td rowspan=1 colspan=1>3.06×</td></tr></table>
+
+\* In addition to the pruning ratios, several layers are skipped, following the setting of $L _ { 1 }$ (pruned-B) Li et al. (2017). Specifically, we refer to the implementation of Liu et al. (2019) at https://github.com/Ericmingjie/rethinking-network-pruning/tree/master/imagenet/l1-norm-pruning.
+
+Meanwhile, combine Eq. 10 and Eq. 11, we can obtain
+
+$$
+\begin{array} { r } { \hat { \mathcal { E } } = ( \mathbf { w } - \mathbf { w } ^ { * } ) ^ { T } \mathbf { H } ( \mathbf { w } - \mathbf { w } ^ { * } ) + \delta \lambda \mathbf { w } ^ { T } \mathbf { I } \mathbf { w } + C . } \end{array}
+$$
+
+Compare Eq. 13 with Eq. 12, we have
+
+$$
+( \mathbf { H } + \delta \lambda \mathbf { I } ) { \hat { \mathbf { w } } } ^ { * } = \mathbf { H } \mathbf { w } ^ { * } \Rightarrow { \hat { \mathbf { w } } } ^ { * } = ( \mathbf { H } + \delta \lambda \mathbf { I } ) ^ { - 1 } \mathbf { H } \mathbf { w } ^ { * } .
+$$
+
+C PROOF OF EQ. 7
+
+$$
+\hat { \mathbf { H } } = \left\{ \begin{array} { c c } { h _ { 1 1 } + \delta \lambda } & { h _ { 1 2 } } \\ { h _ { 1 2 } } & { h _ { 2 2 } + \delta \lambda } \end{array} \right\} \Rightarrow \hat { \mathbf { H } } ^ { - 1 } = \frac { 1 } { \vert \hat { \mathbf { H } } \vert } \left\{ \begin{array} { c c } { h _ { 2 2 } + \delta \lambda } & { - h _ { 1 2 } } \\ { - h _ { 1 2 } } & { h _ { 1 1 } + \delta \lambda } \end{array} \right\}
+$$
+
+Therefore, $\hat { \mathbf { w } } ^ { * } = \hat { \mathbf { H } } ^ { - 1 } \mathbf { H } \mathbf { w } ^ { * } \Rightarrow$
+
+$$
+\begin{array} { r l r } & { } & { \left\{ \hat { w } _ { 1 } ^ { * } \right\} = \hat { \bf H } ^ { - 1 } { \bf H } \left\{ w _ { 1 } ^ { * } \right\} = \frac { 1 } { \left| \hat { \bf H } \right| } \left\{ \begin{array} { c c } { h _ { 2 2 } + \delta \lambda } & { - h _ { 1 2 } } \\ { - h _ { 1 1 } } & { h _ { 1 1 } + \delta \lambda } \end{array} \right\} \left\{ \begin{array} { c c } { h _ { 1 1 } } & { h _ { 1 2 } } \\ { h _ { 1 2 } } & { h _ { 2 2 } } \end{array} \right\} \left\{ \begin{array} { c } { w _ { 1 } ^ { * } } \\ { w _ { 2 } ^ { * } } \end{array} \right\} } \\ & { } & { = \frac { 1 } { \left| \hat { \bf H } \right| } \left\{ \begin{array} { c c } { \left( h _ { 1 1 } h _ { 2 2 } + h _ { 1 1 } \delta \lambda - h _ { 1 2 } ^ { 2 } \right) w _ { 1 } ^ { * } + \delta \lambda h _ { 1 2 } w _ { 2 } ^ { * } } \\ { \left( h _ { 1 1 } h _ { 2 2 } + h _ { 2 2 } \delta \lambda - h _ { 1 2 } ^ { 2 } \right) w _ { 2 } ^ { * } + \delta \lambda h _ { 1 2 } w _ { 1 } ^ { * } } \end{array} \right\} . } \end{array}
+$$
+
+# D GREG- $1 + \mathrm { O B D }$
+
+In Sec. 4.1, we show when pruning the same weights, GReg-1 is significantly better than the oneshot counterpart, where the pruned weights are selected by the $L _ { 1 }$ -norm criterion. Here we conduct the same comparison just with a different pruning criterion introduced in OBD LeCun et al. (1990). OBD is also an one-shot pruning method, using a Hessian-based criterion which is believed to be more advanced than $L _ { 1 }$ -norm.
+
+Results are shown in Tab. 7. As seen, using this more advanced importance criterion, our pruning scheme based on growing regularization is still consistently better than the one-shot counterpart. Besides, it is also verified here that a better pruning schedule can bring more accuracy gain when the speedup is larger.
+
+# E FILTER L1-NORM CHANGE OF VGG19
+
+In Fig. 1 (Row 2), we plot the filter $L _ { 1 }$ -norm change over time for ResNet50 on ImageNet. Here we plot the case of VGG19 on CIFAR100 to show the weight separation phenomenon under growing regularization is a general one across different datasets and networks.
+
+# F HYPER-PARAMETERS AND SENSITIVITY ANALYSIS
+
+There are five introduced values in our methods: regularization ceiling $\tau$ , ceiling for picking $\tau ^ { \prime }$ interval $K _ { u } , K _ { s }$ , granularity $\delta \lambda$ . Their settings are summarized in Tab. 8. Among them, the ceilings
+
+Table 7: Comparison between pruning schedules: one-shot pruning vs. our proposed GReg-1 using the Hessian-based criterion introduced in OBD LeCun et al. (1990). Each setting is randomly run for 3 times, mean and std accuracies reported. We vary the global pruning ratio from 0.7 to 0.95 so as to cover the major speedup spectrum of interest. Same as Tab. 1, the pruned weights here are exactly the same for the two methods under each speedup ratio. The finetuning processes (number of epochs, LR schedules, etc.) are also the same to keep fair comparison.
+
+![](images/0f2d6935b0744fbb2ed80e72482e888c222e79ac5a2f589b70d6f4f3caae6562.jpg)  
+Figure 2: Normalized filter $L _ { 1 }$ -norm over iterations for VGG19 layer3.
+
+are set through validation: $\tau = 1$ is set to make sure the unimportant weights are pushed down enough (as stated in the main paper, normally after the regularization training, their magnitudes are too small to cause significant accuracy degradation if they are completely removed). $\tau ^ { \prime } = 0 . 0 1$ is set generally for the same goal as $\tau$ , but since it is applied to all the weight (not just the unimportant ones), we only expect it to be moderately large (thus smaller than $\tau$ ) so that the important and unimportant can be differentiated with a clear boundary. For the $\delta \lambda$ , we use a very small regularization granularity $\delta \lambda$ , which our theoretical analysis is based on. We set its value to 1e-4 for GReg-1 and 1e-5 for GReg-2 with reference to the original weight decay value $5 \times 1 0 ^ { - 4 }$ (for CIFAR models) and $1 0 ^ { - 4 }$ (for ImageNet models). Note that, these values come from our methods per se, not directly related to datasets and networks, thus are invariant to them. This is why we can employ the same setting of these three hyper-parameters in all our experiments, freeing practitioners from heavy tuning when dealing with different networks or datasets.
+
+Table 8: Hyper-parameters of our methods.   
+
+<table><tr><td rowspan=1 colspan=1>Notation</td><td rowspan=1 colspan=1>Default value (CIFAR)</td><td rowspan=1 colspan=1>Default value (ImageNet)</td></tr><tr><td rowspan=1 colspan=1>8入</td><td rowspan=1 colspan=2>GReg-1: 1e-4, GReg-2: 1e-5</td></tr><tr><td rowspan=1 colspan=1>T</td><td rowspan=1 colspan=2>1</td></tr><tr><td rowspan=1 colspan=1>T</td><td rowspan=1 colspan=2>0.01</td></tr><tr><td rowspan=1 colspan=1>Ku</td><td rowspan=1 colspan=1>10 iterations</td><td rowspan=1 colspan=1>5 iterations</td></tr><tr><td rowspan=1 colspan=1>Ks</td><td rowspan=1 colspan=1>5k iterations</td><td rowspan=1 colspan=1>40k iterations</td></tr></table>
+
+A little bit of change is for $K _ { u } , K _ { s }$ . Both are generally to let the network have enough time to converge to the new equilibrium. Generally, we prefer large update intervals, yet we also need to consider the time complexity: Too large of them will bring too many iterations, which may be unnecessary. Among them, $K _ { s }$ is less important since it is to stabilize the large regularization $\mathit { \Psi } _ { \tau } = 1 \mathit { \Psi } _ { . }$ ). We introduce it simply to make sure the training is fully converged. Therefore, the possibly more sensitive hyper-parameter is the $K _ { u }$ (set to 5 for ImageNet and 10 for CIFAR). Here we will show the performance is insensitive to the varying $K _ { u }$ . As shown in Tab. 9, the peak performance appears at around $K _ { u } = 1 5$ for ResNet56 and $K _ { u } = 1 0$ for VGG19. We simply adopt 10 for a uniform setting in our paper. We did not heavily tune these hyper-parameters, yet as seen, they work pretty well across different networks and datasets. Notably, even for the worst cases in Tab. 9 (in blue color), they are still significantly better than those of the “ $L _ { 1 } +$ one-shot” scheme, demonstrating the robustness of the proposed algorithm.
+
+Table 9: Sensitivity analysis of $K _ { u }$ on CIFAR10/100 datasets with the proposed GReg-1 algorithm. $K _ { u } = 1 0$ is the default setting. Pruning ratio $9 0 \%$ (ResNet56) and $7 0 \%$ (VGG19) are explored here. Experiments are randomly run for 3 times with mean accuracy and standard deviation reported. The best is highlighted with bold and the worst is highlighted with blue color.   
+
+<table><tr><td rowspan=1 colspan=1>Ku</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>5</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>15</td><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>L1+one-shot</td></tr><tr><td rowspan=1 colspan=1>Acc. (%,ResNet56)</td><td rowspan=1 colspan=1>89.40±0.04</td><td rowspan=1 colspan=1>89.38±0.13</td><td rowspan=1 colspan=1>89.49±0.23</td><td rowspan=1 colspan=1>89.69±0.05</td><td rowspan=1 colspan=1>89.62±0.13</td><td rowspan=1 colspan=1>87.34±0.21</td></tr><tr><td rowspan=1 colspan=1>Acc. (%,VGG19)</td><td rowspan=1 colspan=1>67.22±0.33</td><td rowspan=1 colspan=1>67.32±0.24</td><td rowspan=1 colspan=1>67.35±0.15</td><td rowspan=1 colspan=1>67.06±0.40</td><td rowspan=1 colspan=1>66.93±0.22</td><td rowspan=1 colspan=1>66.05±0.04</td></tr></table>
+
+# G MORE RESULTS OF PRUNING SCHEDULE COMPARISON
+
+In Tab. 1, we show using $L _ { 1 }$ -norm sorting, our proposed GReg-1 can consistently surpass the oneshot schedule even pruning the same weights. Here we ask a more general question: Can the benefits from a regularization-based schedule consistently appear, agnostic to the weight importance scoring criterion? This question is important because it will show if the gain from a better pruning schedule is only a bonus concurrent with the $L _ { 1 }$ criterion or a really universal phenomenon. Since there are literally so many weight importance criteria, we cannot ablate them one by one. Nevertheless, given a pre-trained model and a pruning ratio $r$ , no matter what criterion, its role is to select a filter subset. For example, if there are 100 filters in a layer and $r = 0 . 5$ , then they are at most $\binom { 1 0 0 } { 5 0 }$ importance criteria in theory for this layer. We can simply randomly pick a subset of filters (which corresponds to certain criterion, albeit unknown) and compare the one-shot way with regularization-based way on the subset. Based on this idea, we conduct five random runs on the ResNet56 and VGG19 to explore this. The pruning ratio is chosen as $9 0 \%$ for ResNet56 and $7 0 \%$ for VGG19 because under this ratio the compression (or acceleration) ratio is about 10 times, neither too large nor too small (where the network can heal itself regardless of pruning methods).
+
+The results are shown in Tab. 10. Here is a sanity check: Compared with Tab. 1, the mean accuracy of pruning randomly picked filters should be less than pruning those picked by $L _ { 1 }$ -norm, confirmed by $8 6 . 8 5 \%$ vs. $8 7 . 3 4 \%$ for ResNet56 and $6 5 . 0 4 \%$ vs. $6 6 . 0 5 \%$ for VGG19. As seen, in each run, the regularization-based way also significantly surpasses its one-shot counterpart. Although five random runs are still too few given the exploding potential combinations, yet as shown by the accuracy standard deviations, the results are stable and thus qualified to support our finding that the regularization-based pruning schedule is better to the one-shot counterpart.
+
+Table 10: Comparison between pruning schedules: one-shot vs. GReg-1. Pruning ratio is $90 \%$ for ResNet56 and $70 \%$ for VGG19. In each run, the weights to prune are picked randomly before the training starts.   
+
+<table><tr><td rowspan=1 colspan=1>ResNet56 + CIFAR10</td><td rowspan=1 colspan=1>Run #1</td><td rowspan=1 colspan=1>Run #2</td><td rowspan=1 colspan=1>Run #3</td><td rowspan=1 colspan=1>Run #4</td><td rowspan=1 colspan=1>Run #5</td><td rowspan=1 colspan=1>Mean±std</td></tr><tr><td rowspan=1 colspan=1>Acc. (%, one-shot)Acc. (%, GReg-1, ours)</td><td rowspan=1 colspan=1>87.5789.26</td><td rowspan=1 colspan=1>87.0088.98</td><td rowspan=1 colspan=1>86.2788.78</td><td rowspan=1 colspan=1>86.7589.42</td><td rowspan=1 colspan=1>86.6788.96</td><td rowspan=1 colspan=1>86.85±0.4389.08±0.23</td></tr><tr><td rowspan=1 colspan=1>VGG19 + CIFAR100</td><td rowspan=1 colspan=1>Run #1</td><td rowspan=1 colspan=1>Run #2</td><td rowspan=1 colspan=1>Run #3</td><td rowspan=1 colspan=1>Run #4</td><td rowspan=1 colspan=1>Run #5</td><td rowspan=1 colspan=1>Mean±std</td></tr><tr><td rowspan=1 colspan=1>Acc. (%,one-shot)Acc. (%, GReg-1, ours)</td><td rowspan=1 colspan=1>64.5666.63</td><td rowspan=1 colspan=1>65.0666.57</td><td rowspan=1 colspan=1>65.0766.80</td><td rowspan=1 colspan=1>65.0566.80</td><td rowspan=1 colspan=1>65.4867.16</td><td rowspan=1 colspan=1>65.04±0.2966.79±0.21</td></tr></table>

parse/train/rJxgknCcK7/rJxgknCcK7.md

@@ -0,0 +1,317 @@
+# FFJORD: FREE-FORM CONTINUOUS DYNAMICS FOR SCALABLE REVERSIBLE GENERATIVE MODELS
+
+Will Grathwohl∗†‡ , Ricky T. Q. Chen∗†, Jesse Bettencourt†, Ilya Sutskever‡ , David Duvenaud†
+
+# ABSTRACT
+
+Reversible generative models map points from a simple distribution to a complex distribution through an easily invertible neural network. Likelihood-based training of these models requires restricting their architectures to allow cheap computation of Jacobian determinants. Alternatively, the Jacobian trace can be used if the transformation is specified by an ordinary differential equation. In this paper, we use Hutchinson’s trace estimator to give a scalable unbiased estimate of the logdensity. The result is a continuous-time invertible generative model with unbiased density estimation and one-pass sampling, while allowing unrestricted neural network architectures. We demonstrate our approach on high-dimensional density estimation, image generation, and variational inference, improving the state-ofthe-art among exact likelihood methods with efficient sampling.
+
+# 1 INTRODUCTION
+
+Reversible generative models use cheaply invertible neural networks to transform samples from a fixed base distribution. Examples include NICE (Dinh et al., 2014), Real NVP (Dinh et al., 2017), and Glow (Kingma & Dhariwal, 2018). These models are easy to sample from, and can be trained by maximum likelihood using the change of variables formula. However, this requires placing awkward restrictions on their architectures, such as partitioning dimensions or using rank one weight matrices, in order to avoid an $\mathcal { O } ( D ^ { 3 } )$ cost determinant computation.
+
+Recently, Chen et al. (2018) introduced continuous normalizing flows (CNF), defining the mapping from latent variables to data using ordinary differential equations (ODE). In their model, the likelihood can be computed using trace operations costing only $\mathcal { O } ( D ^ { 2 } )$ . This allows a more flexible, but still restricted, family of network architectures to be used.
+
+Extending this work, we introduce an unbiased stochastic estimator of the likelihood that has $\mathcal { O } ( D )$ time cost, allowing completely unrestricted architectures. Furthermore, we have implemented GPU-based adaptive ODE solvers to train and evaluate these models on modern hardware. We call our approach Free-form Jacobian of
+
+![](images/a3ee11ba6739d7a93b9f3874d4b4484510a3bd876d2128620a72649eb1edf2e9.jpg)  
+Figure 1: FFJORD transforms a simple base distribution at $t _ { 0 }$ into the target distribution at $t _ { 1 }$ by integrating over learned continuous dynamics.
+
+Reversible Dynamics (FFJORD). Figure 1 shows FFJORD smoothly transforming a Gaussian distribution into a multi-modal distribution.
+
+# 2 BACKGROUND: GENERATIVE MODELS AND CHANGE OF VARIABLES
+
+In contrast to directly parameterizing a normalized distribution (e.g. Oord et al. (2016); Germain et al. (2015)), the change of variables formula allows one to specify a complex normalized distribution $p _ { \mathbf { x } } ( \mathbf { x } )$ implicitly by warping a normalized base distribution $p _ { \mathbf { z } } ( \mathbf { z } )$ through an invertible function $f : \mathbb { R } ^ { D } \overset { \cdot } {  } \mathbb { R } ^ { D }$ . Given a random variable $\mathbf { z } \sim p _ { \mathbf { z } } ( \mathbf { z } )$ the log density of ${ \bf x } = f ( { \bf z } )$ follows
+
+$$
+\log p _ { \mathbf { x } } ( \mathbf { x } ) = \log p _ { \mathbf { z } } ( \mathbf { z } ) - \log \operatorname* { d e t } \left| \frac { \partial f ( \mathbf { z } ) } { \partial \mathbf { z } } \right|
+$$
+
+where $\partial f ( \mathbf { z } ) / \partial \mathbf { z }$ is the Jacobian of $f$ . In general, computing the log determinant has a time cost of $\mathcal { O } ( D ^ { 3 } )$ . Much work has gone into developing restricted neural network architectures which make computing the Jacobian’s determinant more tractable. These approaches broadly fall into three categories:
+
+Normalizing flows. By restricting the functional form of $f$ , various determinant identities can be exploited (Rezende & Mohamed, 2015; Berg et al., 2018). These models cannot be trained as generative models from data because they do not have a tractable inverse $f ^ { - 1 }$ . However, they are useful for specifying approximate posteriors for variational inference (Kingma & Welling, 2014).
+
+Autoregressive transformations. By using an autoregressive model and specifying an ordering of the dimensions, the Jacobian of $f$ is enforced to be lower triangular (Kingma et al., 2016; Oliva et al., 2018). These models excel at density estimation for tabular datasets (Papamakarios et al., 2017), but require $D$ sequential evaluations of $f$ to invert, which is prohibitive when $D$ is large.
+
+Partitioned transformations. Partitioning the dimensions and using affine transformations makes the determinant of the Jacobian cheap to compute, and the inverse $\breve { f } ^ { - 1 }$ computable with the same cost as $f$ (Dinh et al., 2014; 2017). This method allows the use of convolutional architectures, excelling at density estimation for image data (Dinh et al., 2017; Kingma & Dhariwal, 2018).
+
+Throughout this work, we refer to reversible generative models as those which use the change of variables to transform a base distribution to the model distribution while maintaining both efficient density estimation and efficient sampling capabilities using a single pass of the model.
+
+# 2.1 OTHER GENERATIVE MODELS
+
+There exist several approaches to generative modeling approaches which do not use the change of variables equation for training. Generative adversarial networks (GANs) (Goodfellow et al., 2014) use large, unrestricted neural networks to transform samples from a fixed base distribution. Lacking a closed-form likelihood, an auxiliary discriminator model must be trained to estimate divergences or density ratios in order to provide a training signal. Autoregressive models (Germain et al., 2015; Oord et al., 2016) directly specify the joint distribution $p ( \mathbf { x } )$ as a sequence of explicit conditional distributions using the product rule. These models require at least $\mathcal { O } ( D )$ evaluations to sample from. Variational autoencoders (VAEs) (Kingma & Welling, 2014) use an unrestricted architecture to explicitly specify the conditional likelihood $p ( x | z )$ , but can only efficiently provide a stochastic lower bound on the marginal likelihood $p ( x )$ .
+
+# 2.2 CONTINUOUS NORMALIZING FLOWS
+
+Chen et al. (2018) define a generative model for data $\mathbf { x } \in \mathbb { R } ^ { D }$ similar to those based on (1), but replace the warping function with an integral of continuous-time dynamics. The generative process first samples from a base distribution ${ \bf z } _ { 0 } \sim p _ { z _ { 0 } } ( { \bf z } _ { 0 } )$ . Then, given an ODE whose dynamics are defined by the parametric function $\partial \mathbf { z } ( t ) / \partial t = f ( \mathbf { z } ( t ) , t ; \theta )$ , we solve the initial value problem with $\mathbf { z } ( t _ { 0 } ) = \dot { \mathbf { z } } _ { 0 }$ to obtain a data sample ${ \mathbf x } = { \mathbf z } ( t _ { 1 } )$ . These models are called Continous Normalizing Flows (CNF). The change in log-density under this model follows a second differential equation, called the instantaneous change of variables formula (Chen et al., 2018):
+
+$$
+\frac { \partial \log p ( { \bf z } ( t ) ) } { \partial t } = - \mathrm { T r } \left( \frac { \partial f } { \partial { \bf z } ( t ) } \right) .
+$$
+
+We can compute total change in log-density by integrating across time:
+
+$$
+\log p ( \mathbf { z } ( t _ { 1 } ) ) = \log p ( \mathbf { z } ( t _ { 0 } ) ) - \int _ { t _ { 0 } } ^ { t _ { 1 } } \operatorname { T r } \left( { \frac { \partial f } { \partial \mathbf { z } ( t ) } } \right) d t .
+$$
+
+<table><tr><td colspan="2">Method</td><td rowspan="2">Train on data</td><td rowspan="2">One-pass Sampling</td><td rowspan="2">Exact/Unbiased Log- likelihood</td><td rowspan="2">Free- form Jacobian</td></tr><tr><td colspan="2"></td></tr><tr><td rowspan="4"></td><td>Variational Autoencoders</td><td></td><td></td><td>X</td><td>√</td></tr><tr><td>Generative Adversarial Nets</td><td></td><td>√</td><td>×</td><td>√</td></tr><tr><td>Likelihood-based Autoregressive</td><td></td><td>×</td><td>√</td><td>×</td></tr><tr><td>Normalizing Flows</td><td>X</td><td>√</td><td></td><td>X</td></tr><tr><td rowspan="3">o auegg 2aaiber</td><td>Reverse-NF,MAF, TAN</td><td></td><td>X</td><td></td><td>X</td></tr><tr><td>NICE,Real NVP, Glow, Planar CNF</td><td></td><td>√</td><td></td><td>X</td></tr><tr><td>FFJORD</td><td></td><td>「</td><td></td><td></td></tr></table>
+
+Given a datapoint x, we can compute both the point $\mathbf { z } _ { 0 }$ which generates $\mathbf { x }$ , as well as $\log p ( \mathbf { x } )$ under the model by solving the combined initial value problem:
+
+which integrates the combined dynamics of $z ( t )$ and the log-density of the sample backwards in time from $t _ { 1 }$ to $t _ { 0 }$ . We can then compute $\log p ( \mathbf { x } )$ using the solution of (4) and adding $\log p _ { z _ { 0 } } ( { \bf z } _ { 0 } )$ . The existence and uniqueness of (4) require that $f$ and its first derivatives be Lipschitz continuous (Khalil, 2002), which can be satisfied in practice using neural networks with smooth Lipschitz activations, such as softplus or tanh.
+
+# 2.2.1 BACKPROPAGATING THROUGH ODE SOLUTIONS WITH THE ADJOINT METHOD
+
+CNFs are trained to maximize (3). This objective involves the solution to an initial value problem with dynamics parameterized by $\theta$ . For any scalar loss function which operates on the solution to an initial value problem
+
+$$
+L ( \mathbf { z } ( t _ { 1 } ) ) = L \left( \int _ { t _ { 0 } } ^ { t _ { 1 } } f ( \mathbf { z } ( t ) , t ; \theta ) d t \right)
+$$
+
+then Pontryagin (1962) shows that its derivative takes the form of another initial value problem
+
+$$
+\frac { d L } { d \theta } = - \int _ { t _ { 1 } } ^ { t _ { 0 } } \left( \frac { \partial L } { \partial \mathbf { z } ( t ) } \right) ^ { T } \frac { \partial f ( \mathbf { z } ( t ) , t ; \theta ) } { \partial \theta } d t .
+$$
+
+The quantity $- { \partial L } / { \partial { \bf z } ( t ) }$ is known as the adjoint state of the ODE. Chen et al. (2018) use a black-box ODE solver to compute ${ \bf z } ( t _ { 1 } )$ , and then a separate call to a solver to compute (6) with the initial value ${ \partial L } / { \partial { \bf z } ( t _ { 1 } ) }$ . This approach is a continuous-time analog to the backpropgation algorithm (Rumelhart et al., 1986; Andersson, 2013) and can be combined with gradient-based optimization to fit the parameters $\theta$ by maximum likelihood.
+
+# 3 SCALABLE DENSITY EVALUATION WITH UNRESTRICTED ARCHITECTURES
+
+Switching from discrete-time dynamics to continuous-time dynamics reduces the primary computational bottleneck of normalizing flows from $\mathcal { O } ( D ^ { 3 } )$ to $\mathcal { O } ( D ^ { 2 } )$ , at the cost of introducing a numerical ODE solver. This allows the use of more expressive architectures. For example, each layer of the original normalizing flows model of Rezende & Mohamed (2015) is a one-layer neural network with only a single hidden unit. In contrast, the instantaneous transformation used in planar continuous normalizing flows (Chen et al., 2018) is a one-layer neural network with many hidden units. In this section, we construct an unbiased estimate of the log-density with $\mathcal { O } ( D )$ cost, allowing completely unrestricted neural network architectures to be used.
+
+# 3.1 UNBIASED LINEAR-TIME LOG-DENSITY ESTIMATION
+
+In general, computing $\operatorname { T r } \left( { \partial f } / { \partial \mathbf { z } ( t ) } \right)$ exactly costs $\mathcal { O } ( D ^ { 2 } )$ , or approximately the same cost as $D$ evaluations of $f$ , since each entry of the diagonal of the Jacobian requires computing a separate derivative of $f$ (Griewank & Walther, 2008). However, there are two tricks that can help. First, vector-Jacobian products ${ \pmb v } ^ { T } \frac { \partial f } { \partial { \bf z } }$ can be computed for approximately the same cost as evaluating $f$ using reverse-mode automatic differentiation. Second, we can get an unbiased estimate of the trace of a matrix by taking a double product of that matrix with a noise vector:
+
+$$
+\operatorname { T r } ( A ) = \mathbb { E } _ { p ( \epsilon ) } [ \epsilon ^ { T } A \epsilon ] .
+$$
+
+The above equation holds for any $D$ -by- $D$ matrix $A$ and distribution $p ( \epsilon )$ over $D$ -dimensional vectors such that $\mathbb { E } [ \boldsymbol { \epsilon } ] = 0$ and $\mathrm { C o v } ( \epsilon ) = I$ . The Monte Carlo estimator derived from (7) is known as Hutchinson’s trace estimator (Hutchinson, 1989; Adams et al., 2018).
+
+To keep the dynamics deterministic within each call to the ODE solver, we can use a fixed noise vector $\epsilon$ for the duration of each solve without introducing bias:
+
+$$
+\begin{array} { r l } & { \log p ( \mathbf { z } ( t _ { 1 } ) ) = \log p ( \mathbf { z } ( t _ { 0 } ) ) - \int _ { t _ { 0 } } ^ { t _ { 1 } } \operatorname { T r } \left( \frac { \partial f } { \partial \mathbf { z } ( t ) } \right) d t } \\ & { \qquad = \log p ( \mathbf { z } ( t _ { 0 } ) ) - \int _ { t _ { 0 } } ^ { t _ { 1 } } \mathbb { E } _ { p ( \epsilon ) } \left[ \epsilon ^ { T } \frac { \partial f } { \partial \mathbf { z } ( t ) } \epsilon \right] d t } \\ & { \qquad = \log p ( \mathbf { z } ( t _ { 0 } ) ) - \mathbb { E } _ { p ( \epsilon ) } \left[ \int _ { t _ { 0 } } ^ { t _ { 1 } } \epsilon ^ { T } \frac { \partial f } { \partial \mathbf { z } ( t ) } \epsilon d t \right] } \end{array}
+$$
+
+Typical choices of $p ( \epsilon )$ are a standard Gaussian or Rademacher distribution (Hutchinson, 1989).
+
+# 3.1.1 REDUCING VARIANCE WITH BOTTLENECK CAPACITY
+
+Often, there exist bottlenecks in the architecture of the dynamics network, i.e. hidden layers whose width $H$ is smaller than the dimensions of the input $D$ . In such cases, we can reduce the variance of Hutchinson’s estimator by using the cyclic property of trace. Since the variance of the estimator for $\operatorname { T r } ( A )$ grows asymptotic to $| | \bar { A | | } _ { F } ^ { 2 }$ (Hutchinson, 1989), we suspect that having fewer dimensions should help reduce variance. If we view the dynamics as a composition of two functions $f = g \circ h ( \mathbf { z } )$ then we observe
+
+$$
+\operatorname { T r } \underbrace { \left( { \frac { \partial f } { \partial \mathbf { z } } } \right) } _ { D \times D } = \operatorname { T r } \underbrace { \left( { \frac { \partial g } { \partial h } } { \frac { \partial h } { \partial \mathbf { z } } } \right) } _ { D \times D } = \operatorname { T r } \underbrace { \left( { \frac { \partial h } { \partial \mathbf { z } } } { \frac { \partial g } { \partial h } } \right) } _ { H \times H } = \mathbb { E } _ { p ( \epsilon ) } \left[ \epsilon ^ { T } { \frac { \partial h } { \partial \mathbf { z } } } { \frac { \partial g } { \partial h } } \epsilon \right] .
+$$
+
+When $f$ has multiple hidden layers, we choose $H$ to be the smallest dimension. This bottleneck trick can reduce the norm of the matrix which may also help reduce the variance of the trace estimator. As introducing a bottleneck limits our model capacity, we do not use this trick in our experiments. However this trick can reduce variance when a bottleneck is used, as shown in our ablation studies.
+
+# 3.2 FFJORD: A CONTINUOUS-TIME REVERSIBLE GENERATIVE MODEL
+
+Our complete method uses the dynamics defined in (2) and the efficient log-likelihood estimator of (8) to produce the first scalable and reversible generative model with an unconstrained Jacobian. We call this method Free-Form Jacobian of Reversible Dyanamics (FFJORD). Pseudo-code of our method is given in Algorithm 1, and Table 1 summarizes the capabilities of our model compared to other recent generative modeling approaches.
+
+Assuming the cost of evaluating $f$ is on the order of $\mathcal { O } ( D H )$ where $D$ is the dimensionality of the data and $H$ is the size of the largest hidden layer in $f$ , then the cost of computing the likelihood in models with repeated use of invertible transformations (1) is $\mathcal { O } ( ( D H + \bar { D ^ { 3 } } ) L )$ where $L$ is the number of transformations used. For CNF, this reduces to ${ \mathcal O } ( ( D H + D ^ { 2 } ) \hat { L } )$ for CNFs, where $\hat { L }$ is the number of evaluations of $f$ used by the ODE solver. With FFJORD, this reduces further to $\mathcal { O } ( ( D H + D ) \hat { L } )$ .
+
+<table><tr><td colspan="2">Algorithm1 Unbiased stochastic log-density estimation using the FFJORD model Require: dynamics fe,start time to,stop time t1,data samples x,data dimension D.</td></tr><tr><td>∈ ← sample_unit_variance(x.shape) function faug([zt, log pt],t):</td><td>&gt; Sample E outside of the integral &gt;Augment f with log-density dynamics.</td></tr><tr><td>ft←fo(z(t）,t) Taf</td><td>Evaluate neural network</td></tr><tr><td>g←εT zlz(t)</td><td> Compute vector-Jacobian product with automatic differentiation</td></tr><tr><td>Tr= ge return [ft,-Tr]</td><td> Unbiased estimateof Tr() with eTOfe</td></tr><tr><td>end function [zo,△logp] ←odeint(faug,[x,0],to,t1)</td><td>&gt; Concatenate dynamics of state and log-density Solve theODE St fug([z(t),lgp(z(t)),t)t</td></tr></table>
+
+# 4 EXPERIMENTS
+
+We demonstrate FFJORD on a variety of density estimation tasks, and for approximate inference in variational autoencoders (Kingma & Welling, 2014). Experiments were conducted using a suite of GPU-based ODE-solvers and an implementation of the adjoint method for backpropagation1. In all experiments the RungeKutta 4(5) algorithm with the tableau from Shampine (1986) was used to solve the ODEs. We ensure tolerance is set low enough so numerical error is negligible; see Appendix C.
+
+We used Hutchinson’s trace estimator (7) during training and the exact trace when reporting test results. This was done in all experiments except for our density estimation models trained on MNIST and CIFAR10 where computing the exact Jacobian trace was too expensive.
+
+![](images/ab8bf16b71e4f4d69d040ce6a540697db00a6b4a08e459f7fbc52bea5bcf8b06.jpg)  
+Figure 2: Comparison of trained Glow, planar CNF, and FFJORD models on 2-dimensional distributions, including multi-modal and discontinuous densities.
+
+The dynamics of FFJORD are defined by a neural network $f$ which takes as input the current state $\mathbf { z } ( t ) \in \mathbb { R } ^ { D }$ and the current time $t \in \mathbb { R }$ . We experimented with several ways to incorporate $t$ as an input to $f$ , such as hyper-networks, but found that simply concatenating $t$ on to ${ \bf z } ( t )$ at the input to every layer worked well and was used in all of our experiments.
+
+# 4.1 DENSITY ESTIMATION ON TOY 2D DATA
+
+We first train on 2 dimensional data to visualize the model and the learned dynamics.2 In Figure 2, we show that by warping a simple isotropic Gaussian, FFJORD can fit both multi-modal and even discontinuous distributions. The number of evaluations of the ODE solver is roughly 70-100 on all datasets, so we compare against a Glow model with 100 discrete layers.
+
+The learned distributions of both FFJORD and Glow can be seen in Figure 2. Interestingly, we find that Glow learns to stretch the unimodal base distribution into multiple modes but has trouble modeling the areas of low probability between disconnected regions. In contrast, FFJORD is capable of modeling disconnected modes and can also learn convincing approximations of discontinuous density functions (middle row in Figure 2). Since the main benefit of FFJORD is the ability to train with deeper dynamics networks, we also compare against planar CNF (Chen et al., 2018) which can
+
+![](images/fac29854af968af5e276b62f3dccd72d8cf66f74c5f18de98ca150c65f578941.jpg)  
+Figure 3: Samples and data from our image models. MNIST on left, CIFAR10 on right.
+
+<table><tr><td></td><td>POWER</td><td>GAS</td><td>HEPMASS</td><td>MINIBOONE</td><td>BSDS300</td><td>MNIST</td><td>CIFAR10</td></tr><tr><td>Real NVP</td><td>-0.17</td><td>-8.33</td><td>18.71</td><td>13.55</td><td>-153.28</td><td>1.06*</td><td>3.49*</td></tr><tr><td>Glow</td><td>-0.17</td><td>-8.15</td><td>18.92</td><td>11.35</td><td>-155.07</td><td>1.05*</td><td>3.35*</td></tr><tr><td>FFJORD</td><td>-0.46</td><td>-8.59</td><td>14.92</td><td>10.43</td><td>-157.40</td><td>0.99* (1.05†)</td><td>3.40*</td></tr><tr><td>MADE</td><td>3.08</td><td>-3.56</td><td>20.98</td><td>15.59</td><td>-148.85</td><td>2.04</td><td>5.67</td></tr><tr><td>MAF</td><td>-0.24</td><td>-10.08</td><td>17.70</td><td>11.75</td><td>-155.69</td><td>1.89</td><td>4.31</td></tr><tr><td>TAN</td><td>-0.48</td><td>-11.19</td><td>15.12</td><td>11.01</td><td>-157.03</td><td>-</td><td>-</td></tr><tr><td>MAF-DDSF</td><td>-0.62</td><td>-11.96</td><td>15.09</td><td>8.86</td><td>-157.73</td><td>-</td><td>-</td></tr></table>
+
+Table 2: Negative log-likehood on test data for density estimation models; lower is better. In nats for tabular data and bits/dim for MNIST and CIFAR10. \*Results use multi-scale convolutional architectures. †Results use a single flow with a convolutional encoder-decoder architecture.
+
+be viewed as a single hidden layer network. Without the benefit of a flexible network, planar CNF is unable to model complex distributions.
+
+# 4.2 DENSITY ESTIMATION ON REAL DATA
+
+We perform density estimation on five tabular datasets preprocessed as in Papamakarios et al. (2017) and two image datasets; MNIST and CIFAR10. When reproducing Glow, we use the same configurations for Real NVP as Papamakarios et al. (2017) and add invertible fully connected layer between all coupling layers. On the tabular datasets, FFJORD performs the best out of reversible models by a wide margin but is outperformed by recent autoregressive models. Of those, FFJORD outperforms MAF (Papamakarios et al., 2017) on all but one dataset and manages to outperform TAN Oliva et al. (2018) on the MINIBOONE dataset. These models require $\mathcal { O } ( D )$ sequential computations to sample from while the best performing method, MAF-DDSF (Huang et al., 2018), cannot be sampled from without resorting to correlated or expensive sampling algorithms such as MCMC.
+
+On MNIST we find that FFJORD can model the data as effectively as Glow and Real NVP using only a single flow defined by a single neural network. This is in contrast to Glow and Real NVP which must compose many flows to achieve similar performance. When we use multiple flows in a multiscale architecture (like those used by Glow and Real NVP) we obtain better performance on MNIST and comparable performance to Glow on CIFAR10. Notably, FFJORD is able to achieve this performance while using less than $2 \%$ as many parameters as Glow. We also note that Glow uses a learned base distribution whereas FFJORD and Real NVP use a fixed Gaussian. A summary of our results on density estimation can be found in Table 2 and samples can be seen in Figure 3. Full details on architectures used, our experimental procedure, and additional samples can be found in Appendix B.1.
+
+In general, our approach is slower than competing methods, but we find the memory-efficiency of the adjoint method allows us to use much larger batch sizes than those methods. On the tabular datasets we used a batch sizes up to 10,000 and on the image datasets we used a batch size of 900.
+
+# 4.3 VARIATIONAL AUTOENCODER
+
+We compare FFJORD to other normalizing flows for use in variational inference. We train a VAE (Kingma & Welling, 2014) on four datasets using a FFJORD flow and compare to VAEs with no flow, Planar Flows (Rezende & Mohamed, 2015), Inverse Autoregressive Flow (IAF) (Kingma
+
+<table><tr><td></td><td>MNIST</td><td>Omniglot</td><td>Frey Faces</td><td>Caltech Silhouettes</td></tr><tr><td>No Flow</td><td>86.55 ± .06</td><td>104.28 ± .39</td><td>4.53 ± .02</td><td>110.80 ± .46</td></tr><tr><td>Planar IAF</td><td>86.06 ± .31 84.20 ± .17</td><td>102.65 ± .42</td><td>4.40 ± .06</td><td>109.66 ± .42 111.58 ± .38</td></tr><tr><td></td><td></td><td>102.41 ± .04</td><td>4.47 ± .05</td><td></td></tr><tr><td>Sylvester</td><td>83.32 ± .06</td><td>99.00 ± .04</td><td>4.45 ± .04</td><td>104.62 ± .29</td></tr><tr><td>FFJORD</td><td>82.82 ± .01</td><td>98.33 ± .09</td><td>4.39 ± .01</td><td>104.03 ± .43</td></tr></table>
+
+Table 3: Negative ELBO on test data for VAE models; lower is better. In nats for all datasets except Frey Faces which is presented in bits per dimension. Mean/stdev are estimated over 3 runs.
+
+et al., 2016), and Sylvester normalizing flows (Berg et al., 2018). To provide a fair comparison, our encoder/decoder architectures and learning setup exactly mirror those of Berg et al. (2018).
+
+In VAEs it is common for the encoder network to also output the parameters of the flow as a function of the input $\mathbf { x }$ . With FFJORD, we found this led to differential equations which were too difficult to integrate numerically. Instead, the encoder network outputs a low-rank update to a global weight matrix and an input-dependent bias vector. When used in recognition nets, neural network layers defining the dynamics inside FFJORD take the form
+
+$$
+\mathrm { l a y e r } ( h ; \mathbf { x } , W , b ) = \sigma \left( \left( \underbrace { W } _ { D _ { o u t } \times D _ { i n } } + \underbrace { \hat { U } ( \mathbf { x } ) } _ { D _ { o u t } \times k } \underbrace { \hat { V } ( \mathbf { x } ) } _ { D _ { i n } \times k } ^ { T } \right) h + \underbrace { b } _ { D _ { o u t } \times 1 } + \underbrace { \hat { b } ( \mathbf { x } ) } _ { D _ { o u t } \times 1 } \right)
+$$
+
+where $h$ is the input to the layer, $\sigma$ is an element-wise activation function, $D _ { i n }$ and $D _ { o u t }$ are the input and output dimension of this layer, and ${ \hat { U } } ( \mathbf { x } ) , { \hat { V } } ( \mathbf { x } ) , { \hat { b } } ( \mathbf { x } )$ are input-dependent parameters returned from an encoder network. A full description of the model architectures used and our experimental setup can be found in Appendix B.2.
+
+On every dataset tested, FFJORD outperforms all other competing normalizing flows. A summary of our variational inference results can be found in Table 3.
+
+# 5 ANALYSIS AND DISCUSSION
+
+We performed a series of ablation experiments to gain a better understanding of the proposed model.
+
+# 5.1 FASTER TRAINING WITH BOTTLENECK TRICK
+
+We plotted the training losses on MNIST using an encoder-decoder architecture (see Appendix B.1 for details). Loss during training is plotted in Figure 4, where we use the trace estimator directly on the $D \times D$ Jacobian, or we use the bottleneck trick to reduce the dimension to $H \times H$ . Interestingly, we find that while the bottleneck trick (9) can lead to faster convergence when the trace is estimated using a Gaussian-distributed $\epsilon$ , we did not observe faster convergence when using a Rademacherdistributed $\epsilon$ .
+
+![](images/a5a4104a81a527db90fb5a4bf2e1e69de73b82219692f93512d6220935d9f7d7.jpg)  
+Figure 4: The variance of our model’s log-density estimator can be reduced using neural network architectures with a bottleneck layer, speeding up training.
+
+# 5.2 NUMBER OF FUNCTION EVALUATIONS VS. DATA DIMENSION
+
+The full computational cost of integrating the instantaneous change of variables (2) is $\mathcal { O } ( D H \widehat { L } )$ where $D$ is dimensionality of the data, $H$ is the size of the hidden state, and $\widehat { L }$ is the number of function evaluations (NFE) that the adaptive solver uses to integrate the ODE. In general, each evaluation of the model is $\mathcal { O } ( D H )$ and in practice, $H$ is typically chosen to be close to $D$ . Since the general form of the discrete change of variables equation (1) requires $\mathcal { O } ( D ^ { 3 } )$ -cost, one may wonder whether the number of evaluations $\widehat { L }$ depends on $D$ .
+
+We train VAEs using FFJORD flows with increasing latent dimension $D$ . The NFE throughout training is shown in Figure 5. In all models, we find that the NFE increases throughout training, but converges to the same value, independent of $D$ . We conjecture that the number of evaluations is not dependent on the dimensionality of the data but the complexity of its distribution, or more specifically, how difficult it is to transform its density into the base distribution.
+
+# 5.3 SINGLE-SCALE VS. MULTI-SCALE FFJORD
+
+Crucial to the scalability of Real NVP and Glow is the multiscale architecture originally proposed in Dinh et al. (2017). We compare a single-scale encoder-decoder style FFJORD with a multiscale FFJORD on the MNIST dataset where both models have a comparable number of parameters and plot the total NFE–in both forward and backward passes–against the loss achieved in Figure 6. We find that while the single-scale model uses approximately one half as many function evaluations as the multiscale model, it is not able to achieve the same performance as the multiscale model.
+
+![](images/0062858e8272d5676ba867e22f6633ff8e78e21441e692e039bb10cf152dc6a7.jpg)  
+Figure 5: NFE used by the adaptive ODE solver is approximately independent of data-dimension. Lines are smoothed using a Gaussian filter.
+
+![](images/1cd2619e51c02801395209923fba96f688f591bcf13f63fef7f5450530a63d78.jpg)  
+Figure 6: For image data, a single FFJORD flow can achieve near performance to multi-scale architecture while using half the number of evaluations.
+
+# 6 SCOPE AND LIMITATIONS
+
+Number of function evaluations can be prohibitive. The number of function evaluations required to integrate the dynamics is not fixed ahead of time, and is a function of the data, model architecture, and model parameters. This number tends to grow as the models trains and can become prohibitively large, even when memory stays constant due to the adjoint method. Various forms of regularization such as weight decay and spectral normalization (Miyato et al., 2018) can be used to reduce the this quantity, but their use tends to hurt performance slightly.
+
+Limitations of general-purpose ODE solvers. In theory, our model can approximate any differential equation (given mild assumptions based on existence and uniqueness of the solution), but in practice our reliance on general-purpose ODE solvers restricts us to non-stiff differential equations that can be efficiently solved. ODE solvers for stiff dynamics exist, but they evaluate $f$ many more times to achieve the same error. We find that a small amount of weight decay regularizes the ODE to be sufficiently non-stiff.
+
+# 7 CONCLUSION
+
+We have presented FFJORD, a reversible generative model for high-dimensional data which can compute exact log-likelihoods and can be sampled from efficiently. Our model uses continuoustime dynamics to produce a generative model which is parameterized by an unrestricted neural network. All required quantities for training and sampling can be computed using automatic differentiation, Hutchinson’s trace estimator, and black-box ODE solvers. Our model stands in contrast to other methods with similar properties which rely on restricted, hand-engineered neural network architectures. We demonstrated that this additional flexibility allows our approach to achieve on-par or improved performance on density estimation and variational inference.
+
+We believe there is much room for further work exploring and improving this method. FFJORD is empirically slower to evaluate than other reversible models like Real NVP or Glow, so we are interested specifically in ways to reduce the number of function evaluations used by the ODE-solver without hurting predictive performance. Advancements like these will be crucial in scaling this method to even higher-dimensional datasets.
+
+# 8 ACKNOWLEDGEMENTS
+
+We thank Yulia Rubanova and Roger Grosse for helpful discussions.
+
+# REFERENCES
+
+R. P. Adams, J. Pennington, M. J. Johnson, J. Smith, Y. Ovadia, B. Patton, and J. Saunderson. Estimating the Spectral Density of Large Implicit Matrices. ArXiv e-prints, February 2018.
+
+Joel Andersson. A general-purpose software framework for dynamic optimization. PhD thesis, 2013.
+
+Rianne van den Berg, Leonard Hasenclever, Jakub M Tomczak, and Max Welling. Sylvester normalizing flows for variational inference. arXiv preprint arXiv:1803.05649, 2018.
+
+Ricky T. Q. Chen, Yulia Rubanova, Jesse Bettencourt, and David Duvenaud. Neural ordinary differential equations. Advances in Neural Information Processing Systems, 2018.
+
+Laurent Dinh, David Krueger, and Yoshua Bengio. NICE: Non-linear independent components estimation. International Conference on Learning Representations Workshop, 2014.
+
+Laurent Dinh, Jascha Sohl-Dickstein, and Samy Bengio. Density estimation using Real NVP. International Conference on Learning Representations, 2017.
+
+Mathieu Germain, Karol Gregor, Iain Murray, and Hugo Larochelle. Made: Masked autoencoder for distribution estimation. In International Conference on Machine Learning, pp. 881–889, 2015.
+
+Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In Advances in neural information processing systems, pp. 2672–2680, 2014.
+
+Andreas Griewank and Andrea Walther. Evaluating derivatives: principles and techniques of algorithmic differentiation, volume 105. Siam, 2008.
+
+Chin-Wei Huang, David Krueger, Alexandre Lacoste, and Aaron Courville. Neural autoregressive flows. International Conference on Machine Learning, 2018.
+
+M.F. Hutchinson. A stochastic estimator of the trace of the influence matrix for laplacian smoothing splines. 18:1059–1076, 01 1989.
+
+H.K. Khalil. Nonlinear Systems. Pearson Education. Prentice Hall, 2002.
+
+Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. International Conference on Learning Representations, 2015.
+
+Diederik P Kingma and Prafulla Dhariwal. Glow: Generative flow with invertible 1x1 convolutions. Advances in Neural Information Processing Systems, 2018.
+
+Diederik P Kingma and Max Welling. Auto-encoding variational bayes. International Conference on Learning Representations, 2014.
+
+Diederik P Kingma, Tim Salimans, Rafal Jozefowicz, Xi Chen, Ilya Sutskever, and Max Welling. Improved variational inference with inverse autoregressive flow. In Advances in Neural Information Processing Systems, pp. 4743–4751, 2016.
+
+Takeru Miyato, Toshiki Kataoka, Masanori Koyama, and Yuichi Yoshida. Spectral normalization for generative adversarial networks. International Conference on Learning Representations, 2018.
+
+Junier B Oliva, Avinava Dubey, Barnabas P ´ oczos, Jeff Schneider, and Eric P Xing. Transformation ´ autoregressive networks. International Conference on Machine Learning, 2018.
+
+Aaron van den Oord, Nal Kalchbrenner, and Koray Kavukcuoglu. Pixel recurrent neural networks. International Conference on Machine Learning, 2016.
+
+George Papamakarios, Iain Murray, and Theo Pavlakou. Masked autoregressive flow for density estimation. In Advances in Neural Information Processing Systems, pp. 2338–2347, 2017.
+
+Lev Semenovich Pontryagin. Mathematical theory of optimal processes. Routledge, 1962.
+
+Danilo Jimenez Rezende and Shakir Mohamed. Variational inference with normalizing flows. International Conference on Machine Learning, 2015.
+
+David E Rumelhart, Geoffrey E Hinton, and Ronald J Williams. Learning representations by backpropagating errors. Nature, 323(6088):533, 1986.
+
+Lawrence F Shampine. Some practical Runge-Kutta formulas. Mathematics of Computation, 46 (173):135–150, 1986.
+
+# APPENDIX A QUALITATIVE SAMPLES
+
+Samples from our FFJORD models trained on MNIST and CIFAR10 can be found in Figure 7.
+
+![](images/7069f2c96885024f26e2483d05fa76cd504e9adeaf9540d42653e6f44943d89f.jpg)  
+Figure 7: Samples and data from our image models. MNIST on left, CIFAR10 on right.
+
+# APPENDIX B EXPERIMENTAL DETAILS AND ADDITIONAL RESULTS
+
+# B.1 DENSITY ESTIMATION
+
+On the tabular datasets we performed a grid-search over network architectures. We searched over models with 1, 2, 5, or 10 flows with 1, 2, 3, or 4 hidden layers per flow. Since each dataset has a different number of dimensions, we searched over hidden dimensions equal to 5, 10, or 20 times the data dimension (hidden dimension multiplier in Table 4). We tried both the tanh and softplus nonlinearities. The best performing models can be found in the Table 4.
+
+On the image datasets we experimented with two different model architectures; a single flow with an encoder-decoder style architecture and a multiscale architecture composed of multiple flows.
+
+While they were able to fit MNIST and obtain competitive performance, the encoder-decoder architectures were unable to fit more complicated image datasets such as CIFAR10 and Street View House Numbers. The architecture for MNIST which obtained the results in Table 2 was composed of four convolutional layers with $6 4 \to 6 4 \to 1 2 8 \to 1 2 8$ filters and down-sampling with strided convolutions by two every other layer. There are then four transpose-convolutional layers who’s filters mirror the first four layers and up-sample by two every other layer. The softplus activation function is used in every layer.
+
+The multiscale architectures were inspired by those presented in Dinh et al. (2017). We compose multiple flows together interspersed with “squeeze” operations which down-sample the spatial resolution of the images and increase the number of channels. These operations are stacked into a “scale block” which contains $N$ flows, a squeeze, then $N$ flows. For MNIST we use 3 scale blocks and for CIFAR10 we use 4 scale blocks and let $N = 2$ for both datasets. Each flow is defined by 3 convolutional layers with 64 filters and a kernel size of 3. The softplus nonlinearity is used in all layers.
+
+Both models were trained with the Adam optimizer (Kingma & Ba, 2015). We trained for 500 epochs with a learning rate of .001 which was decayed to .0001 after 250 epochs. Training took place on six GPUs and completed after approximately five days.
+
+# B.2 VARIATIONAL AUTOENCODER
+
+Our experimental procedure exactly mirrors that of Berg et al. (2018). We use the same 7-layer encoder and decoder, learning rate (.001), optimizer (Adam Kingma & Ba (2015)), batch size (100), and early stopping procedure (stop after 100 epochs of no validaiton improvment). The only difference was in the nomralizing flow used in the approximate posterior.
+
+We performed a grid-search over neural network architectures for the dynamics of FFJORD. We searched over networks with 1 and 2 hidden layers and hidden dimension 512, 1024, and 2048. We used flows with 1, 2, or 5 steps and wight matrix updates of rank 1, 20, and 64. We use the softplus activation function for all datasets except for Caltech Silhouettes where we used tanh. The best performing models can be found in the Table 5. Models were trained on a single GPU and training took between four hours and three days depending on the dataset.
+
+<table><tr><td>Dataset</td><td>nonlinearity</td><td>#layers</td><td>hidden dim multiplier</td><td># flow steps</td><td>batchsize</td></tr><tr><td>POWER</td><td>tanh</td><td>3</td><td>10</td><td>5</td><td>10000</td></tr><tr><td>GAS</td><td>tanh</td><td>3</td><td>20</td><td>5</td><td>1000</td></tr><tr><td>HEPMASS</td><td>softplus</td><td>2</td><td>10</td><td>10</td><td>10000</td></tr><tr><td>MINIBOONE</td><td>softplus</td><td>2</td><td>20</td><td>1</td><td>1000</td></tr><tr><td>BSDS300</td><td> softplus</td><td>3</td><td>20</td><td>2</td><td>10000</td></tr></table>
+
+Table 4: Best performing model architectures for density estimation on tabular data with FFJORD.
+
+Table 5: Best performing model architectures for VAEs with FFJORD.   
+
+<table><tr><td>Dataset</td><td>nonlinearity</td><td># layers</td><td>hidden dimension</td><td>#flow steps</td><td>rank</td></tr><tr><td>MNIST</td><td>softplus</td><td>2</td><td>1024</td><td>2</td><td>64</td></tr><tr><td>Omniglot</td><td>softplus</td><td>2</td><td>512</td><td>5</td><td>20</td></tr><tr><td>Frey Faces</td><td>softplus</td><td>2</td><td>512</td><td>2</td><td>20</td></tr><tr><td>Caltech</td><td>tanh</td><td>1</td><td>2048</td><td>1</td><td>20</td></tr></table>
+
+B.3 STANDARD DEVIATIONS FOR TABULAR DENSITY ESTIMATION   
+
+<table><tr><td></td><td>POWER</td><td>GAS</td><td>HEPMASS</td><td>MINIBOONE</td><td>BSDS300</td></tr><tr><td>Real NVP</td><td>-0.17 ± 0.01</td><td>-8.33 ± 0.14</td><td>18.71 ± 0.02</td><td>13.55 ± 0.49</td><td>-153.28 ± 1.78</td></tr><tr><td>Glow</td><td>-0.17 ± 0.01</td><td>-8.15 ± 0.40</td><td>18.92 ± 0.08</td><td>11.35 ± 0.07</td><td>-155.07 ± 0.03</td></tr><tr><td>FFJORD</td><td>-0.46 ± 0.01</td><td>-8.59 ±0.12</td><td>14.92 ± 0.08</td><td>10.43 ± 0.04</td><td>-157.40 ± 0.19</td></tr><tr><td>MADE</td><td>3.08 ± 0.03</td><td>-3.56 ± 0.04</td><td>20.98 ± 0.02</td><td>15.59 ± 0.50</td><td>-148.85 ± 0.28</td></tr><tr><td>MAF</td><td>-0.24 ± 0.01</td><td>-10.08 ± 0.02</td><td>17.70 ± 0.02</td><td>11.75 ± 0.44</td><td>-155.69 ± 0.28</td></tr><tr><td>TAN</td><td>-0.48 ± 0.01</td><td>-11.19 ± 0.02</td><td>15.12 ± 0.02</td><td>11.01 ± 0.48</td><td>-157.03 ± 0.07</td></tr><tr><td>MAF-DDSF</td><td>-0.62 ± 0.01</td><td>-11.96 ± 0.33</td><td>15.09 ± 0.40</td><td>8.86 ± 0.15</td><td>-157.73 ± 0.04</td></tr></table>
+
+Table 6: Negative log-likehood on test data for density estimation models. Means/stdev over 3 runs. Real NVP, MADE, MAF, TAN, and MAF-DDSF results on are taken from Huang et al. (2018). In reproducing Glow, we were able to get comparable results to the reported Real NVP by removing the invertible fully connected layers.
+
+# APPENDIX C NUMERICAL ERROR FROM THE ODE SOLVER
+
+ODE solvers are numerical integration methods so there is error inherent in their outputs. Adaptive solvers (like those used in all of our experiments) attempt to predict the errors that they accrue and modify their step-size to reduce their error below a user set tolerance. It is important to be aware of this error when we use these solvers for density estimation as the solver outputs the density that we report and compare with other methods. When tolerance is too low, we run into machine precision errors. Similarly when tolerance is too high, errors are large, our training objective becomes biased and we can run into divergent training dynamics.
+
+Since a valid probability density function integrates to one, we take a model trained on Figure 1 and numerically find the area under the curve using Riemann sum and a very fine grid. We do this for a range of tolerance values and show the resulting error in Figure 8. We set both atol and rtol to the same tolerance.
+
+![](images/02e88a1805109d6d2399eee267e1694fbcf917ec7e51dd627a734ef15382389d.jpg)  
+Figure 8: Numerical integration shows that the density under the model does integrate to one given sufficiently low tolerance. Both log and non-log plots are shown.
+
+The numerical error follows the same order as the tolerance, as expected. During training, we find that the error becomes non-negligible when using tolerance values higher than $\bar { 1 0 } ^ { - 5 }$ . For most of our experiments, we set tolerance to $1 0 ^ { - 5 }$ as that gives reasonable performance while requiring few number of evaluations. For the tabular experiments, we use atol $= 1 0 ^ { - 8 }$ and $\mathtt { r t o l } \mathtt { = } 1 0 ^ { - 6 }$ .

parse/train/rJxgknCcK7/rJxgknCcK7_content_list.json

@@ -0,0 +1,1702 @@
+[
+    {
+        "type": "text",
+        "text": "FFJORD: FREE-FORM CONTINUOUS DYNAMICS FOR SCALABLE REVERSIBLE GENERATIVE MODELS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            823,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Will Grathwohl∗†‡ , Ricky T. Q. Chen∗†, Jesse Bettencourt†, Ilya Sutskever‡ , David Duvenaud† ",
+        "bbox": [
+            179,
+            169,
+            826,
+            185
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            220,
+            544,
+            236
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Reversible generative models map points from a simple distribution to a complex distribution through an easily invertible neural network. Likelihood-based training of these models requires restricting their architectures to allow cheap computation of Jacobian determinants. Alternatively, the Jacobian trace can be used if the transformation is specified by an ordinary differential equation. In this paper, we use Hutchinson’s trace estimator to give a scalable unbiased estimate of the logdensity. The result is a continuous-time invertible generative model with unbiased density estimation and one-pass sampling, while allowing unrestricted neural network architectures. We demonstrate our approach on high-dimensional density estimation, image generation, and variational inference, improving the state-ofthe-art among exact likelihood methods with efficient sampling. ",
+        "bbox": [
+            233,
+            262,
+            764,
+            415
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            464,
+            336,
+            479
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Reversible generative models use cheaply invertible neural networks to transform samples from a fixed base distribution. Examples include NICE (Dinh et al., 2014), Real NVP (Dinh et al., 2017), and Glow (Kingma & Dhariwal, 2018). These models are easy to sample from, and can be trained by maximum likelihood using the change of variables formula. However, this requires placing awkward restrictions on their architectures, such as partitioning dimensions or using rank one weight matrices, in order to avoid an $\\mathcal { O } ( D ^ { 3 } )$ cost determinant computation. ",
+        "bbox": [
+            174,
+            503,
+            549,
+            642
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recently, Chen et al. (2018) introduced continuous normalizing flows (CNF), defining the mapping from latent variables to data using ordinary differential equations (ODE). In their model, the likelihood can be computed using trace operations costing only $\\mathcal { O } ( D ^ { 2 } )$ . This allows a more flexible, but still restricted, family of network architectures to be used. ",
+        "bbox": [
+            174,
+            650,
+            547,
+            746
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Extending this work, we introduce an unbiased stochastic estimator of the likelihood that has $\\mathcal { O } ( D )$ time cost, allowing completely unrestricted architectures. Furthermore, we have implemented GPU-based adaptive ODE solvers to train and evaluate these models on modern hardware. We call our approach Free-form Jacobian of ",
+        "bbox": [
+            174,
+            755,
+            549,
+            838
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/a3ee11ba6739d7a93b9f3874d4b4484510a3bd876d2128620a72649eb1edf2e9.jpg",
+        "image_caption": [
+            "Figure 1: FFJORD transforms a simple base distribution at $t _ { 0 }$ into the target distribution at $t _ { 1 }$ by integrating over learned continuous dynamics. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            560,
+            513,
+            820,
+            755
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Reversible Dynamics (FFJORD). Figure 1 shows FFJORD smoothly transforming a Gaussian distribution into a multi-modal distribution. ",
+        "bbox": [
+            174,
+            838,
+            825,
+            866
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "2 BACKGROUND: GENERATIVE MODELS AND CHANGE OF VARIABLES ",
+        "text_level": 1,
+        "bbox": [
+            169,
+            102,
+            776,
+            118
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In contrast to directly parameterizing a normalized distribution (e.g. Oord et al. (2016); Germain et al. (2015)), the change of variables formula allows one to specify a complex normalized distribution $p _ { \\mathbf { x } } ( \\mathbf { x } )$ implicitly by warping a normalized base distribution $p _ { \\mathbf { z } } ( \\mathbf { z } )$ through an invertible function $f : \\mathbb { R } ^ { D } \\overset { \\cdot } {  } \\mathbb { R } ^ { D }$ . Given a random variable $\\mathbf { z } \\sim p _ { \\mathbf { z } } ( \\mathbf { z } )$ the log density of ${ \\bf x } = f ( { \\bf z } )$ follows ",
+        "bbox": [
+            173,
+            132,
+            825,
+            189
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/cb46a9be2003733da0a7e00cb2df083a5cd6cd05898f1e5d16245321de36f59a.jpg",
+        "text": "$$\n\\log p _ { \\mathbf { x } } ( \\mathbf { x } ) = \\log p _ { \\mathbf { z } } ( \\mathbf { z } ) - \\log \\operatorname* { d e t } \\left| \\frac { \\partial f ( \\mathbf { z } ) } { \\partial \\mathbf { z } } \\right|\n$$",
+        "text_format": "latex",
+        "bbox": [
+            362,
+            190,
+            637,
+            224
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $\\partial f ( \\mathbf { z } ) / \\partial \\mathbf { z }$ is the Jacobian of $f$ . In general, computing the log determinant has a time cost of $\\mathcal { O } ( D ^ { 3 } )$ . Much work has gone into developing restricted neural network architectures which make computing the Jacobian’s determinant more tractable. These approaches broadly fall into three categories: ",
+        "bbox": [
+            174,
+            227,
+            825,
+            282
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Normalizing flows. By restricting the functional form of $f$ , various determinant identities can be exploited (Rezende & Mohamed, 2015; Berg et al., 2018). These models cannot be trained as generative models from data because they do not have a tractable inverse $f ^ { - 1 }$ . However, they are useful for specifying approximate posteriors for variational inference (Kingma & Welling, 2014). ",
+        "bbox": [
+            181,
+            291,
+            825,
+            348
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Autoregressive transformations. By using an autoregressive model and specifying an ordering of the dimensions, the Jacobian of $f$ is enforced to be lower triangular (Kingma et al., 2016; Oliva et al., 2018). These models excel at density estimation for tabular datasets (Papamakarios et al., 2017), but require $D$ sequential evaluations of $f$ to invert, which is prohibitive when $D$ is large. ",
+        "bbox": [
+            183,
+            351,
+            825,
+            407
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Partitioned transformations. Partitioning the dimensions and using affine transformations makes the determinant of the Jacobian cheap to compute, and the inverse $\\breve { f } ^ { - 1 }$ computable with the same cost as $f$ (Dinh et al., 2014; 2017). This method allows the use of convolutional architectures, excelling at density estimation for image data (Dinh et al., 2017; Kingma & Dhariwal, 2018). ",
+        "bbox": [
+            181,
+            410,
+            825,
+            467
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Throughout this work, we refer to reversible generative models as those which use the change of variables to transform a base distribution to the model distribution while maintaining both efficient density estimation and efficient sampling capabilities using a single pass of the model. ",
+        "bbox": [
+            176,
+            477,
+            823,
+            520
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 OTHER GENERATIVE MODELS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            535,
+            424,
+            549
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "There exist several approaches to generative modeling approaches which do not use the change of variables equation for training. Generative adversarial networks (GANs) (Goodfellow et al., 2014) use large, unrestricted neural networks to transform samples from a fixed base distribution. Lacking a closed-form likelihood, an auxiliary discriminator model must be trained to estimate divergences or density ratios in order to provide a training signal. Autoregressive models (Germain et al., 2015; Oord et al., 2016) directly specify the joint distribution $p ( \\mathbf { x } )$ as a sequence of explicit conditional distributions using the product rule. These models require at least $\\mathcal { O } ( D )$ evaluations to sample from. Variational autoencoders (VAEs) (Kingma & Welling, 2014) use an unrestricted architecture to explicitly specify the conditional likelihood $p ( x | z )$ , but can only efficiently provide a stochastic lower bound on the marginal likelihood $p ( x )$ . ",
+        "bbox": [
+            173,
+            560,
+            825,
+            700
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.2 CONTINUOUS NORMALIZING FLOWS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            715,
+            470,
+            729
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Chen et al. (2018) define a generative model for data $\\mathbf { x } \\in \\mathbb { R } ^ { D }$ similar to those based on (1), but replace the warping function with an integral of continuous-time dynamics. The generative process first samples from a base distribution ${ \\bf z } _ { 0 } \\sim p _ { z _ { 0 } } ( { \\bf z } _ { 0 } )$ . Then, given an ODE whose dynamics are defined by the parametric function $\\partial \\mathbf { z } ( t ) / \\partial t = f ( \\mathbf { z } ( t ) , t ; \\theta )$ , we solve the initial value problem with $\\mathbf { z } ( t _ { 0 } ) = \\dot { \\mathbf { z } } _ { 0 }$ to obtain a data sample ${ \\mathbf x } = { \\mathbf z } ( t _ { 1 } )$ . These models are called Continous Normalizing Flows (CNF). The change in log-density under this model follows a second differential equation, called the instantaneous change of variables formula (Chen et al., 2018): ",
+        "bbox": [
+            173,
+            741,
+            825,
+            840
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5848f3f861f37da5242e69251c7c16ad419da374ec336abf4fa7d998de9acba1.jpg",
+        "text": "$$\n\\frac { \\partial \\log p ( { \\bf z } ( t ) ) } { \\partial t } = - \\mathrm { T r } \\left( \\frac { \\partial f } { \\partial { \\bf z } ( t ) } \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            390,
+            840,
+            609,
+            875
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We can compute total change in log-density by integrating across time: ",
+        "bbox": [
+            176,
+            876,
+            638,
+            891
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d84a7717eebbd6134c421bea344835f1bc9a5e9840271c4c9cedb55a3bb6458a.jpg",
+        "text": "$$\n\\log p ( \\mathbf { z } ( t _ { 1 } ) ) = \\log p ( \\mathbf { z } ( t _ { 0 } ) ) - \\int _ { t _ { 0 } } ^ { t _ { 1 } } \\operatorname { T r } \\left( { \\frac { \\partial f } { \\partial \\mathbf { z } ( t ) } } \\right) d t .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            326,
+            891,
+            673,
+            929
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "table",
+        "img_path": "images/1cf781c68cf80067d0a2434a4b4ad54ded98de4747c4834fd9e47f1a23e2ff8c.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"2\">Method</td><td rowspan=\"2\">Train on data</td><td rowspan=\"2\">One-pass Sampling</td><td rowspan=\"2\">Exact/Unbiased Log- likelihood</td><td rowspan=\"2\">Free- form Jacobian</td></tr><tr><td colspan=\"2\"></td></tr><tr><td rowspan=\"4\"></td><td>Variational Autoencoders</td><td></td><td></td><td>X</td><td>√</td></tr><tr><td>Generative Adversarial Nets</td><td></td><td>√</td><td>×</td><td>√</td></tr><tr><td>Likelihood-based Autoregressive</td><td></td><td>×</td><td>√</td><td>×</td></tr><tr><td>Normalizing Flows</td><td>X</td><td>√</td><td></td><td>X</td></tr><tr><td rowspan=\"3\">o auegg 2aaiber</td><td>Reverse-NF,MAF, TAN</td><td></td><td>X</td><td></td><td>X</td></tr><tr><td>NICE,Real NVP, Glow, Planar CNF</td><td></td><td>√</td><td></td><td>X</td></tr><tr><td>FFJORD</td><td></td><td>「</td><td></td><td></td></tr></table>",
+        "bbox": [
+            173,
+            99,
+            823,
+            289
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Given a datapoint x, we can compute both the point $\\mathbf { z } _ { 0 }$ which generates $\\mathbf { x }$ , as well as $\\log p ( \\mathbf { x } )$ under the model by solving the combined initial value problem: ",
+        "bbox": [
+            173,
+            335,
+            823,
+            363
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "which integrates the combined dynamics of $z ( t )$ and the log-density of the sample backwards in time from $t _ { 1 }$ to $t _ { 0 }$ . We can then compute $\\log p ( \\mathbf { x } )$ using the solution of (4) and adding $\\log p _ { z _ { 0 } } ( { \\bf z } _ { 0 } )$ . The existence and uniqueness of (4) require that $f$ and its first derivatives be Lipschitz continuous (Khalil, 2002), which can be satisfied in practice using neural networks with smooth Lipschitz activations, such as softplus or tanh. ",
+        "bbox": [
+            173,
+            444,
+            825,
+            515
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2.1 BACKPROPAGATING THROUGH ODE SOLUTIONS WITH THE ADJOINT METHOD ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            529,
+            772,
+            544
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "CNFs are trained to maximize (3). This objective involves the solution to an initial value problem with dynamics parameterized by $\\theta$ . For any scalar loss function which operates on the solution to an initial value problem ",
+        "bbox": [
+            176,
+            553,
+            821,
+            595
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/142e659d51d33580aeb22cd663fd59c402ec0087f798290cb30d3be7d1314f97.jpg",
+        "text": "$$\nL ( \\mathbf { z } ( t _ { 1 } ) ) = L \\left( \\int _ { t _ { 0 } } ^ { t _ { 1 } } f ( \\mathbf { z } ( t ) , t ; \\theta ) d t \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            375,
+            597,
+            620,
+            633
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "then Pontryagin (1962) shows that its derivative takes the form of another initial value problem ",
+        "bbox": [
+            171,
+            636,
+            792,
+            650
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6a8edb91704d25bb78453d4b2c448749666f93f4ada6c5b901af1dc9f2e9267a.jpg",
+        "text": "$$\n\\frac { d L } { d \\theta } = - \\int _ { t _ { 1 } } ^ { t _ { 0 } } \\left( \\frac { \\partial L } { \\partial \\mathbf { z } ( t ) } \\right) ^ { T } \\frac { \\partial f ( \\mathbf { z } ( t ) , t ; \\theta ) } { \\partial \\theta } d t .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            357,
+            651,
+            640,
+            690
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The quantity $- { \\partial L } / { \\partial { \\bf z } ( t ) }$ is known as the adjoint state of the ODE. Chen et al. (2018) use a black-box ODE solver to compute ${ \\bf z } ( t _ { 1 } )$ , and then a separate call to a solver to compute (6) with the initial value ${ \\partial L } / { \\partial { \\bf z } ( t _ { 1 } ) }$ . This approach is a continuous-time analog to the backpropgation algorithm (Rumelhart et al., 1986; Andersson, 2013) and can be combined with gradient-based optimization to fit the parameters $\\theta$ by maximum likelihood. ",
+        "bbox": [
+            173,
+            691,
+            825,
+            762
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 SCALABLE DENSITY EVALUATION WITH UNRESTRICTED ARCHITECTURES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            782,
+            815,
+            797
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Switching from discrete-time dynamics to continuous-time dynamics reduces the primary computational bottleneck of normalizing flows from $\\mathcal { O } ( D ^ { 3 } )$ to $\\mathcal { O } ( D ^ { 2 } )$ , at the cost of introducing a numerical ODE solver. This allows the use of more expressive architectures. For example, each layer of the original normalizing flows model of Rezende & Mohamed (2015) is a one-layer neural network with only a single hidden unit. In contrast, the instantaneous transformation used in planar continuous normalizing flows (Chen et al., 2018) is a one-layer neural network with many hidden units. In this section, we construct an unbiased estimate of the log-density with $\\mathcal { O } ( D )$ cost, allowing completely unrestricted neural network architectures to be used. ",
+        "bbox": [
+            173,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 UNBIASED LINEAR-TIME LOG-DENSITY ESTIMATION ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            103,
+            588,
+            118
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In general, computing $\\operatorname { T r } \\left( { \\partial f } / { \\partial \\mathbf { z } ( t ) } \\right)$ exactly costs $\\mathcal { O } ( D ^ { 2 } )$ , or approximately the same cost as $D$ evaluations of $f$ , since each entry of the diagonal of the Jacobian requires computing a separate derivative of $f$ (Griewank & Walther, 2008). However, there are two tricks that can help. First, vector-Jacobian products ${ \\pmb v } ^ { T } \\frac { \\partial f } { \\partial { \\bf z } }$ can be computed for approximately the same cost as evaluating $f$ using reverse-mode automatic differentiation. Second, we can get an unbiased estimate of the trace of a matrix by taking a double product of that matrix with a noise vector: ",
+        "bbox": [
+            173,
+            128,
+            825,
+            215
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/cbfd424e90b2ddcd418be555e45c02a402a00d2550d9ad9a3f8d3cab825d4873.jpg",
+        "text": "$$\n\\operatorname { T r } ( A ) = \\mathbb { E } _ { p ( \\epsilon ) } [ \\epsilon ^ { T } A \\epsilon ] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            421,
+            223,
+            576,
+            243
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The above equation holds for any $D$ -by- $D$ matrix $A$ and distribution $p ( \\epsilon )$ over $D$ -dimensional vectors such that $\\mathbb { E } [ \\boldsymbol { \\epsilon } ] = 0$ and $\\mathrm { C o v } ( \\epsilon ) = I$ . The Monte Carlo estimator derived from (7) is known as Hutchinson’s trace estimator (Hutchinson, 1989; Adams et al., 2018). ",
+        "bbox": [
+            174,
+            251,
+            825,
+            294
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To keep the dynamics deterministic within each call to the ODE solver, we can use a fixed noise vector $\\epsilon$ for the duration of each solve without introducing bias: ",
+        "bbox": [
+            174,
+            299,
+            823,
+            328
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/54c0e4989ba82626d9ee7008dd9e24b3ca31ec1ac529d881f2c00d987681e85e.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\log p ( \\mathbf { z } ( t _ { 1 } ) ) = \\log p ( \\mathbf { z } ( t _ { 0 } ) ) - \\int _ { t _ { 0 } } ^ { t _ { 1 } } \\operatorname { T r } \\left( \\frac { \\partial f } { \\partial \\mathbf { z } ( t ) } \\right) d t } \\\\ & { \\qquad = \\log p ( \\mathbf { z } ( t _ { 0 } ) ) - \\int _ { t _ { 0 } } ^ { t _ { 1 } } \\mathbb { E } _ { p ( \\epsilon ) } \\left[ \\epsilon ^ { T } \\frac { \\partial f } { \\partial \\mathbf { z } ( t ) } \\epsilon \\right] d t } \\\\ & { \\qquad = \\log p ( \\mathbf { z } ( t _ { 0 } ) ) - \\mathbb { E } _ { p ( \\epsilon ) } \\left[ \\int _ { t _ { 0 } } ^ { t _ { 1 } } \\epsilon ^ { T } \\frac { \\partial f } { \\partial \\mathbf { z } ( t ) } \\epsilon d t \\right] } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            310,
+            335,
+            686,
+            449
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Typical choices of $p ( \\epsilon )$ are a standard Gaussian or Rademacher distribution (Hutchinson, 1989). ",
+        "bbox": [
+            168,
+            454,
+            805,
+            469
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1.1 REDUCING VARIANCE WITH BOTTLENECK CAPACITY ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            484,
+            599,
+            500
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Often, there exist bottlenecks in the architecture of the dynamics network, i.e. hidden layers whose width $H$ is smaller than the dimensions of the input $D$ . In such cases, we can reduce the variance of Hutchinson’s estimator by using the cyclic property of trace. Since the variance of the estimator for $\\operatorname { T r } ( A )$ grows asymptotic to $| | \\bar { A | | } _ { F } ^ { 2 }$ (Hutchinson, 1989), we suspect that having fewer dimensions should help reduce variance. If we view the dynamics as a composition of two functions $f = g \\circ h ( \\mathbf { z } )$ then we observe ",
+        "bbox": [
+            176,
+            508,
+            825,
+            593
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/12c2e802076e689c015ee899b8b2349b0db6d7c6595fad6bbbfe12aaa7a57d9c.jpg",
+        "text": "$$\n\\operatorname { T r } \\underbrace { \\left( { \\frac { \\partial f } { \\partial \\mathbf { z } } } \\right) } _ { D \\times D } = \\operatorname { T r } \\underbrace { \\left( { \\frac { \\partial g } { \\partial h } } { \\frac { \\partial h } { \\partial \\mathbf { z } } } \\right) } _ { D \\times D } = \\operatorname { T r } \\underbrace { \\left( { \\frac { \\partial h } { \\partial \\mathbf { z } } } { \\frac { \\partial g } { \\partial h } } \\right) } _ { H \\times H } = \\mathbb { E } _ { p ( \\epsilon ) } \\left[ \\epsilon ^ { T } { \\frac { \\partial h } { \\partial \\mathbf { z } } } { \\frac { \\partial g } { \\partial h } } \\epsilon \\right] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            276,
+            598,
+            723,
+            651
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "When $f$ has multiple hidden layers, we choose $H$ to be the smallest dimension. This bottleneck trick can reduce the norm of the matrix which may also help reduce the variance of the trace estimator. As introducing a bottleneck limits our model capacity, we do not use this trick in our experiments. However this trick can reduce variance when a bottleneck is used, as shown in our ablation studies. ",
+        "bbox": [
+            176,
+            657,
+            823,
+            715
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 FFJORD: A CONTINUOUS-TIME REVERSIBLE GENERATIVE MODEL ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            731,
+            687,
+            747
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Our complete method uses the dynamics defined in (2) and the efficient log-likelihood estimator of (8) to produce the first scalable and reversible generative model with an unconstrained Jacobian. We call this method Free-Form Jacobian of Reversible Dyanamics (FFJORD). Pseudo-code of our method is given in Algorithm 1, and Table 1 summarizes the capabilities of our model compared to other recent generative modeling approaches. ",
+        "bbox": [
+            174,
+            757,
+            825,
+            829
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Assuming the cost of evaluating $f$ is on the order of $\\mathcal { O } ( D H )$ where $D$ is the dimensionality of the data and $H$ is the size of the largest hidden layer in $f$ , then the cost of computing the likelihood in models with repeated use of invertible transformations (1) is $\\mathcal { O } ( ( D H + \\bar { D ^ { 3 } } ) L )$ where $L$ is the number of transformations used. For CNF, this reduces to ${ \\mathcal O } ( ( D H + D ^ { 2 } ) \\hat { L } )$ for CNFs, where $\\hat { L }$ is the number of evaluations of $f$ used by the ODE solver. With FFJORD, this reduces further to $\\mathcal { O } ( ( D H + D ) \\hat { L } )$ . ",
+        "bbox": [
+            173,
+            834,
+            825,
+            925
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/b34fed5a83684ccc6e93bb0dc5a1feeb508097f2797af7d9f111193d13b8258e.jpg",
+        "table_caption": [
+            ""
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"2\">Algorithm1 Unbiased stochastic log-density estimation using the FFJORD model Require: dynamics fe,start time to,stop time t1,data samples x,data dimension D.</td></tr><tr><td>∈ ← sample_unit_variance(x.shape) function faug([zt, log pt],t):</td><td>&gt; Sample E outside of the integral &gt;Augment f with log-density dynamics.</td></tr><tr><td>ft←fo(z(t）,t) Taf</td><td>Evaluate neural network</td></tr><tr><td>g←εT zlz(t)</td><td> Compute vector-Jacobian product with automatic differentiation</td></tr><tr><td>Tr= ge return [ft,-Tr]</td><td> Unbiased estimateof Tr() with eTOfe</td></tr><tr><td>end function [zo,△logp] ←odeint(faug,[x,0],to,t1)</td><td>&gt; Concatenate dynamics of state and log-density Solve theODE St fug([z(t),lgp(z(t)),t)t</td></tr></table>",
+        "bbox": [
+            173,
+            107,
+            826,
+            296
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            325,
+            326,
+            342
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We demonstrate FFJORD on a variety of density estimation tasks, and for approximate inference in variational autoencoders (Kingma & Welling, 2014). Experiments were conducted using a suite of GPU-based ODE-solvers and an implementation of the adjoint method for backpropagation1. In all experiments the RungeKutta 4(5) algorithm with the tableau from Shampine (1986) was used to solve the ODEs. We ensure tolerance is set low enough so numerical error is negligible; see Appendix C. ",
+        "bbox": [
+            174,
+            359,
+            483,
+            512
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We used Hutchinson’s trace estimator (7) during training and the exact trace when reporting test results. This was done in all experiments except for our density estimation models trained on MNIST and CIFAR10 where computing the exact Jacobian trace was too expensive. ",
+        "bbox": [
+            174,
+            520,
+            483,
+            617
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/ab8bf16b71e4f4d69d040ce6a540697db00a6b4a08e459f7fbc52bea5bcf8b06.jpg",
+        "image_caption": [
+            "Figure 2: Comparison of trained Glow, planar CNF, and FFJORD models on 2-dimensional distributions, including multi-modal and discontinuous densities. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            503,
+            337,
+            816,
+            537
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The dynamics of FFJORD are defined by a neural network $f$ which takes as input the current state $\\mathbf { z } ( t ) \\in \\mathbb { R } ^ { D }$ and the current time $t \\in \\mathbb { R }$ . We experimented with several ways to incorporate $t$ as an input to $f$ , such as hyper-networks, but found that simply concatenating $t$ on to ${ \\bf z } ( t )$ at the input to every layer worked well and was used in all of our experiments. ",
+        "bbox": [
+            174,
+            625,
+            825,
+            680
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 DENSITY ESTIMATION ON TOY 2D DATA ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            702,
+            500,
+            717
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We first train on 2 dimensional data to visualize the model and the learned dynamics.2 In Figure 2, we show that by warping a simple isotropic Gaussian, FFJORD can fit both multi-modal and even discontinuous distributions. The number of evaluations of the ODE solver is roughly 70-100 on all datasets, so we compare against a Glow model with 100 discrete layers. ",
+        "bbox": [
+            174,
+            729,
+            825,
+            786
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The learned distributions of both FFJORD and Glow can be seen in Figure 2. Interestingly, we find that Glow learns to stretch the unimodal base distribution into multiple modes but has trouble modeling the areas of low probability between disconnected regions. In contrast, FFJORD is capable of modeling disconnected modes and can also learn convincing approximations of discontinuous density functions (middle row in Figure 2). Since the main benefit of FFJORD is the ability to train with deeper dynamics networks, we also compare against planar CNF (Chen et al., 2018) which can ",
+        "bbox": [
+            174,
+            792,
+            825,
+            877
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/fac29854af968af5e276b62f3dccd72d8cf66f74c5f18de98ca150c65f578941.jpg",
+        "image_caption": [
+            "Figure 3: Samples and data from our image models. MNIST on left, CIFAR10 on right. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            101,
+            825,
+            151
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/458a366710f2fc34c0cc4a2bd74ad71f73cbbd18ca9e4d9f0ca8e520ba7f4225.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>POWER</td><td>GAS</td><td>HEPMASS</td><td>MINIBOONE</td><td>BSDS300</td><td>MNIST</td><td>CIFAR10</td></tr><tr><td>Real NVP</td><td>-0.17</td><td>-8.33</td><td>18.71</td><td>13.55</td><td>-153.28</td><td>1.06*</td><td>3.49*</td></tr><tr><td>Glow</td><td>-0.17</td><td>-8.15</td><td>18.92</td><td>11.35</td><td>-155.07</td><td>1.05*</td><td>3.35*</td></tr><tr><td>FFJORD</td><td>-0.46</td><td>-8.59</td><td>14.92</td><td>10.43</td><td>-157.40</td><td>0.99* (1.05†)</td><td>3.40*</td></tr><tr><td>MADE</td><td>3.08</td><td>-3.56</td><td>20.98</td><td>15.59</td><td>-148.85</td><td>2.04</td><td>5.67</td></tr><tr><td>MAF</td><td>-0.24</td><td>-10.08</td><td>17.70</td><td>11.75</td><td>-155.69</td><td>1.89</td><td>4.31</td></tr><tr><td>TAN</td><td>-0.48</td><td>-11.19</td><td>15.12</td><td>11.01</td><td>-157.03</td><td>-</td><td>-</td></tr><tr><td>MAF-DDSF</td><td>-0.62</td><td>-11.96</td><td>15.09</td><td>8.86</td><td>-157.73</td><td>-</td><td>-</td></tr></table>",
+        "bbox": [
+            173,
+            193,
+            823,
+            351
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Table 2: Negative log-likehood on test data for density estimation models; lower is better. In nats for tabular data and bits/dim for MNIST and CIFAR10. \\*Results use multi-scale convolutional architectures. †Results use a single flow with a convolutional encoder-decoder architecture. ",
+        "bbox": [
+            174,
+            359,
+            825,
+            402
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "be viewed as a single hidden layer network. Without the benefit of a flexible network, planar CNF is unable to model complex distributions. ",
+        "bbox": [
+            174,
+            433,
+            821,
+            462
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 DENSITY ESTIMATION ON REAL DATA ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            483,
+            480,
+            498
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We perform density estimation on five tabular datasets preprocessed as in Papamakarios et al. (2017) and two image datasets; MNIST and CIFAR10. When reproducing Glow, we use the same configurations for Real NVP as Papamakarios et al. (2017) and add invertible fully connected layer between all coupling layers. On the tabular datasets, FFJORD performs the best out of reversible models by a wide margin but is outperformed by recent autoregressive models. Of those, FFJORD outperforms MAF (Papamakarios et al., 2017) on all but one dataset and manages to outperform TAN Oliva et al. (2018) on the MINIBOONE dataset. These models require $\\mathcal { O } ( D )$ sequential computations to sample from while the best performing method, MAF-DDSF (Huang et al., 2018), cannot be sampled from without resorting to correlated or expensive sampling algorithms such as MCMC. ",
+        "bbox": [
+            174,
+            512,
+            825,
+            637
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "On MNIST we find that FFJORD can model the data as effectively as Glow and Real NVP using only a single flow defined by a single neural network. This is in contrast to Glow and Real NVP which must compose many flows to achieve similar performance. When we use multiple flows in a multiscale architecture (like those used by Glow and Real NVP) we obtain better performance on MNIST and comparable performance to Glow on CIFAR10. Notably, FFJORD is able to achieve this performance while using less than $2 \\%$ as many parameters as Glow. We also note that Glow uses a learned base distribution whereas FFJORD and Real NVP use a fixed Gaussian. A summary of our results on density estimation can be found in Table 2 and samples can be seen in Figure 3. Full details on architectures used, our experimental procedure, and additional samples can be found in Appendix B.1. ",
+        "bbox": [
+            174,
+            643,
+            825,
+            782
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In general, our approach is slower than competing methods, but we find the memory-efficiency of the adjoint method allows us to use much larger batch sizes than those methods. On the tabular datasets we used a batch sizes up to 10,000 and on the image datasets we used a batch size of 900. ",
+        "bbox": [
+            176,
+            790,
+            823,
+            832
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.3 VARIATIONAL AUTOENCODER ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            853,
+            423,
+            867
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We compare FFJORD to other normalizing flows for use in variational inference. We train a VAE (Kingma & Welling, 2014) on four datasets using a FFJORD flow and compare to VAEs with no flow, Planar Flows (Rezende & Mohamed, 2015), Inverse Autoregressive Flow (IAF) (Kingma ",
+        "bbox": [
+            176,
+            882,
+            823,
+            922
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/e5be08504d8e7f8d6823c71a96eb090a0b8d126ca3b94d78574aee015b82bfca.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>MNIST</td><td>Omniglot</td><td>Frey Faces</td><td>Caltech Silhouettes</td></tr><tr><td>No Flow</td><td>86.55 ± .06</td><td>104.28 ± .39</td><td>4.53 ± .02</td><td>110.80 ± .46</td></tr><tr><td>Planar IAF</td><td>86.06 ± .31 84.20 ± .17</td><td>102.65 ± .42</td><td>4.40 ± .06</td><td>109.66 ± .42 111.58 ± .38</td></tr><tr><td></td><td></td><td>102.41 ± .04</td><td>4.47 ± .05</td><td></td></tr><tr><td>Sylvester</td><td>83.32 ± .06</td><td>99.00 ± .04</td><td>4.45 ± .04</td><td>104.62 ± .29</td></tr><tr><td>FFJORD</td><td>82.82 ± .01</td><td>98.33 ± .09</td><td>4.39 ± .01</td><td>104.03 ± .43</td></tr></table>",
+        "bbox": [
+            238,
+            101,
+            758,
+            218
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 3: Negative ELBO on test data for VAE models; lower is better. In nats for all datasets except Frey Faces which is presented in bits per dimension. Mean/stdev are estimated over 3 runs. ",
+        "bbox": [
+            173,
+            227,
+            823,
+            256
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "et al., 2016), and Sylvester normalizing flows (Berg et al., 2018). To provide a fair comparison, our encoder/decoder architectures and learning setup exactly mirror those of Berg et al. (2018). ",
+        "bbox": [
+            173,
+            280,
+            823,
+            309
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In VAEs it is common for the encoder network to also output the parameters of the flow as a function of the input $\\mathbf { x }$ . With FFJORD, we found this led to differential equations which were too difficult to integrate numerically. Instead, the encoder network outputs a low-rank update to a global weight matrix and an input-dependent bias vector. When used in recognition nets, neural network layers defining the dynamics inside FFJORD take the form ",
+        "bbox": [
+            176,
+            315,
+            823,
+            386
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2819597158464df4e29f85605e3f59a998943628e0a06ac572626318d327820e.jpg",
+        "text": "$$\n\\mathrm { l a y e r } ( h ; \\mathbf { x } , W , b ) = \\sigma \\left( \\left( \\underbrace { W } _ { D _ { o u t } \\times D _ { i n } } + \\underbrace { \\hat { U } ( \\mathbf { x } ) } _ { D _ { o u t } \\times k } \\underbrace { \\hat { V } ( \\mathbf { x } ) } _ { D _ { i n } \\times k } ^ { T } \\right) h + \\underbrace { b } _ { D _ { o u t } \\times 1 } + \\underbrace { \\hat { b } ( \\mathbf { x } ) } _ { D _ { o u t } \\times 1 } \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            236,
+            388,
+            761,
+            440
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "where $h$ is the input to the layer, $\\sigma$ is an element-wise activation function, $D _ { i n }$ and $D _ { o u t }$ are the input and output dimension of this layer, and ${ \\hat { U } } ( \\mathbf { x } ) , { \\hat { V } } ( \\mathbf { x } ) , { \\hat { b } } ( \\mathbf { x } )$ are input-dependent parameters returned from an encoder network. A full description of the model architectures used and our experimental setup can be found in Appendix B.2. ",
+        "bbox": [
+            174,
+            443,
+            825,
+            502
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "On every dataset tested, FFJORD outperforms all other competing normalizing flows. A summary of our variational inference results can be found in Table 3. ",
+        "bbox": [
+            174,
+            507,
+            823,
+            536
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5 ANALYSIS AND DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            556,
+            442,
+            571
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We performed a series of ablation experiments to gain a better understanding of the proposed model. ",
+        "bbox": [
+            174,
+            587,
+            549,
+            616
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.1 FASTER TRAINING WITH BOTTLENECK TRICK ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            632,
+            532,
+            646
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We plotted the training losses on MNIST using an encoder-decoder architecture (see Appendix B.1 for details). Loss during training is plotted in Figure 4, where we use the trace estimator directly on the $D \\times D$ Jacobian, or we use the bottleneck trick to reduce the dimension to $H \\times H$ . Interestingly, we find that while the bottleneck trick (9) can lead to faster convergence when the trace is estimated using a Gaussian-distributed $\\epsilon$ , we did not observe faster convergence when using a Rademacherdistributed $\\epsilon$ . ",
+        "bbox": [
+            174,
+            657,
+            549,
+            796
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/a5a4104a81a527db90fb5a4bf2e1e69de73b82219692f93512d6220935d9f7d7.jpg",
+        "image_caption": [
+            "Figure 4: The variance of our model’s log-density estimator can be reduced using neural network architectures with a bottleneck layer, speeding up training. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            571,
+            583,
+            812,
+            717
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.2 NUMBER OF FUNCTION EVALUATIONS VS. DATA DIMENSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            813,
+            638,
+            828
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The full computational cost of integrating the instantaneous change of variables (2) is $\\mathcal { O } ( D H \\widehat { L } )$ where $D$ is dimensionality of the data, $H$ is the size of the hidden state, and $\\widehat { L }$ is the number of function evaluations (NFE) that the adaptive solver uses to integrate the ODE. In general, each evaluation of the model is $\\mathcal { O } ( D H )$ and in practice, $H$ is typically chosen to be close to $D$ . Since the general form of the discrete change of variables equation (1) requires $\\mathcal { O } ( D ^ { 3 } )$ -cost, one may wonder whether the number of evaluations $\\widehat { L }$ depends on $D$ . ",
+        "bbox": [
+            174,
+            838,
+            825,
+            928
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We train VAEs using FFJORD flows with increasing latent dimension $D$ . The NFE throughout training is shown in Figure 5. In all models, we find that the NFE increases throughout training, but converges to the same value, independent of $D$ . We conjecture that the number of evaluations is not dependent on the dimensionality of the data but the complexity of its distribution, or more specifically, how difficult it is to transform its density into the base distribution. ",
+        "bbox": [
+            174,
+            103,
+            549,
+            228
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.3 SINGLE-SCALE VS. MULTI-SCALE FFJORD",
+        "text_level": 1,
+        "bbox": [
+            174,
+            251,
+            517,
+            265
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Crucial to the scalability of Real NVP and Glow is the multiscale architecture originally proposed in Dinh et al. (2017). We compare a single-scale encoder-decoder style FFJORD with a multiscale FFJORD on the MNIST dataset where both models have a comparable number of parameters and plot the total NFE–in both forward and backward passes–against the loss achieved in Figure 6. We find that while the single-scale model uses approximately one half as many function evaluations as the multiscale model, it is not able to achieve the same performance as the multiscale model. ",
+        "bbox": [
+            174,
+            279,
+            549,
+            430
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/0062858e8272d5676ba867e22f6633ff8e78e21441e692e039bb10cf152dc6a7.jpg",
+        "image_caption": [
+            "Figure 5: NFE used by the adaptive ODE solver is approximately independent of data-dimension. Lines are smoothed using a Gaussian filter. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            580,
+            74,
+            810,
+            178
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/1cd2619e51c02801395209923fba96f688f591bcf13f63fef7f5450530a63d78.jpg",
+        "image_caption": [
+            "Figure 6: For image data, a single FFJORD flow can achieve near performance to multi-scale architecture while using half the number of evaluations. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            573,
+            265,
+            813,
+            381
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 SCOPE AND LIMITATIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            455,
+            418,
+            472
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Number of function evaluations can be prohibitive. The number of function evaluations required to integrate the dynamics is not fixed ahead of time, and is a function of the data, model architecture, and model parameters. This number tends to grow as the models trains and can become prohibitively large, even when memory stays constant due to the adjoint method. Various forms of regularization such as weight decay and spectral normalization (Miyato et al., 2018) can be used to reduce the this quantity, but their use tends to hurt performance slightly. ",
+        "bbox": [
+            174,
+            489,
+            823,
+            574
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Limitations of general-purpose ODE solvers. In theory, our model can approximate any differential equation (given mild assumptions based on existence and uniqueness of the solution), but in practice our reliance on general-purpose ODE solvers restricts us to non-stiff differential equations that can be efficiently solved. ODE solvers for stiff dynamics exist, but they evaluate $f$ many more times to achieve the same error. We find that a small amount of weight decay regularizes the ODE to be sufficiently non-stiff. ",
+        "bbox": [
+            174,
+            593,
+            825,
+            676
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "7 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            702,
+            318,
+            717
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We have presented FFJORD, a reversible generative model for high-dimensional data which can compute exact log-likelihoods and can be sampled from efficiently. Our model uses continuoustime dynamics to produce a generative model which is parameterized by an unrestricted neural network. All required quantities for training and sampling can be computed using automatic differentiation, Hutchinson’s trace estimator, and black-box ODE solvers. Our model stands in contrast to other methods with similar properties which rely on restricted, hand-engineered neural network architectures. We demonstrated that this additional flexibility allows our approach to achieve on-par or improved performance on density estimation and variational inference. ",
+        "bbox": [
+            174,
+            734,
+            825,
+            847
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We believe there is much room for further work exploring and improving this method. FFJORD is empirically slower to evaluate than other reversible models like Real NVP or Glow, so we are interested specifically in ways to reduce the number of function evaluations used by the ODE-solver without hurting predictive performance. Advancements like these will be crucial in scaling this method to even higher-dimensional datasets. ",
+        "bbox": [
+            176,
+            854,
+            823,
+            922
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "8 ACKNOWLEDGEMENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            398,
+            118
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We thank Yulia Rubanova and Roger Grosse for helpful discussions. ",
+        "bbox": [
+            173,
+            133,
+            620,
+            148
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            170,
+            287,
+            185
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "R. P. Adams, J. Pennington, M. J. Johnson, J. Smith, Y. Ovadia, B. Patton, and J. Saunderson. Estimating the Spectral Density of Large Implicit Matrices. ArXiv e-prints, February 2018. ",
+        "bbox": [
+            176,
+            194,
+            821,
+            223
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Joel Andersson. A general-purpose software framework for dynamic optimization. PhD thesis, 2013. ",
+        "bbox": [
+            176,
+            232,
+            820,
+            248
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Rianne van den Berg, Leonard Hasenclever, Jakub M Tomczak, and Max Welling. Sylvester normalizing flows for variational inference. arXiv preprint arXiv:1803.05649, 2018. ",
+        "bbox": [
+            174,
+            257,
+            818,
+            286
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ricky T. Q. Chen, Yulia Rubanova, Jesse Bettencourt, and David Duvenaud. Neural ordinary differential equations. Advances in Neural Information Processing Systems, 2018. ",
+        "bbox": [
+            173,
+            296,
+            820,
+            325
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Laurent Dinh, David Krueger, and Yoshua Bengio. NICE: Non-linear independent components estimation. International Conference on Learning Representations Workshop, 2014. ",
+        "bbox": [
+            174,
+            334,
+            823,
+            366
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Laurent Dinh, Jascha Sohl-Dickstein, and Samy Bengio. Density estimation using Real NVP. International Conference on Learning Representations, 2017. ",
+        "bbox": [
+            176,
+            375,
+            825,
+            404
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Mathieu Germain, Karol Gregor, Iain Murray, and Hugo Larochelle. Made: Masked autoencoder for distribution estimation. In International Conference on Machine Learning, pp. 881–889, 2015. ",
+        "bbox": [
+            173,
+            412,
+            825,
+            443
+        ],
+        "page_idx": 8
+    },
+    {
+        "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 Advances in neural information processing systems, pp. 2672–2680, 2014. ",
+        "bbox": [
+            173,
+            452,
+            823,
+            496
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Andreas Griewank and Andrea Walther. Evaluating derivatives: principles and techniques of algorithmic differentiation, volume 105. Siam, 2008. ",
+        "bbox": [
+            169,
+            505,
+            823,
+            535
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Chin-Wei Huang, David Krueger, Alexandre Lacoste, and Aaron Courville. Neural autoregressive flows. International Conference on Machine Learning, 2018. ",
+        "bbox": [
+            174,
+            544,
+            823,
+            574
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "M.F. Hutchinson. A stochastic estimator of the trace of the influence matrix for laplacian smoothing splines. 18:1059–1076, 01 1989. ",
+        "bbox": [
+            174,
+            583,
+            823,
+            612
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "H.K. Khalil. Nonlinear Systems. Pearson Education. Prentice Hall, 2002. ",
+        "bbox": [
+            173,
+            622,
+            655,
+            637
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. International Conference on Learning Representations, 2015. ",
+        "bbox": [
+            176,
+            647,
+            823,
+            676
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Diederik P Kingma and Prafulla Dhariwal. Glow: Generative flow with invertible 1x1 convolutions. Advances in Neural Information Processing Systems, 2018. ",
+        "bbox": [
+            174,
+            685,
+            823,
+            715
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Diederik P Kingma and Max Welling. Auto-encoding variational bayes. International Conference on Learning Representations, 2014. ",
+        "bbox": [
+            173,
+            724,
+            825,
+            755
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Diederik P Kingma, Tim Salimans, Rafal Jozefowicz, Xi Chen, Ilya Sutskever, and Max Welling. Improved variational inference with inverse autoregressive flow. In Advances in Neural Information Processing Systems, pp. 4743–4751, 2016. ",
+        "bbox": [
+            173,
+            763,
+            823,
+            808
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Takeru Miyato, Toshiki Kataoka, Masanori Koyama, and Yuichi Yoshida. Spectral normalization for generative adversarial networks. International Conference on Learning Representations, 2018. ",
+        "bbox": [
+            171,
+            816,
+            823,
+            847
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Junier B Oliva, Avinava Dubey, Barnabas P ´ oczos, Jeff Schneider, and Eric P Xing. Transformation ´ autoregressive networks. International Conference on Machine Learning, 2018. ",
+        "bbox": [
+            171,
+            856,
+            823,
+            886
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Aaron van den Oord, Nal Kalchbrenner, and Koray Kavukcuoglu. Pixel recurrent neural networks. International Conference on Machine Learning, 2016. ",
+        "bbox": [
+            174,
+            895,
+            820,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "George Papamakarios, Iain Murray, and Theo Pavlakou. Masked autoregressive flow for density estimation. In Advances in Neural Information Processing Systems, pp. 2338–2347, 2017. ",
+        "bbox": [
+            169,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Lev Semenovich Pontryagin. Mathematical theory of optimal processes. Routledge, 1962. ",
+        "bbox": [
+            173,
+            140,
+            769,
+            157
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Danilo Jimenez Rezende and Shakir Mohamed. Variational inference with normalizing flows. International Conference on Machine Learning, 2015. ",
+        "bbox": [
+            173,
+            165,
+            821,
+            194
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "David E Rumelhart, Geoffrey E Hinton, and Ronald J Williams. Learning representations by backpropagating errors. Nature, 323(6088):533, 1986. ",
+        "bbox": [
+            173,
+            202,
+            823,
+            231
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Lawrence F Shampine. Some practical Runge-Kutta formulas. Mathematics of Computation, 46 (173):135–150, 1986. ",
+        "bbox": [
+            169,
+            241,
+            823,
+            270
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX A QUALITATIVE SAMPLES",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            501,
+            118
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Samples from our FFJORD models trained on MNIST and CIFAR10 can be found in Figure 7. ",
+        "bbox": [
+            173,
+            136,
+            792,
+            151
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/7069f2c96885024f26e2483d05fa76cd504e9adeaf9540d42653e6f44943d89f.jpg",
+        "image_caption": [
+            "Figure 7: Samples and data from our image models. MNIST on left, CIFAR10 on right. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            169,
+            823,
+            621
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX B EXPERIMENTAL DETAILS AND ADDITIONAL RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            679,
+            748,
+            695
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "B.1 DENSITY ESTIMATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            713,
+            374,
+            728
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "On the tabular datasets we performed a grid-search over network architectures. We searched over models with 1, 2, 5, or 10 flows with 1, 2, 3, or 4 hidden layers per flow. Since each dataset has a different number of dimensions, we searched over hidden dimensions equal to 5, 10, or 20 times the data dimension (hidden dimension multiplier in Table 4). We tried both the tanh and softplus nonlinearities. The best performing models can be found in the Table 4. ",
+        "bbox": [
+            174,
+            742,
+            825,
+            811
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "On the image datasets we experimented with two different model architectures; a single flow with an encoder-decoder style architecture and a multiscale architecture composed of multiple flows. ",
+        "bbox": [
+            173,
+            818,
+            823,
+            847
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "While they were able to fit MNIST and obtain competitive performance, the encoder-decoder architectures were unable to fit more complicated image datasets such as CIFAR10 and Street View House Numbers. The architecture for MNIST which obtained the results in Table 2 was composed of four convolutional layers with $6 4 \\to 6 4 \\to 1 2 8 \\to 1 2 8$ filters and down-sampling with strided convolutions by two every other layer. There are then four transpose-convolutional layers who’s filters mirror the first four layers and up-sample by two every other layer. The softplus activation function is used in every layer. ",
+        "bbox": [
+            174,
+            853,
+            823,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "The multiscale architectures were inspired by those presented in Dinh et al. (2017). We compose multiple flows together interspersed with “squeeze” operations which down-sample the spatial resolution of the images and increase the number of channels. These operations are stacked into a “scale block” which contains $N$ flows, a squeeze, then $N$ flows. For MNIST we use 3 scale blocks and for CIFAR10 we use 4 scale blocks and let $N = 2$ for both datasets. Each flow is defined by 3 convolutional layers with 64 filters and a kernel size of 3. The softplus nonlinearity is used in all layers. ",
+        "bbox": [
+            174,
+            138,
+            825,
+            236
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Both models were trained with the Adam optimizer (Kingma & Ba, 2015). We trained for 500 epochs with a learning rate of .001 which was decayed to .0001 after 250 epochs. Training took place on six GPUs and completed after approximately five days. ",
+        "bbox": [
+            176,
+            243,
+            825,
+            285
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "B.2 VARIATIONAL AUTOENCODER ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            335,
+            426,
+            349
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Our experimental procedure exactly mirrors that of Berg et al. (2018). We use the same 7-layer encoder and decoder, learning rate (.001), optimizer (Adam Kingma & Ba (2015)), batch size (100), and early stopping procedure (stop after 100 epochs of no validaiton improvment). The only difference was in the nomralizing flow used in the approximate posterior. ",
+        "bbox": [
+            174,
+            375,
+            825,
+            431
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We performed a grid-search over neural network architectures for the dynamics of FFJORD. We searched over networks with 1 and 2 hidden layers and hidden dimension 512, 1024, and 2048. We used flows with 1, 2, or 5 steps and wight matrix updates of rank 1, 20, and 64. We use the softplus activation function for all datasets except for Caltech Silhouettes where we used tanh. The best performing models can be found in the Table 5. Models were trained on a single GPU and training took between four hours and three days depending on the dataset. ",
+        "bbox": [
+            174,
+            438,
+            825,
+            521
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/df5cb65527b4102df3cd2872ced64c50a7e9f8c473aef67d521426a05f92f3df.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td>nonlinearity</td><td>#layers</td><td>hidden dim multiplier</td><td># flow steps</td><td>batchsize</td></tr><tr><td>POWER</td><td>tanh</td><td>3</td><td>10</td><td>5</td><td>10000</td></tr><tr><td>GAS</td><td>tanh</td><td>3</td><td>20</td><td>5</td><td>1000</td></tr><tr><td>HEPMASS</td><td>softplus</td><td>2</td><td>10</td><td>10</td><td>10000</td></tr><tr><td>MINIBOONE</td><td>softplus</td><td>2</td><td>20</td><td>1</td><td>1000</td></tr><tr><td>BSDS300</td><td> softplus</td><td>3</td><td>20</td><td>2</td><td>10000</td></tr></table>",
+        "bbox": [
+            184,
+            565,
+            812,
+            681
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Table 4: Best performing model architectures for density estimation on tabular data with FFJORD. ",
+        "bbox": [
+            173,
+            691,
+            821,
+            707
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/5ad1aab5ce685306abab09f6703d59096e710d899b7838cc42724a6a5e43df0c.jpg",
+        "table_caption": [
+            "Table 5: Best performing model architectures for VAEs with FFJORD. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td>nonlinearity</td><td># layers</td><td>hidden dimension</td><td>#flow steps</td><td>rank</td></tr><tr><td>MNIST</td><td>softplus</td><td>2</td><td>1024</td><td>2</td><td>64</td></tr><tr><td>Omniglot</td><td>softplus</td><td>2</td><td>512</td><td>5</td><td>20</td></tr><tr><td>Frey Faces</td><td>softplus</td><td>2</td><td>512</td><td>2</td><td>20</td></tr><tr><td>Caltech</td><td>tanh</td><td>1</td><td>2048</td><td>1</td><td>20</td></tr></table>",
+        "bbox": [
+            228,
+            796,
+            769,
+            895
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/edae3d51ae89b8c68cb1e69957429ad9d96783ba1f363ae9ad822bafe701683d.jpg",
+        "table_caption": [
+            "B.3 STANDARD DEVIATIONS FOR TABULAR DENSITY ESTIMATION "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>POWER</td><td>GAS</td><td>HEPMASS</td><td>MINIBOONE</td><td>BSDS300</td></tr><tr><td>Real NVP</td><td>-0.17 ± 0.01</td><td>-8.33 ± 0.14</td><td>18.71 ± 0.02</td><td>13.55 ± 0.49</td><td>-153.28 ± 1.78</td></tr><tr><td>Glow</td><td>-0.17 ± 0.01</td><td>-8.15 ± 0.40</td><td>18.92 ± 0.08</td><td>11.35 ± 0.07</td><td>-155.07 ± 0.03</td></tr><tr><td>FFJORD</td><td>-0.46 ± 0.01</td><td>-8.59 ±0.12</td><td>14.92 ± 0.08</td><td>10.43 ± 0.04</td><td>-157.40 ± 0.19</td></tr><tr><td>MADE</td><td>3.08 ± 0.03</td><td>-3.56 ± 0.04</td><td>20.98 ± 0.02</td><td>15.59 ± 0.50</td><td>-148.85 ± 0.28</td></tr><tr><td>MAF</td><td>-0.24 ± 0.01</td><td>-10.08 ± 0.02</td><td>17.70 ± 0.02</td><td>11.75 ± 0.44</td><td>-155.69 ± 0.28</td></tr><tr><td>TAN</td><td>-0.48 ± 0.01</td><td>-11.19 ± 0.02</td><td>15.12 ± 0.02</td><td>11.01 ± 0.48</td><td>-157.03 ± 0.07</td></tr><tr><td>MAF-DDSF</td><td>-0.62 ± 0.01</td><td>-11.96 ± 0.33</td><td>15.09 ± 0.40</td><td>8.86 ± 0.15</td><td>-157.73 ± 0.04</td></tr></table>",
+        "bbox": [
+            194,
+            133,
+            805,
+            292
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Table 6: Negative log-likehood on test data for density estimation models. Means/stdev over 3 runs. Real NVP, MADE, MAF, TAN, and MAF-DDSF results on are taken from Huang et al. (2018). In reproducing Glow, we were able to get comparable results to the reported Real NVP by removing the invertible fully connected layers. ",
+        "bbox": [
+            173,
+            303,
+            825,
+            359
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX C NUMERICAL ERROR FROM THE ODE SOLVER ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            387,
+            679,
+            405
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "ODE solvers are numerical integration methods so there is error inherent in their outputs. Adaptive solvers (like those used in all of our experiments) attempt to predict the errors that they accrue and modify their step-size to reduce their error below a user set tolerance. It is important to be aware of this error when we use these solvers for density estimation as the solver outputs the density that we report and compare with other methods. When tolerance is too low, we run into machine precision errors. Similarly when tolerance is too high, errors are large, our training objective becomes biased and we can run into divergent training dynamics. ",
+        "bbox": [
+            173,
+            419,
+            825,
+            517
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Since a valid probability density function integrates to one, we take a model trained on Figure 1 and numerically find the area under the curve using Riemann sum and a very fine grid. We do this for a range of tolerance values and show the resulting error in Figure 8. We set both atol and rtol to the same tolerance. ",
+        "bbox": [
+            173,
+            523,
+            825,
+            579
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/02e88a1805109d6d2399eee267e1694fbcf917ec7e51dd627a734ef15382389d.jpg",
+        "image_caption": [
+            "Figure 8: Numerical integration shows that the density under the model does integrate to one given sufficiently low tolerance. Both log and non-log plots are shown. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            192,
+            597,
+            807,
+            729
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The numerical error follows the same order as the tolerance, as expected. During training, we find that the error becomes non-negligible when using tolerance values higher than $\\bar { 1 0 } ^ { - 5 }$ . For most of our experiments, we set tolerance to $1 0 ^ { - 5 }$ as that gives reasonable performance while requiring few number of evaluations. For the tabular experiments, we use atol $= 1 0 ^ { - 8 }$ and $\\mathtt { r t o l } \\mathtt { = } 1 0 ^ { - 6 }$ . ",
+        "bbox": [
+            174,
+            803,
+            825,
+            858
+        ],
+        "page_idx": 12
+    }
+]

parse/train/yWd42CWN3c/yWd42CWN3c.md

@@ -0,0 +1,324 @@
+# Combining Recurrent, Convolutional, and Continuous-time Models with Linear State-Space Layers
+
+Albert $\mathbf { G } \mathbf { u } ^ { \dagger }$ , Isys Johnson‡, Karan Goel†, Khaled Saab∗, Tri Dao†, Atri Rudra‡, Christopher Ré†
+
+† Department of Computer Science, Stanford University ∗ Department of Electrical Engineering, Stanford University ‡ Department of Computer Science and Engineering, University at Buffalo, SUNY {albertgu,knrg,ksaab,trid}@stanford.edu, chrismre@cs.stanford.edu {isysjohn,atri}@buffalo.edu
+
+# Abstract
+
+Recurrent neural networks (RNNs), temporal convolutions, and neural differential equations (NDEs) are popular families of deep learning models for time-series data, each with unique strengths and tradeoffs in modeling power and computational efficiency. We introduce a simple sequence model inspired by control systems that generalizes these approaches while addressing their shortcomings. The Linear State-Space Layer (LSSL) maps a sequence $u \mapsto y$ by simply simulating a linear continuous-time state-space representation ${ \dot { x } } = A x + B u , y = C x + D u$ Theoretically, we show that LSSL models are closely related to the three aforementioned families of models and inherit their strengths. For example, they generalize convolutions to continuous-time, explain common RNN heuristics, and share features of NDEs such as time-scale adaptation. We then incorporate and generalize recent theory on continuous-time memorization to introduce a trainable subset of structured matrices $A$ that endow LSSLs with long-range memory. Empirically, stacking LSSL layers into a simple deep neural network obtains state-of-the-art results across time series benchmarks for long dependencies in sequential image classification, real-world healthcare regression tasks, and speech. On a difficult speech classification task with length-16000 sequences, LSSL outperforms prior approaches by 24 accuracy points, and even outperforms baselines that use handcrafted features on $1 0 0 \mathrm { x }$ shorter sequences.
+
+# 1 Introduction
+
+A longstanding challenge in machine learning is efficiently modeling sequential data longer than a few thousand time steps. The usual paradigms for designing sequence models involve recurrence (e.g. RNNs), convolutions (e.g. CNNs), or differential equations (e.g. NDEs), which each come with tradeoffs. For example, RNNs are a natural stateful model for sequential data that require only constant computation/storage per time step, but are slow to train and suffer from optimization difficulties (e.g., the "vanishing gradient problem" [39]), which empirically limits their ability to handle long sequences. CNNs encode local context and enjoy fast, parallelizable training, but are not sequential, resulting in more expensive inference and an inherent limitation on the context length. NDEs are a principled mathematical model that can theoretically address continuous-time problems and long-term dependencies [37], but are very inefficient.
+
+Ideally, a model family would combine the strengths of these paradigms, providing properties like parallelizable training (convolutional), stateful inference (recurrence) and time-scale adaptation (differential equations), while handling very long sequences in a computationally efficient way. Several recent works have turned to this question. These include the CKConv, which models a continuous convolution kernel [44]; several ODE-inspired RNNs, such as the UnICORNN [47]; the LMU, which speeds up a specific linear recurrence using convolutions [12, 58]; and HiPPO [24], a generalization of the LMU that introduces a theoretical framework for continuous-time memorization. However, these model families come at the price of reduced expressivity: intuitively, a family that is both convolutional and recurrent should be more restrictive than either.
+
+![](images/ea61b96555207397a42570dc9e353cb2fe433bafb6a857f9f99af2dbe77cad26.jpg)  
+Figure 1: (Three views of the LSSL) A Linear State Space Layer layer is a map $u _ { t } \ \in \ \mathbb { R } \ \to \ y _ { t } \ \in \ \mathbb { R }$ , where each feature $u _ { t } \mapsto y _ { t }$ is defined by discretizing a state-space model $A , B , C , D$ with a parameter $\Delta t$ The underlying state space model defines a discrete recurrence through combining the state matrix $A$ and timescale $\Delta t$ into a transition matrix $\overline { { A } }$ . (Left) As an implicit continuous model, irregularly-spaced data can be handled by discretizing the same matrix $A$ using a different timescale $\Delta t$ . (Center) As a recurrent model, inference can be performed efficiently by computing the layer timewise (i.e., one vertical slice at a time $( u _ { t } , x _ { t } , y _ { t } ) , ( u _ { t + 1 } , x _ { t + 1 } , y _ { t + 1 } ) , \dots )$ , by unrolling the linear recurrence. (Right) As a convolutional model, training can be performed efficiently by computing the layer depthwise in parallel (i.e., one horizontal slice at a time $( u _ { t } ) _ { t \in [ L ] } , ( y _ { t } ) _ { t \in [ L ] } , \dots . )$ , by convolving with a particular filter.
+
+Our first goal is to construct an expressive model family that combines all 3 paradigms while preserving their strengths. The Linear State-Space Layer (LSSL) is a simple sequence model that maps a 1-dimensional function or sequence $u ( t ) \mapsto y ( t )$ through an implicit state $x ( t )$ by simulating a linear continuous-time state-space representation in discrete-time
+
+$$
+\begin{array} { l } { \dot { \boldsymbol { x } } ( t ) = \boldsymbol { A } \boldsymbol { x } ( t ) + \boldsymbol { B } \boldsymbol { u } ( t ) } \\ { \boldsymbol { y } ( t ) = \boldsymbol { C } \boldsymbol { x } ( t ) + \boldsymbol { D } \boldsymbol { u } ( t ) , } \end{array}
+$$
+
+where $A$ controls the evolution of the system and $B , C , D$ are projection parameters. The LSSL can be viewed as an instantiation of each family, inheriting their strengths (Fig. 1):
+
+• LSSLs are recurrent. If a discrete step-size $\Delta t$ is specified, the LSSL can be discretized into a linear recurrence using standard techniques, and simulated during inference as a stateful recurrent model with constant memory and computation per time step. • LSSLs are convolutional. The linear time-invariant systems defined by $( 1 ) + ( 2 )$ are known to be explicitly representable as a continuous convolution. Moreover, the discrete-time version can be parallelized during training using convolutions [12, 44]. • LSSLs are continuous-time. The LSSL itself is a differential equation. As such, it can perform unique applications of continuous-time models, such as simulating continuous processes, handling missing data [45], and adapting to different timescales.
+
+Surprisingly, we show that LSSLs do not sacrifice expressivity, and in fact generalize convolutions and RNNs. First, classical results from control theory imply that all 1-D convolutional kernels can be approximated by an LSSL [59]. Additionally, we provide two results relating RNNs and ODEs that may be of broader interest, e.g. showing that some RNN architectural heuristics (such as gating mechanisms) are related to the step-size $\Delta t$ and can actually be derived from ODE approximations. As corollaries of these results, we show that popular RNN methods are special cases of LSSLs.
+
+The generality of LSSLs does come with tradeoffs. In particular, we describe and address two challenges that naive LSSL instantiations face when handling long sequences: (i) they inherit the limitations of both RNNs and CNNs at remembering long dependencies, and (ii) choosing the state matrix $A$ and timescale $\Delta t$ appropriately are critical to their performance, yet learning them is computationally infeasible. We simultaneously address these challenges by specializing LSSLs using a carefully chosen class of structured matrices $A$ , such that (i) these matrices generalize prior work on continuous-time memory [24] and mathematically capture long dependencies with respect to a learnable family of measures, and (ii) with new algorithms, LSSLs with these matrices $A$ can be theoretically sped up under certain computation models, even while learning the measure $A$ and timescale $\Delta t$ .
+
+We empirically validate that LSSLs are widely effective on benchmark datasets and very long time series from healthcare sensor data, images, and speech.
+
+• On benchmark datasets, LSSLs obtain SoTA over recent RNN, CNN, and NDE-based methods across sequential image classification tasks (e.g., by over $10 \%$ accuracy on sequential CIFAR) and healthcare regression tasks with length-4000 time series (by up to $80 \%$ reduction in RMSE). • To showcase the potential of LSSLs to unlock applications with extremely long sequences, we introduce a new sequential CelebA classification task with length-38000 sequences. A small LSSL comes within 2.16 accuracy points of a specialized ResNet-18 vision architecture that has $1 0 \mathrm { x }$ more parameters and is trained directly on images. • Finally, we test LSSLs on a difficult dataset of high-resolution speech clips, where usual speech pipelines pre-process the signals to reduce the length by $1 0 0 \mathrm { x }$ . When training on the raw length16000 signals, the LSSL not only (i) outperforms previous methods by over 20 accuracy points in 1/5 the training time, but (ii) outperforms all baselines that use the pre-processed length-160 sequences, overcoming the limitations of hand-crafted feature engineering.
+
+# Summary of Contributions
+
+• We introduce Linear State-Space Layers (LSSLs), a simple sequence-to-sequence transformation that shares the modeling advantages of recurrent, convolutional, and continuous-time methods. Conversely, we show that RNNs and CNNs can be seen as special cases of LSSLs (Section 3).
+
+• We prove that a structured subclass of LSSLs can learn representations that solve continuous-time memorization, allowing it to adapt its measure and timescale (Section 4.1). We also provide new algorithms for these LSSLs, showing that they can be sped up computationally under an arithmetic complexity model Section 4.2.
+
+• Empirically, we show that LSSLs stacked into a deep neural network are widely effective on time series data, even (or especially) on extremely long sequences (Section 5).
+
+# 2 Technical Background
+
+We summarize the preliminaries on differential equations that are necessary for this work. We first introduce two standard approximation schemes for differential equations that we will use to convert continuous-time models to discrete-time, and will be used in our results on understanding RNNs. We give further context on the step size or timescale $\Delta t$ , which is a particularly important parameter involved in this approximation process. Finally, we provide a summary of the HiPPO framework for continuous-time memorization [24], which will give us a mathematical tool for constructing LSSLs that can address long-term dependencies.
+
+Approximations of differential equations. Any differential equation ${ \dot { x } } ( t ) = f ( t , x ( t ) )$ has an equivalent integral equation $\begin{array} { r } { x ( t ) = x ( t _ { 0 } ) + \int _ { t _ { 0 } } ^ { t } f ( s , x ( s ) ) d s } \end{array}$ . This can be numerically solved by storing some approximation for $x$ , and keeping it fixed inside $f ( t , x )$ while iterating the equation. For example, Picard iteration is often used to prove the existence of solutions to ODEs by iterating the equation $\begin{array} { r } { x _ { i + 1 } ( t ) : = x _ { i } ( t _ { 0 } ) + \int _ { t _ { 0 } } ^ { t } f ( s , x _ { i } ( s ) ) d s } \end{array}$ . In other words, it finds a sequence of functions $x _ { 0 } ( t ) , x _ { 1 } ( t ) , \ldots$ that approximate the solution $x ( t )$ of the integral equation.
+
+Discretization. On the other hand, for a desired sequence of discrete times $t _ { i }$ , approximations to $x ( t _ { 0 } ) , x ( t _ { 1 } ) , \ldots$ can be found by iterating the equation $\begin{array} { r } { x ( t _ { i + 1 } ) = x ( t _ { i } ) + \int _ { t _ { i } } ^ { t _ { i + 1 } } f ( s , x ( s ) ) d s } \end{array}$ Different ways of approximating the RHS integral lead to different discretization schemes. We single out a discretization method called the generalized bilinear transform (GBT) which is specialized to linear ODEs of the form (1). Given a step size $\Delta t$ , the GBT update is
+
+$$
+x ( t + \Delta t ) = ( I - \alpha \Delta t \cdot A ) ^ { - 1 } ( I + ( 1 - \alpha ) \Delta t \cdot A ) x ( t ) + \Delta t ( I - \alpha \Delta t \cdot A ) ^ { - 1 } B \cdot u ( t ) .
+$$
+
+Three important cases are: $\alpha = 0$ becomes the classic Euler method which is simply the first-order approximation $x ( t + \Delta t ) = x ( t ) + \Delta t \cdot x ^ { \prime } ( t )$ ; $\alpha = 1$ is called the backward Euler method; and $\begin{array} { r } { \dot { \alpha } = \frac { 1 } { 2 } } \end{array}$ is called the bilinear method, which preserves the stability of the system [61].
+
+In Section 3.2 we will show that the backward Euler method and Picard iteration are actually related to RNNs. On the other hand, the bilinear discretization will be our main method for computing accurate discrete-time approximations of our continuous-time models. In particular, define $\overline { { A } }$ and $\overline { B }$ to be the matrices appearing in (3) for $\begin{array} { r } { \alpha = \frac { 1 } { 2 } } \end{array}$ . Then the discrete-time state-space model is
+
+$$
+\begin{array} { l } { { x _ { t } = \overline { { A } } x _ { t - 1 } + \overline { { B } } u _ { t } } } \\ { { y _ { t } = C x _ { t } + D u _ { t } . } } \end{array}
+$$
+
+$\Delta t$ as a timescale. In most models, the length of dependencies they can capture is roughly proportional to $\frac { 1 } { \Delta t }$ . Thus we also refer to the step size $\Delta t$ as a timescale. This is an intrinsic part of converting a continuous-time ODE into a discrete-time recurrence, and most ODE-based RNN models have it as an important and non-trainable hyperparameter [24, 47, 58]. On the other hand, in Section 3.2 we show that the gating mechanism of classical RNNs is a version of learning $\Delta t$ . Moreover when viewed as a CNN, the timescale $\Delta t$ can be viewed as controlling the width of the convolution kernel (Section 3.2). Ideally, all ODE-based sequence models would be able to automatically learn the proper timescales.
+
+Continuous-time memory. Consider an input function $u ( t )$ , a fixed probability measure $\omega ( t )$ , and a sequence of $N$ basis functions such as polynomials. At every time $t$ , the history of $u$ before time $t$ can be projected onto this basis, which yields a vector of coefficients $\boldsymbol { x } ( t ) \in \mathbb { R } ^ { \tilde { N } }$ that represents an optimal approximation of the history of $u$ with respect to the provided measure $\omega$ . The map taking the function $u ( t ) \in \mathbb { R }$ to coefficients $\boldsymbol { x } ( t ) \in \mathbb { R } ^ { N }$ is called the High-Order Polynomial Projection Operator (HiPPO) with respect to the measure $\omega$ . In special cases such as the uniform measure $\omega = \mathbb { I } \{ [ 0 , 1 ] \}$ and the exponentially-decaying measure $\omega ( t ) = \exp ( - t )$ , Gu et al. [24] showed that $x ( t )$ satisfies a differential equation ${ \dot { x } } ( t ) = A ( t ) x ( t ) + B ( t ) u ( t )$ (i.e., (1)) and derived closed forms for the matrix $A$ . Their framework provides a principled way to design memory models handling long dependencies; however, they prove only these few special cases.
+
+# 3 Linear State-Space Layers (LSSL)
+
+We define our main abstraction, a model family that generalizes recurrence and convolutions. Section 3.1 first formally defines the LSSL, then discusses how to compute it with multiple views. Conversely, Section 3.2 shows that LSSLs are related to mechanisms of the most popular RNNs.
+
+# 3.1 Different Views of the LSSL
+
+Given a fixed state space representation $A , B , C , D$ , an LSSL is the sequence-to-sequence mapping defined by discretizing the linear state-space model (1) and (2).
+
+Concretely, an LSSL layer has parameters $A , B , C , D$ , and $\Delta t$ . It operates on an input $\boldsymbol { u } \in \mathbb { R } ^ { L \times H }$ represefeature equence of length  defines a sequenc $L$ h timestep has an , which is combin $H$ -dimensional fea with a timescale vector. Eachto define an $h \in [ H ]$ $( u _ { t } ^ { ( h ) } ) _ { t \in [ L ] }$ $\Delta t _ { h }$ output $\boldsymbol { y } ^ { ( h ) } \in \mathbb { R } ^ { L }$ via the discretized state-space model (4)+(5).
+
+Computationally, the discrete-time LSSL can be viewed in multiple ways (Fig. 1).
+
+As a recurrence. The recurrent state $\boldsymbol { x } _ { t - 1 } \in \mathbb { R } ^ { H \times N }$ carries the context of all inputs before time $t$ The current state $x _ { t }$ and output $y _ { t }$ can be computed by simply following equations $( 4 ) + ( 5 )$ . Thus the LSSL is a recurrent model with efficient and stateful inference, which can consume a (potentially unbounded) sequence of inputs while requiring fixed computation/storage per time step.
+
+As a convolution. For simplicity let the initial state be $x _ { - 1 } = 0$ . Then $( 4 ) + ( 5 )$ explicitly yields
+
+$$
+y _ { k } = C \left( \overline { { A } } \right) ^ { k } \overline { { B } } u _ { 0 } + C \left( \overline { { A } } \right) ^ { k - 1 } \overline { { B } } u _ { 1 } + \cdot \cdot \cdot + C \overline { { A } } \overline { { B } } u _ { k - 1 } + \overline { { B } } u _ { k } + D u _ { k } .
+$$
+
+Then $y$ is simply the (non-circular) convolution $y = \mathcal { K } _ { L } ( \overline { { A } } , \overline { { B } } , C ) \ast u + D u$ , where
+
+$$
+{ \mathcal { K } } _ { L } ( A , B , C ) = \left( C A ^ { i } B \right) _ { i \in [ L ] } \in \mathbb { R } ^ { L } = ( C B , C A B , \ldots , C A ^ { L - 1 } B ) .
+$$
+
+Thus the LSSL can be viewed as a convolutional model where the entire output $y \in \mathbb { R } ^ { H \times L }$ can be computed at once by a convolution, which can be efficiently implemented with three FFTs.
+
+The computational bottleneck. We make a note that the bottleneck of (i) the recurrence view is matrix-vector multiplication (MVM) by the discretized state matrix $\overline { { A } }$ when simulating (4), and (ii) the convolutional view is computing the Krylov function $\kappa _ { L }$ (7). Throughout this section we assumed the LSSL parameters were fixed, which means that $\overline { { A } }$ and $\mathcal { K } _ { L } ( A , B , C )$ can be cached for efficiency. However, learning the parameters $\overline { { A } }$ and $\Delta t$ would involve repeatedly re-computing these, which is infeasible in practice. We revisit and solve this problem in Section 4.2.
+
+# 3.2 Expressivity of LSSLs
+
+For a model to be both recurrent and convolutional, one might expect it to be limited in other ways. Indeed, while [12, 44] also observe that certain recurrences can be replaced with a convolution, they note that it is not obvious if convolutions can be replaced by recurrences. Moreover, while the LSSL is a linear recurrence, popular RNN models are nonlinear sequence models with activation functions between each time step. We now show that LSSLs surprisingly do not have limited expressivity.
+
+Convolutions are LSSLs. A well-known fact about state-space systems $( 1 ) + ( 2 )$ is that the output $y$ is related to the input $u$ by a convolution $\begin{array} { r } { y ( t ) = \int h ( \tau ) u ( \bar { t } - \tau ) \dot { d } \tau } \end{array}$ with the impulse response $h$ of the system. Conversely, a convolutional filter $h$ that is a rational function of degree $N$ can be represented by a state-space model of size $N$ [59]. Thus, an arbitrary convolutional filter $h$ can be approximated by a rational function (e.g., by Padé approximants) and represented by an LSSL.
+
+In the particular case of LSSLs with HiPPO matrices (Sections 2 and 4.1), there is another intuitive interpretation of how LSSL relate to convolutions. Consider the special case when $A$ corresponds to a uniform measure (in the literature known as the LMU [58] or HiPPO-LegT [24] matrix). Then for a fixed $d t$ , equation (1) is simply memorizing the input within sliding windows of $\frac { 1 } { \Delta t }$ elements, and equation (2) extracts features from this window. Thus the LSSL can be interpreted as automatically learning convolution filters with a learnable kernel width.
+
+RNNs are LSSLs. We show two results about RNNs that may be of broader interest. Our first result says that the ubiquitous gating mechanism of RNNs, commonly perceived as a heuristic to smooth optimization [28], is actually the analog of a step size or timescale $\Delta t$ .
+
+Lemma 3.1. A (1-D) gated recurrence $x _ { t } = ( 1 - \sigma ( z ) ) x _ { t - 1 } + \sigma ( z ) u _ { t }$ , where $\sigma$ is the sigmoid function and $z$ is an arbitrary expression, can be viewed as the $G B T ( \alpha = 1 ,$ ) (i.e., backwards-Euler) discretization of a 1-D linear ODE ${ \dot { x } } ( t ) = - x ( t ) + u ( t )$ .
+
+Proof. Applying a discretization requires a positive step size $\Delta t$ . The simplest way to parameterize a positive function is via the exponential function $\Delta t = \exp ( z )$ applied to any expression $z$ . Substituting this into (3) with $A = - 1 , B = 1 , \alpha = 1$ exactly produces the gated recurrence. □
+
+While Lemma 3.1 involves approximating continuous systems using discretization, the second result is about approximating them using Picard iteration (Section 2). Roughly speaking, each layer of a deep linear RNN can be viewed as successive Picard iterates $x _ { 0 } ( t ) , x _ { 1 } ( t ) , \ldots$ approximating a function $x ( t )$ defined by a non-linear ODE. This shows that we do not lose modeling power by using linear instead of non-linear recurrences, and that the nonlinearity can instead be “moved” to the depth direction of deep neural networks to improve speed without sacrificing expressivity.
+
+Lemma 3.2. (Infinitely) deep stacked LSSL layers of order $N = 1$ with position-wise non-linear functions can approximate any non-linear ODE $\dot { x } ( t ) = - x + f ( t , x ( t ) )$ .
+
+We note that many of the most popular and effective RNN variants such as the LSTM [28], GRU [14], QRNN [5], and SRU [33], involve a hidden state $\boldsymbol { x } _ { t } \in \mathbb { R } ^ { H }$ that involves independently “gating” the $H$ hidden units. Applying Lemma 3.1, they actually also approximate an ODE of the form in Lemma 3.2. Thus LSSLs and these popular RNN models can be seen to all approximate the same type of underlying continuous dynamics, by using Picard approximations in the depth direction and discretization (gates) in the time direction. Appendix C gives precise statements and proofs.
+
+# 3.3 Deep LSSLs
+
+The basic LSSL is defined as a sequence-to-sequence map from $\mathbb { R } ^ { L } \to \mathbb { R } ^ { L }$ on 1D sequences of length $L$ , parameterized by parameters $A \in \mathbb { R } ^ { \tilde { N } \times N } , B \in \hat { \mathbb { R } } ^ { N \times 1 } , C \in \mathbb { R } ^ { 1 \times N } , D \in \mathbb { R } ^ { 1 \times \hat { 1 } } , \Delta t \in \mathbb { R } .$ Given an input sequence with hidden dimension $H$ (in other words a feature dimension greater than 1), we simply broadcast the parameters $B , C , D , \Delta t$ with an extra dimension $H$ . Each of these $H$ copies is learned independently, so that there are $H$ different versions of a 1D LSSL processing each of the input features independently. Overall, the standalone LSSL layer is a sequence-to-sequence map with the same interface as standard sequence model layers such as RNNs, CNNs, and Transformers.
+
+The full LSSL architecture in a deep neural network is defined similarly to standard sequence models such as deep ResNets and Transformers, involving stacking LSSL layers connected with normalization layers and residual connections. Full architecture details are described in Appendix B, including the initialization of $A$ and $\Delta t$ , computational details, and other architectural details.
+
+# 4 Combining LSSLs with Continuous-time Memorization
+
+In Section 3 we introduced the LSSL model and showed that it shares the strengths of convolutions and recurrences while also generalizing them. We now discuss and address its main limitations, in particular handling long dependencies (Section 4.1) and efficient computation (Section 4.2).
+
+# 4.1 Incorporating Long Dependencies into LSSLs
+
+The generality of LSSLs means they can inherit the issues of recurrences and convolutions at addressing long dependencies (Section 1). For example, viewed as a recurrence, repeated multiplication by $\overline { { A } }$ could suffer from the vanishing gradients problem [39, 44]. We confirm empirically that LSSLs with random state matrices $A$ are actually not effective (Section 5.4) as a generic sequence model.
+
+However, one advantage of these mathematical continuous-time models is that they are theoretically analyzable, and specific $A$ matrices can be derived to address this issue. In particular, the HiPPO framework (Section 2) describes how to memorize a function in continuous time with respect to a measure $\omega$ [24]. This operator mapping a function to a continuous representation of its past is denoted hippo $( \omega )$ , and was shown to have the form of equation (1) in three special cases. However, these matrices are non-trainable in the sense that no other $A$ matrices were known to be hippo operators.
+
+To address this, we theoretically resolve the open question from [24], showing that hippo $( \omega )$ for any measure $\omega ^ { \mathrm { ~ 1 ~ } }$ results in (1) with a structured matrix $A$ .
+
+Theorem 1 (Informal). For an arbitrary measure $\omega$ , the optimal memorization operator hippo $( \omega )$ has the form ${ \dot { x } } ( t ) = A x ( t ) + B u ( t )$ (1) for $a$ low recurrence-width (LRW) [17] state matrix A.
+
+For measures covering the classical orthogonal polynomials (OPs) [52] (in particular, corresponding to Jacobi and Laguerre polynomials), there is even more structure.
+
+Corollary 4.1. For $\omega$ corresponding to the classical $O P s ,$ , hippo $( \omega )$ is 3-quasiseparable.
+
+Although beyond the scope of this section, we mention that LRW matrices are a type of structured matrix that have linear MVM [17]. In Appendix $\mathrm { D }$ we define this class and prove Theorem 1. Quasi
+
+separable matrices are a related class of structured matrices with additional algorithmic properties.   
+We define these matrices in Definition 4 and prove Corollary 4.1 in Appendix D.3.
+
+Theorem 1 tells us that a LSSL that uses a state matrix $A$ within a particular class of structured matrices would carry the theoretical interpretation of continuous-time memorization. Ideally, we would be able to automatically learn the best $A$ within this class; however, this runs into computational challenges which we address next (Section 4.2). For now, we define the LSSL-fixed or LSSL-f to be one where the $A$ matrix is fixed to one of the HiPPO matrices prescribed by [24].
+
+# 4.2 Theoretically Efficient Algorithms for the LSSL
+
+Although $A$ and $\Delta t$ are the most critical parameters of an LSSL which govern the state-space (c.f. Section 4.1) and timescale (Sections 2 and 3.2), they are not feasible to train in a naive LSSL. In particular, Section 3.1 noted that it would require efficient matrix-vector multiplication (MVM) and Krylov function (7) for $\overline { { A } }$ to compute the recurrent and convolutional views, respectively. However, the former seems to involve a matrix inversion (3), while the latter seems to require powering $\overline { { A } }$ up $L$ times.
+
+In this section, we show that the same restriction of $A$ to the class of quasiseparable (Corollary 4.1), which gives an LSSL the ability to theoretically remember long dependencies, simultaneously grants it computational efficiency.
+
+First of all, it is known that quasiseparable matrices have efficient (linear-time) MVM [40]. We show that they also have fast Krylov functions, allowing efficient training with convolutions.
+
+Theorem 2. For any $k$ -quasiseparable matrix $A$ (with constant $k$ ) and arbitrary $B , C _ { i }$ , the Krylov function $\mathcal { K } _ { L } ( A , B , C )$ can be computed in quasi-linear time and space $\tilde { O } ( N + L )$ and logarithmic depth (i.e., is parallelizable). The operation count is in an exact arithmetic model, not accounting for bit complexity or numerical stability.
+
+We remark that Theorem 2 is non-obvious. To illustrate, it is easy to see that unrolling (7) for a general matrix $A$ takes time $L N ^ { 2 }$ . Even if $A$ is extremely structured with linear computation, it requires $L N$ operations and linear depth. The depth can be reduced with the squaring technique (batch multiply by ${ \bar { A } } , A ^ { 2 } , A ^ { 4 } , \ldots )$ , but this then requires $L N$ intermediate storage. In fact, the algorithm for Theorem 2 is quite sophisticated (Appendix E) and involves a divide-and-conquer recursion over matrices of polynomials, using the observation that (7) is related to the power series $C ( I - A x ) ^ { - 1 } B$ .
+
+Unless specified otherwise, the full LSSL refers to an LSSL with $A$ satisfying Corollary 4.1. In conclusion, learning within this structured matrix family simultaneously endows LSSLs with longrange memory through Theorem 1 and is theoretically computationally feasible through Theorem 2. We note the caveat that Theorem 2 is over exact arithmetic and not floating point numbers, and thus is treated more as a proof of concept that LSSLs can be computationally efficient in theory. We comment more on the limitations of the LSSL in Section 6.
+
+# 5 Empirical Evaluation
+
+We test LSSLs empirically on a range of time series datasets with sequences from length 160 up to 38000 (Sections 5.1 and 5.2), where they substantially improve over prior work. We additionally validate the computational and modeling benefits of LSSLs from generalizing all three main model families (Section 5.3), and analyze the benefits of incorporating principled memory representations that can be learned (Section 5.4).
+
+Baselines. Our tasks have extensive prior work and we evaluate against previously reported best results. We highlight our primary baselines, three very recent works explicitly designed for long sequences: CKConv (a continuous-time CNN) [44], UnICORNN (an ODE-inspired RNN) [47], and Neural Controlled/Rough Differential Equations (NCDE/NRDE) (a sophisticated NDE) [31, 37]. These are the only models we are aware of that have experimented with sequences of length ${ \mathrm { > } } 1 0 \mathrm { k }$ .
+
+# 5.1 Image and Time Series Benchmarks
+
+Table 1: (Pixel-by-pixel image classification.) (Top) our methods. (Middle) recurrent baselines. (Bottom) convolutional $^ +$ other baselines.   
+
+<table><tr><td>Model</td><td>sMNIST</td><td>pMNIST</td><td>sCIFAR</td></tr><tr><td>LSSL</td><td>99.53</td><td>98.76</td><td>84.65</td></tr><tr><td>LSSL-fixed</td><td>99.50</td><td>98.60</td><td>81.97</td></tr><tr><td>LipschitzRNN</td><td>99.4</td><td>96.3</td><td>64.2</td></tr><tr><td>LMUFFT[12]</td><td>-</td><td>98.49</td><td>-</td></tr><tr><td>UNIcoRNN [47]</td><td>=</td><td>98.4</td><td>1</td></tr><tr><td>HiPPO-RNN [24]</td><td>98.9</td><td>98.3</td><td>61.1</td></tr><tr><td>URGRU [25]</td><td>99.27</td><td>96.51</td><td>74.4</td></tr><tr><td>IndRNN [34]</td><td>99.0</td><td>96.0</td><td>1</td></tr><tr><td>Dilated RNN [8]</td><td>98.0</td><td>96.1</td><td>=</td></tr><tr><td>r-LSTM [56]</td><td>98.4</td><td>95.2</td><td>72.2</td></tr><tr><td>CKConv [44]</td><td>99.32</td><td>98.54</td><td>63.74</td></tr><tr><td>TrellisNet [4]</td><td>99.20</td><td>98.13</td><td>73.42</td></tr><tr><td>TCN [3]</td><td>99.0</td><td>97.2</td><td>1</td></tr><tr><td>Transformer [56]</td><td>98.9</td><td>97.9</td><td>62.2</td></tr></table>
+
+Table 2: (Vital signs prediction.) RMSE for predicting respiratory rate (RR), heart rate (HR), and blood oxygen (SpO2). \* indicates our own runs to complete results for the strongest baselines.   
+
+<table><tr><td>Model</td><td>RR</td><td>HR</td><td>SpO2</td></tr><tr><td>LSSL</td><td>0.350</td><td>0.432</td><td>0.141</td></tr><tr><td>LSSL-fixed</td><td>0.378</td><td>0.561</td><td>0.221</td></tr><tr><td>UnICORNN [47]</td><td>1.06</td><td>1.39</td><td>0.869*</td></tr><tr><td>coRNN [47]</td><td>1.45</td><td>1.81</td><td>-</td></tr><tr><td>CKConv</td><td>1.214*</td><td>2.05*</td><td>1.051*</td></tr><tr><td>NRDE [37]</td><td>1.49</td><td>2.97</td><td>1.29</td></tr><tr><td>IndRNN [47]</td><td>1.47</td><td>2.1</td><td>-</td></tr><tr><td>expRNN [47]</td><td>1.57</td><td>1.87</td><td>-</td></tr><tr><td>LSTM</td><td>2.28</td><td>10.7</td><td>=</td></tr><tr><td>Transformer</td><td>2.61*</td><td>12.2*</td><td>3.02*</td></tr><tr><td>XGBoost [55]</td><td>1.67</td><td>4.72</td><td>1.52</td></tr><tr><td>Random Forest [55]</td><td>1.85</td><td>5.69</td><td>1.74</td></tr><tr><td>Ridge Regress. [55]</td><td>3.86</td><td>17.3</td><td>4.16</td></tr></table>
+
+Table 3: (Sequential CelebA Classification.)   
+
+<table><tr><td colspan="2">LSSL-f ResNet</td></tr><tr><td>Att.</td><td>78.89 81.35</td></tr><tr><td>MSO 92.36</td><td>93.92</td></tr><tr><td>Smil.</td><td>90.95 92.89</td></tr><tr><td>WL</td><td>90.57 93.25</td></tr></table>
+
+We test on the sequential MNIST, permuted MNIST, and sequential CIFAR tasks (Table 1), popular benchmarks which were originally designed to test the ability of recurrent models to capture long-term dependencies of length up to 1k [2]. LSSL sets SoTA on sCIFAR by more than 10 points. We note that all results were achieved with at least 5x fewer parameters than the previous SoTA (Appendix F).
+
+We additionally use the BDIMC healthcare datasets (Table 2), a suite of widely studied time series regression problems of length 4000 on estimating vital signs. LSSL reduces RMSE by more than two-thirds on all datasets.
+
+# 5.2 Speech and Image Classification for Very Long Time Series
+
+Raw speech is challenging for ML models due to high-frequency sampling resulting in very long sequences. Traditional systems involve complex pipelines that require feeding mixed-and-matched hand-crafted features into DNNs [42]. Table 4 reports results for the Speech Commands (SC) dataset [31] for classification of 1-second audio clips. Few methods have made progress on the raw speech signal, instead requiring pre-processing with standard mel-frequency cepstrum coefficients (MFCC). By contrast, LSSL sets SoTA on this dataset while training on the raw signal. We note that MFCC extracts sliding window frequency coefficients and thus is related to the coefficients $x ( t )$ defined by LSSL-f (Section 2, Section 4.1, [24], Appendix D). Consequently, LSSL may be interpreted as automatically learning MFCC-type features in a trainable basis.
+
+To stress-test the LSSL’s ability to handle extremely long sequences, we create a challenging new sequential-CelebA task, where we classify $1 7 8 \times 2 1 8$ images $\mathbf { \mu } = 3 8 0 0 0$ -length sequences for 4 facial attributes: Attractive (Att.), Mouth Slightly Open (MSO), Smiling (Smil.), Wearing Lipstick (WL) [36]. We chose the 4 most class-balanced attributes to avoid well-known problems with class imbalance. LSSL-f comes close to matching the performance of a specialized ResNet-18 image classification architecture that has $1 0 \times$ the parameters (Table 3). We emphasize we are the first to demonstrate that this is possible to do with a generic sequence model.
+
+# 5.3 Advantages of Recurrent, Convolutional, and Continuous-time Models
+
+We validate that the generality of LSSLs endows it with the strengths of all three families.
+
+Convergence Speed. As a recurrent and NDE model that incorporates new theory for continuoustime memory (Section 4.1), the LSSL has strong inductive bias for sequential data, and converges rapidly to SoTA results on our benchmarks. With its convolutional view, training can be parallelized and it is also computationally efficient in practice. Table 5 compares the time it takes the LSSL-f to achieve SoTA, in either sample (measured by epochs) or computational (measured by wall clock) complexity. In all cases, LSSLs reached the target in a fraction of the time of the previous model.
+
+Table 4: (Raw Speech Classification; Timescale Shift.) (Top): Raw signals (length 16000); $1  f$ indicates test-time change in sampling rate by a factor of $f$ . (Bottom): Pre-processed MFCC features used in prior work (length 161). $\pmb { \chi }$ denotes computationally infeasible.   
+
+<table><tr><td></td><td>LSSL</td><td>LSSL-f</td><td>CKConv</td><td>UnICORNN</td><td>N(C/R)DE</td><td>ODE-RNN [45]</td><td>GRU-ODE [16]</td></tr><tr><td>1→1</td><td>95.87</td><td>90.64</td><td>71.66</td><td>11.02</td><td>16.49</td><td>X</td><td>X</td></tr><tr><td>1</td><td>88.66</td><td>78.01</td><td>65.96</td><td>11.07</td><td>15.12</td><td>X</td><td>X</td></tr><tr><td>MFCC</td><td>93.58</td><td>92.55</td><td>95.3</td><td>90.64</td><td>89.8</td><td>65.9</td><td>47.9</td></tr></table>
+
+Table 5: (Modeling and Computational Benefits of LSSLs.) In each benchmark category, we compare the number of epochs (ep.) it takes a LSSL-f to reach the previous SoTA (PSoTA) results as well as a near-SoTA target. We also report the wall clock time it took to reach PSoTA relative to the previous best model.   
+
+<table><tr><td></td><td colspan="3">Permuted MNIST</td><td colspan="3">BDIMC Heart Rate</td><td colspan="3">Speech Commands RAW</td></tr><tr><td></td><td>98% Acc.</td><td>PSoTA</td><td>Time</td><td>1.5 RMSE</td><td>PSoTA</td><td>Time</td><td>65% Acc.</td><td>PSoTA</td><td>Time</td></tr><tr><td>LSSL-fixed</td><td>16 ep.</td><td>104 ep.</td><td>0.19×</td><td>9ep.</td><td>10 ep.</td><td>0.07×</td><td>9ep.</td><td>10 ep.</td><td>0.14×</td></tr><tr><td>CKConv</td><td>118ep.</td><td>200ep.</td><td>1.0×</td><td>X</td><td>X</td><td>X</td><td>188 ep.</td><td>280ep.</td><td>1.0×</td></tr><tr><td>UnICORNN</td><td>75 ep.</td><td>×</td><td>×</td><td>116 ep.</td><td>467 ep.</td><td>1.0×</td><td>X</td><td>×</td><td>X</td></tr></table>
+
+Timescale Adaptation. Table 4 also reports the results of continuous-time models that are able to handle unique settings such as missing data in time series, or test-time shift in timescale (we note that this is a realistic problem, e.g., when deployed healthcare models are tested on EEG signals that are sampled at a different rate [48, 49]). We note that many of these baselines were custom designed for such settings, which is of independent interest. On the other hand, LSSLs perform timescale adaptation by simply changing its $\Delta t$ values at inference time, while still outperforming the performance of prior methods with no shift. Additional results on the CharacterTrajectories dataset from prior work [31, 44] are in Appendix F, where LSSL is competitive with the best baselines.
+
+# 5.4 LSSL Ablations: Learning the Memory Dynamics and Timescale
+
+We demonstrate that the $\Delta t$ and $A$ parameters, which LSSLs are able to automatically learn in contrast to prior work, are indeed critical to the performance of these continuous-time models. We note that learning $\Delta t$ adds only $O ( H )$ parameters and learning $A$ adds $O ( N )$ parameters, adding less than $1 \%$ parameter count compared to the base models with $O ( H N )$ parameters.
+
+Memory dynamics $A$ . We validate that vanilla LSSLs suffer from the modeling issues described in Section 4. We tested that LSSLs with random $A$ matrices (normalized appropriately) perform very poorly (e.g., $62 \%$ on pMNIST). Further, we note the consistent increase in performance from LSSL-f to LSSL despite the negligible parameter difference. These ablations show that (i) incorporating the theory of Theorem 1 is actually necessary for LSSLs, and (ii) further training the structured $A$ is additionally helpful, which can be interpreted as learning the measure for memorization (Section 4.1).
+
+Timescale $\Delta t$ . Section 3.2 showed that LSSL’s ability to learn $\Delta t$ is its direct generalization of the critical gating mechanism of popular RNNs, which previous ODE-based RNN models [12, 24, 47, 58] cannot learn. We note that on sCIFAR, LSSL-f with poorly-specified $\Delta t$ gets only $4 9 . 3 \%$ accuracy. Additional results in Appendix F show that learning $\Delta t$ alone provides an orthogonal boost to learning $A$ , and visualizes the noticeable change in $\Delta t$ over the course of training.
+
+# 6 Discussion
+
+In this work we introduced a simple and principled model (LSSL) inspired by a fundamental representation of physical systems. We showed theoretically and empirically that it generalizes and inherits the strengths of the main families of modern time series models, that its main limitations of long-term memory can be resolved with new theory on continuous-time memorization, and that it is empirically effective on difficult tasks with very long sequences.
+
+Related work. The LSSL is related to several rich lines of work on recurrent, convolutional, and continuous-time models, as well as sequence models addressing long dependencies. Appendix A provides an extended related work connecting these topics.
+
+Tuning. Our models are very simple, consisting of identical L(inear)SSL layers with simple positionwise non-linear modules between layers (Appendix B). Our models were able to train at much higher learning rates than baselines and were not sensitive to hyperparameters, of which we did light tuning primarily on learning rate and dropout. In contrast to previous baselines [4, 31, 44], we did not use hyperparameters for improving stability and regularization such as weight decay, gradient clipping, weight norm, input dropout, etc. While the most competitive recent works introduce at least one hyperparameter of critical importance (e.g. depth and step size [37], $\alpha$ and $\Delta t$ [47], $\omega _ { 0 }$ [44]) that are difficult to tune, the LSSL-fixed has only $\Delta t$ , which the full LSSL can even learn automatically (at the expense of speed).
+
+Limitations. Sections 1 and 3 and Fig. 1 mention that a potential benefit of having the recurrent representation of LSSLs may endow it with efficient inference. While this is theoretically possible, this work did not experiment on any applications that leverage this. Follow-up work showed that it is indeed possible in practice to speed up some applications at inference time.
+
+Theorem 2’s algorithm is sophisticated (Appendix D) and was not implemented in the first version of this work. A follow-up to this paper found that it is not numerically stable and thus not usable on hardware. Thus the algorithmic contributions in Theorem 2 serve the purpose of a proof-of-concept that fast algorithms for the LSSL do exist in other computation models (i.e., arithmetic operations instead of floating point operations), and leave an open question as to whether fast, numerically stable, and practical algorithms for the LSSL exist.
+
+As described in Appendix B, by freezing the $A$ matrix and $\Delta t$ timescale, the LSSL-fixed is able to be computed much faster than the full LSSL, and is comparable to prior models in practice (Table 5). However, beyond computational complexity, there is also a consideration of space efficiency. Both the LSSL and LSSL-fixed suffer from a large amount of space overhead (described in Appendix B) – using $O ( N L )$ instead of $O ( L )$ space when working on a 1D sequence of length $L$ – that essentially stems from using the latent state representation of dimension $N$ . Consequently, the LSSL can be space inefficient and we used multi-GPU training for our largest experiments (speech and high resolution images, Tables 3 and 4).
+
+These fundamental issues with computation and space complexity were revisited and resolved in follow-up work to this paper, where a new state space model (the Structured State Space) provided a new parameterization and algorithms for state spaces.
+
+Conclusion and future work. Modern deep learning models struggle in applications with very long temporal data such as speech, videos, and medical time-series. We hope that our conceptual and technical contributions can lead to new capabilities with simple, principled, and less engineered models. We note that our pixel-level image classification experiments, which use no heuristics (batch norm, auxiliary losses) or extra information (data augmentation), perform similar to early convnet models with vastly more parameters, and is in the spirit of recent attempts at unifying data modalities with a generic sequence model [18]. Our speech results demonstrate the possibility of learning better features than hand-crafted processing pipelines used widely in speech applications. We are excited about potential downstream applications, such as training other downstream models on top of pre-trained state space features.
+
+# Acknowledgments
+
+We thank Arjun Desai, Ananya Kumar, Laurel Orr, Sabri Eyuboglu, Dan Fu, Mayee Chen, Sarah Hooper, Simran Arora, and Trenton Chang for helpful feedback on earlier drafts. We thank David Romero and James Morrill for discussions and additional results for baselines used in our experiments. This work was done with the support of Google Cloud credits under HAI proposals 540994170283 and 578192719349. AR and IJ are supported under NSF grant CCF-1763481. KS is supported by the Wu Tsai Neuroscience Interdisciplinary Graduate Fellowship. We gratefully acknowledge the support of NIH under No. U54EB020405 (Mobilize), NSF under Nos. CCF1763315 (Beyond Sparsity), CCF1563078 (Volume to Velocity), and 1937301 (RTML); ONR under No. N000141712266 (Unifying Weak Supervision); ONR N00014-20-1-2480: Understanding and Applying Non-Euclidean Geometry in Machine Learning; N000142012275 (NEPTUNE); the Moore Foundation, NXP, Xilinx,
+
+LETI-CEA, Intel, IBM, Microsoft, NEC, Toshiba, TSMC, ARM, Hitachi, BASF, Accenture, Ericsson, Qualcomm, Analog Devices, the Okawa Foundation, American Family Insurance, Google Cloud, Salesforce, Total, the HAI-AWS Cloud Credits for Research program, the Stanford Data Science Initiative (SDSI), and members of the Stanford DAWN project: Facebook, Google, and VMWare. The Mobilize Center is a Biomedical Technology Resource Center, funded by the NIH National Institute of Biomedical Imaging and Bioengineering through Grant P41EB027060. The U.S. Government is authorized to reproduce and distribute reprints for Governmental purposes notwithstanding any copyright notation thereon. Any opinions, findings, and conclusions or recommendations expressed in this material are those of the authors and do not necessarily reflect the views, policies, or endorsements, either expressed or implied, of NIH, ONR, or the U.S. Government.
+
+# References
+
+[1] George B. (George Brown) Arfken, Hans Jürgen Weber, and Frank E Harris. Mathematical methods for physicists : a comprehensive guide / George B. Arfken, Hans J. Weber, Frank E. Harris. Academic Press, Amsterdam, 7th ed. edition, 2013. ISBN 0-12-384654-4.   
+[2] Martin Arjovsky, Amar Shah, and Yoshua Bengio. Unitary evolution recurrent neural networks. In The International Conference on Machine Learning (ICML), pages 1120–1128, 2016.   
+[3] Shaojie Bai, J Zico Kolter, and Vladlen Koltun. An empirical evaluation of generic convolutional and recurrent networks for sequence modeling. arXiv preprint arXiv:1803.01271, 2018.   
+[4] Shaojie Bai, J Zico Kolter, and Vladlen Koltun. Trellis networks for sequence modeling. In The International Conference on Learning Representations (ICLR), 2019.   
+[5] James Bradbury, Stephen Merity, Caiming Xiong, and Richard Socher. Quasi-recurrent neural networks. arXiv preprint arXiv:1611.01576, 2016.   
+[6] John Charles Butcher and Nicolette Goodwin. Numerical methods for ordinary differential equations, volume 2. Wiley Online Library, 2008.   
+[7] Bo Chang, Minmin Chen, Eldad Haber, and Ed H Chi. Antisymmetricrnn: A dynamical system view on recurrent neural networks. In International Conference on Learning Representations, 2019.   
+[8] Shiyu Chang, Yang Zhang, Wei Han, Mo Yu, Xiaoxiao Guo, Wei Tan, Xiaodong Cui, Michael Witbrock, Mark Hasegawa-Johnson, and Thomas S Huang. Dilated recurrent neural networks. In Advances in Neural Information Processing Systems (NeurIPS), 2017.   
+[9] Zhengping Che, Sanjay Purushotham, Kyunghyun Cho, David Sontag, and Yan Liu. Recurrent neural networks for multivariate time series with missing values. Scientific reports, 8(1):1–12, 2018.   
+[10] Tian Qi Chen, Yulia Rubanova, Jesse Bettencourt, and David K Duvenaud. Neural ordinary differential equations. In Advances in neural information processing systems, pages 6571–6583, 2018.   
+[11] T. S. Chihara. An introduction to orthogonal polynomials. Dover Books on Mathematics. Dover Publications, 2011. ISBN 9780486479293.   
+[12] Narsimha Chilkuri and Chris Eliasmith. Parallelizing legendre memory unit training. The International Conference on Machine Learning (ICML), 2021.   
+[13] François Chollet. Xception: Deep learning with depthwise separable convolutions. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 1251–1258, 2017.   
+[14] Junyoung Chung, Caglar Gulcehre, KyungHyun Cho, and Yoshua Bengio. Empirical evaluation of gated recurrent neural networks on sequence modeling. arXiv preprint arXiv:1412.3555, 2014.
+
+[15] Jared Quincy Davis, Albert Gu, Tri Dao, Krzysztof Choromanski, Christopher Ré, Percy Liang, and Chelsea Finn. Catformer: Designing stable transformers via sensitivity analysis. In The International Conference on Machine Learning (ICML), 2021.
+
+[16] Edward De Brouwer, Jaak Simm, Adam Arany, and Yves Moreau. Gru-ode-bayes: Continuous modeling of sporadically-observed time series. In Advances in Neural Information Processing Systems (NeurIPS), 2019.
+
+[17] Christopher De Sa, Albert Gu, Rohan Puttagunta, Christopher Ré, and Atri Rudra. A twopronged progress in structured dense matrix vector multiplication. In Proceedings of the Twenty-Ninth Annual ACM-SIAM Symposium on Discrete Algorithms, pages 1060–1079. SIAM, 2018.
+
+[18] Alexey Dosovitskiy, Lucas Beyer, Alexander Kolesnikov, Dirk Weissenborn, Xiaohua Zhai, Thomas Unterthiner, Mostafa Dehghani, Matthias Minderer, Georg Heigold, Sylvain Gelly, et al. An image is worth 16x16 words: Transformers for image recognition at scale. arXiv preprint arXiv:2010.11929, 2020.
+
+[19] Y. Eidelman and I. Gohberg. On a new class of structured matrices. Integral Equations and Operator Theory, 34, 1999.
+
+[20] N Benjamin Erichson, Omri Azencot, Alejandro Queiruga, Liam Hodgkinson, and Michael W Mahoney. Lipschitz recurrent neural networks. In International Conference on Learning Representations, 2021.
+
+[21] Karl J Friston, Lee Harrison, and Will Penny. Dynamic causal modelling. Neuroimage, 19(4): 1273–1302, 2003.
+
+[22] Ken-ichi Funahashi and Yuichi Nakamura. Approximation of dynamical systems by continuous time recurrent neural networks. Neural networks, 6(6):801–806, 1993.
+
+[23] Gene H Golub and Charles F Van Loan. Matrix computations, volume 3. JHU press, 2013.
+
+[24] Albert Gu, Tri Dao, Stefano Ermon, Atri Rudra, and Christopher Ré. Hippo: Recurrent memory with optimal polynomial projections. In Hugo Larochelle, Marc’Aurelio Ranzato, Raia Hadsell, Maria-Florina Balcan, and Hsuan-Tien Lin, editors, Advances in Neural Information Processing Systems 33: Annual Conference on Neural Information Processing Systems 2020, NeurIPS 2020, December 6-12, 2020, virtual, 2020. URL https://proceedings.neurips. cc/paper/2020/hash/102f0bb6efb3a6128a3c750dd16729be-Abstract.html.
+
+[25] Albert Gu, Caglar Gulcehre, Tom Le Paine, Matt Hoffman, and Razvan Pascanu. Improving the gating mechanism of recurrent neural networks. In The International Conference on Machine Learning (ICML), 2020.
+
+[26] Ramin Hasani, Mathias Lechner, Alexander Amini, Lucas Liebenwein, Max Tschaikowski, Gerald Teschl, and Daniela Rus. Closed-form continuous-depth models. arXiv preprint arXiv:2106.13898, 2021.
+
+[27] Ramin Hasani, Mathias Lechner, Alexander Amini, Daniela Rus, and Radu Grosu. Liquid time-constant networks. In Proceedings of the AAAI Conference on Artificial Intelligence, 2021.
+
+[28] Sepp Hochreiter and Jürgen Schmidhuber. Long short-term memory. Neural computation, 9(8): 1735–1780, 1997.
+
+[29] Ian D Jordan, Piotr Aleksander Sokół, and Il Memming Park. Gated recurrent units viewed through the lens of continuous time dynamical systems. Frontiers in computational neuroscience, page 67, 2021.
+
+[30] Anil Kag, Ziming Zhang, and Venkatesh Saligrama. Rnns incrementally evolving on an equilibrium manifold: A panacea for vanishing and exploding gradients? In International Conference on Learning Representations, 2020.
+
+[31] Patrick Kidger, James Morrill, James Foster, and Terry Lyons. Neural controlled differential equations for irregular time series. arXiv preprint arXiv:2005.08926, 2020.
+
+[32] Mathias Lechner and Ramin Hasani. Learning long-term dependencies in irregularly-sampled time series. arXiv preprint arXiv:2006.04418, 2020.   
+[33] Tao Lei, Yu Zhang, Sida I Wang, Hui Dai, and Yoav Artzi. Simple recurrent units for highly parallelizable recurrence. arXiv preprint arXiv:1709.02755, 2017.   
+[34] Shuai Li, Wanqing Li, Chris Cook, Ce Zhu, and Yanbo Gao. Independently recurrent neural network (IndRNN): Building a longer and deeper RNN. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 5457–5466, 2018.   
+[35] Liyuan Liu, Xiaodong Liu, Jianfeng Gao, Weizhu Chen, and Jiawei Han. Understanding the difficulty of training transformers. The International Conference on Machine Learning (ICML), 2020.   
+[36] Ziwei Liu, Ping Luo, Xiaogang Wang, and Xiaoou Tang. Deep learning face attributes in the wild. In ICCV, pages 3730–3738. IEEE Computer Society, 2015. ISBN 978-1-4673-8391-2. URL http://dblp.uni-trier.de/db/conf/iccv/iccv2015.html#LiuLWT15.   
+[37] James Morrill, Cristopher Salvi, Patrick Kidger, James Foster, and Terry Lyons. Neural rough differential equations for long time series. The International Conference on Machine Learning (ICML), 2021.   
+[38] Murphy Yuezhen Niu, Lior Horesh, and Isaac Chuang. Recurrent neural networks in the eye of differential equations. arXiv preprint arXiv:1904.12933, 2019.   
+[39] Razvan Pascanu, Tomas Mikolov, and Yoshua Bengio. On the difficulty of training recurrent neural networks. In International conference on machine learning, pages 1310–1318, 2013.   
+[40] Clément Pernet. Computing with quasiseparable matrices. In Proceedings of the ACM on International Symposium on Symbolic and Algebraic Computation, pages 389–396, 2016.   
+[41] KB Petersen and MS Pedersen. The matrix cookbook, version 20121115. Technical Univ. Denmark, Kongens Lyngby, Denmark, Tech. Rep, 3274, 2012.   
+[42] M. Ravanelli, T. Parcollet, and Y. Bengio. The pytorch-kaldi speech recognition toolkit. In In Proc. of ICASSP, 2019.   
+[43] David W Romero, Robert-Jan Bruintjes, Jakub M Tomczak, Erik J Bekkers, Mark Hoogendoorn, and Jan C van Gemert. Flexconv: Continuous kernel convolutions with differentiable kernel sizes. arXiv preprint arXiv:2110.08059, 2021.   
+[44] David W Romero, Anna Kuzina, Erik J Bekkers, Jakub M Tomczak, and Mark Hoogendoorn. Ckconv: Continuous kernel convolution for sequential data. arXiv preprint arXiv:2102.02611, 2021.   
+[45] Yulia Rubanova, Tian Qi Chen, and David K Duvenaud. Latent ordinary differential equations for irregularly-sampled time series. In Advances in Neural Information Processing Systems, pages 5321–5331, 2019.   
+[46] T. Konstantin Rusch and Siddhartha Mishra. Coupled oscillatory recurrent neural network (cornn): An accurate and (gradient) stable architecture for learning long time dependencies. In International Conference on Learning Representations, 2021.   
+[47] T Konstantin Rusch and Siddhartha Mishra. Unicornn: A recurrent model for learning very long time dependencies. The International Conference on Machine Learning (ICML), 2021.   
+[48] Khaled Saab, Jared Dunnmon, Christopher Ré, Daniel Rubin, and Christopher Lee-Messer. Weak supervision as an efficient approach for automated seizure detection in electroencephalography. NPJ Digital Medicine, 3(1):1–12, 2020.   
+[49] Vinit Shah, Eva Von Weltin, Silvia Lopez, James Riley McHugh, Lillian Veloso, Meysam Golmohammadi, Iyad Obeid, and Joseph Picone. The Temple University hospital seizure detection corpus. Frontiers in neuroinformatics, 12:83, 2018.   
+[50] Jie Shen, Tao Tang, and Li-Lian Wang. Orthogonal Polynomials and Related Approximation Results, pages 47–140. Springer Berlin Heidelberg, Berlin, Heidelberg, 2011. ISBN 978- 3-540-71041-7. doi: 10.1007/978-3-540-71041-7_3. URL https://doi.org/10.1007/ 978-3-540-71041-7_3.   
+[51] Victor Shoup. A computational introduction to number theory and algebra. Cambridge university press, 2009.   
+[52] G. Szegö. Orthogonal Polynomials. Number v.23 in American Mathematical Society colloquium publications. American Mathematical Society, 1967. ISBN 9780821889527.   
+[53] G. Szego.˝ Orthogonal Polynomials. American Mathematical Society: Colloquium publications. American Mathematical Society, 1975. ISBN 9780821810231.   
+[54] Corentin Tallec and Yann Ollivier. Can recurrent neural networks warp time? In The International Conference on Learning Representations (ICLR), 2018.   
+[55] Chang Wei Tan, Christoph Bergmeir, Francois Petitjean, and Geoffrey I Webb. Time series extrinsic regression. Data Mining and Knowledge Discovery, pages 1–29, 2021. doi: https: //doi.org/10.1007/s10618-021-00745-9.   
+[56] Trieu H Trinh, Andrew M Dai, Minh-Thang Luong, and Quoc V Le. Learning longer-term dependencies in RNNs with auxiliary losses. In The International Conference on Machine Learning (ICML), 2018.   
+[57] Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Lukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Advances in Neural Information Processing Systems (NeurIPS), 2017.   
+[58] Aaron Voelker, Ivana Kajic, and Chris Eliasmith. Legendre memory units: Continuous-time ´ representation in recurrent neural networks. In Advances in Neural Information Processing Systems, pages 15544–15553, 2019.   
+[59] Robert L Williams, Douglas A Lawrence, et al. Linear state-space control systems. Wiley Online Library, 2007.   
+[60] Max A Woodbury. Inverting modified matrices. Memorandum report, 42:106, 1950.   
+[61] Guofeng Zhang, Tongwen Chen, and Xiang Chen. Performance recovery in digital implementation of analogue systems. SIAM journal on control and optimization, 45(6):2207–2223, 2007.   
+[62] Huaguang Zhang, Zhanshan Wang, and Derong Liu. A comprehensive review of stability analysis of continuous-time recurrent neural networks. IEEE Transactions on Neural Networks and Learning Systems, 25(7):1229–1262, 2014.

parse/train/yWd42CWN3c/yWd42CWN3c_content_list.json

@@ -0,0 +1,1557 @@
+[
+    {
+        "type": "text",
+        "text": "Combining Recurrent, Convolutional, and Continuous-time Models with Linear State-Space Layers ",
+        "text_level": 1,
+        "bbox": [
+            272,
+            122,
+            730,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Albert $\\mathbf { G } \\mathbf { u } ^ { \\dagger }$ , Isys Johnson‡, Karan Goel†, Khaled Saab∗, Tri Dao†, Atri Rudra‡, Christopher Ré† ",
+        "bbox": [
+            169,
+            250,
+            833,
+            266
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "† Department of Computer Science, Stanford University ∗ Department of Electrical Engineering, Stanford University ‡ Department of Computer Science and Engineering, University at Buffalo, SUNY {albertgu,knrg,ksaab,trid}@stanford.edu, chrismre@cs.stanford.edu {isysjohn,atri}@buffalo.edu ",
+        "bbox": [
+            223,
+            266,
+            764,
+            337
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            372,
+            535,
+            388
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recurrent neural networks (RNNs), temporal convolutions, and neural differential equations (NDEs) are popular families of deep learning models for time-series data, each with unique strengths and tradeoffs in modeling power and computational efficiency. We introduce a simple sequence model inspired by control systems that generalizes these approaches while addressing their shortcomings. The Linear State-Space Layer (LSSL) maps a sequence $u \\mapsto y$ by simply simulating a linear continuous-time state-space representation ${ \\dot { x } } = A x + B u , y = C x + D u$ Theoretically, we show that LSSL models are closely related to the three aforementioned families of models and inherit their strengths. For example, they generalize convolutions to continuous-time, explain common RNN heuristics, and share features of NDEs such as time-scale adaptation. We then incorporate and generalize recent theory on continuous-time memorization to introduce a trainable subset of structured matrices $A$ that endow LSSLs with long-range memory. Empirically, stacking LSSL layers into a simple deep neural network obtains state-of-the-art results across time series benchmarks for long dependencies in sequential image classification, real-world healthcare regression tasks, and speech. On a difficult speech classification task with length-16000 sequences, LSSL outperforms prior approaches by 24 accuracy points, and even outperforms baselines that use handcrafted features on $1 0 0 \\mathrm { x }$ shorter sequences. ",
+        "bbox": [
+            233,
+            405,
+            766,
+            667
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            694,
+            310,
+            712
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "A longstanding challenge in machine learning is efficiently modeling sequential data longer than a few thousand time steps. The usual paradigms for designing sequence models involve recurrence (e.g. RNNs), convolutions (e.g. CNNs), or differential equations (e.g. NDEs), which each come with tradeoffs. For example, RNNs are a natural stateful model for sequential data that require only constant computation/storage per time step, but are slow to train and suffer from optimization difficulties (e.g., the \"vanishing gradient problem\" [39]), which empirically limits their ability to handle long sequences. CNNs encode local context and enjoy fast, parallelizable training, but are not sequential, resulting in more expensive inference and an inherent limitation on the context length. NDEs are a principled mathematical model that can theoretically address continuous-time problems and long-term dependencies [37], but are very inefficient. ",
+        "bbox": [
+            174,
+            727,
+            825,
+            866
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Ideally, a model family would combine the strengths of these paradigms, providing properties like parallelizable training (convolutional), stateful inference (recurrence) and time-scale adaptation (differential equations), while handling very long sequences in a computationally efficient way. Several recent works have turned to this question. These include the CKConv, which models a continuous convolution kernel [44]; several ODE-inspired RNNs, such as the UnICORNN [47]; the LMU, which speeds up a specific linear recurrence using convolutions [12, 58]; and HiPPO [24], a generalization of the LMU that introduces a theoretical framework for continuous-time memorization. However, these model families come at the price of reduced expressivity: intuitively, a family that is both convolutional and recurrent should be more restrictive than either. ",
+        "bbox": [
+            174,
+            871,
+            823,
+            900
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/ea61b96555207397a42570dc9e353cb2fe433bafb6a857f9f99af2dbe77cad26.jpg",
+        "image_caption": [
+            "Figure 1: (Three views of the LSSL) A Linear State Space Layer layer is a map $u _ { t } \\ \\in \\ \\mathbb { R } \\ \\to \\ y _ { t } \\ \\in \\ \\mathbb { R }$ , where each feature $u _ { t } \\mapsto y _ { t }$ is defined by discretizing a state-space model $A , B , C , D$ with a parameter $\\Delta t$ The underlying state space model defines a discrete recurrence through combining the state matrix $A$ and timescale $\\Delta t$ into a transition matrix $\\overline { { A } }$ . (Left) As an implicit continuous model, irregularly-spaced data can be handled by discretizing the same matrix $A$ using a different timescale $\\Delta t$ . (Center) As a recurrent model, inference can be performed efficiently by computing the layer timewise (i.e., one vertical slice at a time $( u _ { t } , x _ { t } , y _ { t } ) , ( u _ { t + 1 } , x _ { t + 1 } , y _ { t + 1 } ) , \\dots )$ , by unrolling the linear recurrence. (Right) As a convolutional model, training can be performed efficiently by computing the layer depthwise in parallel (i.e., one horizontal slice at a time $( u _ { t } ) _ { t \\in [ L ] } , ( y _ { t } ) _ { t \\in [ L ] } , \\dots . )$ , by convolving with a particular filter. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            89,
+            823,
+            330
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            477,
+            825,
+            574
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our first goal is to construct an expressive model family that combines all 3 paradigms while preserving their strengths. The Linear State-Space Layer (LSSL) is a simple sequence model that maps a 1-dimensional function or sequence $u ( t ) \\mapsto y ( t )$ through an implicit state $x ( t )$ by simulating a linear continuous-time state-space representation in discrete-time ",
+        "bbox": [
+            174,
+            580,
+            825,
+            637
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3363a1c309c8c100c36518628e0bc2d017eb37c15c392315c394f0f6a7aa545a.jpg",
+        "text": "$$\n\\begin{array} { l } { \\dot { \\boldsymbol { x } } ( t ) = \\boldsymbol { A } \\boldsymbol { x } ( t ) + \\boldsymbol { B } \\boldsymbol { u } ( t ) } \\\\ { \\boldsymbol { y } ( t ) = \\boldsymbol { C } \\boldsymbol { x } ( t ) + \\boldsymbol { D } \\boldsymbol { u } ( t ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            418,
+            641,
+            578,
+            680
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $A$ controls the evolution of the system and $B , C , D$ are projection parameters. The LSSL can be viewed as an instantiation of each family, inheriting their strengths (Fig. 1): ",
+        "bbox": [
+            173,
+            683,
+            825,
+            712
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• LSSLs are recurrent. If a discrete step-size $\\Delta t$ is specified, the LSSL can be discretized into a linear recurrence using standard techniques, and simulated during inference as a stateful recurrent model with constant memory and computation per time step. • LSSLs are convolutional. The linear time-invariant systems defined by $( 1 ) + ( 2 )$ are known to be explicitly representable as a continuous convolution. Moreover, the discrete-time version can be parallelized during training using convolutions [12, 44]. • LSSLs are continuous-time. The LSSL itself is a differential equation. As such, it can perform unique applications of continuous-time models, such as simulating continuous processes, handling missing data [45], and adapting to different timescales. ",
+        "bbox": [
+            217,
+            722,
+            825,
+            858
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Surprisingly, we show that LSSLs do not sacrifice expressivity, and in fact generalize convolutions and RNNs. First, classical results from control theory imply that all 1-D convolutional kernels can be approximated by an LSSL [59]. Additionally, we provide two results relating RNNs and ODEs that may be of broader interest, e.g. showing that some RNN architectural heuristics (such as gating mechanisms) are related to the step-size $\\Delta t$ and can actually be derived from ODE approximations. As corollaries of these results, we show that popular RNN methods are special cases of LSSLs. ",
+        "bbox": [
+            176,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            92,
+            823,
+            133
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The generality of LSSLs does come with tradeoffs. In particular, we describe and address two challenges that naive LSSL instantiations face when handling long sequences: (i) they inherit the limitations of both RNNs and CNNs at remembering long dependencies, and (ii) choosing the state matrix $A$ and timescale $\\Delta t$ appropriately are critical to their performance, yet learning them is computationally infeasible. We simultaneously address these challenges by specializing LSSLs using a carefully chosen class of structured matrices $A$ , such that (i) these matrices generalize prior work on continuous-time memory [24] and mathematically capture long dependencies with respect to a learnable family of measures, and (ii) with new algorithms, LSSLs with these matrices $A$ can be theoretically sped up under certain computation models, even while learning the measure $A$ and timescale $\\Delta t$ . ",
+        "bbox": [
+            173,
+            138,
+            825,
+            277
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We empirically validate that LSSLs are widely effective on benchmark datasets and very long time series from healthcare sensor data, images, and speech. ",
+        "bbox": [
+            173,
+            284,
+            821,
+            313
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "• On benchmark datasets, LSSLs obtain SoTA over recent RNN, CNN, and NDE-based methods across sequential image classification tasks (e.g., by over $10 \\%$ accuracy on sequential CIFAR) and healthcare regression tasks with length-4000 time series (by up to $80 \\%$ reduction in RMSE). • To showcase the potential of LSSLs to unlock applications with extremely long sequences, we introduce a new sequential CelebA classification task with length-38000 sequences. A small LSSL comes within 2.16 accuracy points of a specialized ResNet-18 vision architecture that has $1 0 \\mathrm { x }$ more parameters and is trained directly on images. • Finally, we test LSSLs on a difficult dataset of high-resolution speech clips, where usual speech pipelines pre-process the signals to reduce the length by $1 0 0 \\mathrm { x }$ . When training on the raw length16000 signals, the LSSL not only (i) outperforms previous methods by over 20 accuracy points in 1/5 the training time, but (ii) outperforms all baselines that use the pre-processed length-160 sequences, overcoming the limitations of hand-crafted feature engineering. ",
+        "bbox": [
+            173,
+            324,
+            825,
+            505
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Summary of Contributions ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            516,
+            362,
+            531
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "• We introduce Linear State-Space Layers (LSSLs), a simple sequence-to-sequence transformation that shares the modeling advantages of recurrent, convolutional, and continuous-time methods. Conversely, we show that RNNs and CNNs can be seen as special cases of LSSLs (Section 3). ",
+        "bbox": [
+            174,
+            542,
+            823,
+            585
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "• We prove that a structured subclass of LSSLs can learn representations that solve continuous-time memorization, allowing it to adapt its measure and timescale (Section 4.1). We also provide new algorithms for these LSSLs, showing that they can be sped up computationally under an arithmetic complexity model Section 4.2. ",
+        "bbox": [
+            176,
+            592,
+            821,
+            647
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "• Empirically, we show that LSSLs stacked into a deep neural network are widely effective on time series data, even (or especially) on extremely long sequences (Section 5). ",
+        "bbox": [
+            171,
+            654,
+            823,
+            683
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 Technical Background ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            703,
+            393,
+            720
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We summarize the preliminaries on differential equations that are necessary for this work. We first introduce two standard approximation schemes for differential equations that we will use to convert continuous-time models to discrete-time, and will be used in our results on understanding RNNs. We give further context on the step size or timescale $\\Delta t$ , which is a particularly important parameter involved in this approximation process. Finally, we provide a summary of the HiPPO framework for continuous-time memorization [24], which will give us a mathematical tool for constructing LSSLs that can address long-term dependencies. ",
+        "bbox": [
+            173,
+            736,
+            825,
+            833
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Approximations of differential equations. Any differential equation ${ \\dot { x } } ( t ) = f ( t , x ( t ) )$ has an equivalent integral equation $\\begin{array} { r } { x ( t ) = x ( t _ { 0 } ) + \\int _ { t _ { 0 } } ^ { t } f ( s , x ( s ) ) d s } \\end{array}$ . This can be numerically solved by storing some approximation for $x$ , and keeping it fixed inside $f ( t , x )$ while iterating the equation. For example, Picard iteration is often used to prove the existence of solutions to ODEs by iterating the equation $\\begin{array} { r } { x _ { i + 1 } ( t ) : = x _ { i } ( t _ { 0 } ) + \\int _ { t _ { 0 } } ^ { t } f ( s , x _ { i } ( s ) ) d s } \\end{array}$ . In other words, it finds a sequence of functions $x _ { 0 } ( t ) , x _ { 1 } ( t ) , \\ldots$ that approximate the solution $x ( t )$ of the integral equation. ",
+        "bbox": [
+            174,
+            849,
+            825,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            169,
+            88,
+            825,
+            123
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Discretization. On the other hand, for a desired sequence of discrete times $t _ { i }$ , approximations to $x ( t _ { 0 } ) , x ( t _ { 1 } ) , \\ldots$ can be found by iterating the equation $\\begin{array} { r } { x ( t _ { i + 1 } ) = x ( t _ { i } ) + \\int _ { t _ { i } } ^ { t _ { i + 1 } } f ( s , x ( s ) ) d s } \\end{array}$ Different ways of approximating the RHS integral lead to different discretization schemes. We single out a discretization method called the generalized bilinear transform (GBT) which is specialized to linear ODEs of the form (1). Given a step size $\\Delta t$ , the GBT update is ",
+        "bbox": [
+            173,
+            136,
+            825,
+            210
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7db6e6577fd369def46b7667f96c7e9576c4ece41cb37429237aaf7e02befacc.jpg",
+        "text": "$$\nx ( t + \\Delta t ) = ( I - \\alpha \\Delta t \\cdot A ) ^ { - 1 } ( I + ( 1 - \\alpha ) \\Delta t \\cdot A ) x ( t ) + \\Delta t ( I - \\alpha \\Delta t \\cdot A ) ^ { - 1 } B \\cdot u ( t ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            199,
+            214,
+            779,
+            233
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Three important cases are: $\\alpha = 0$ becomes the classic Euler method which is simply the first-order approximation $x ( t + \\Delta t ) = x ( t ) + \\Delta t \\cdot x ^ { \\prime } ( t )$ ; $\\alpha = 1$ is called the backward Euler method; and $\\begin{array} { r } { \\dot { \\alpha } = \\frac { 1 } { 2 } } \\end{array}$ is called the bilinear method, which preserves the stability of the system [61]. ",
+        "bbox": [
+            173,
+            237,
+            825,
+            280
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In Section 3.2 we will show that the backward Euler method and Picard iteration are actually related to RNNs. On the other hand, the bilinear discretization will be our main method for computing accurate discrete-time approximations of our continuous-time models. In particular, define $\\overline { { A } }$ and $\\overline { B }$ to be the matrices appearing in (3) for $\\begin{array} { r } { \\alpha = \\frac { 1 } { 2 } } \\end{array}$ . Then the discrete-time state-space model is ",
+        "bbox": [
+            174,
+            285,
+            825,
+            343
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9bd9db7d4be2e9c092037784c1ffa1e081089c9486018aa2005ee98a25163de2.jpg",
+        "text": "$$\n\\begin{array} { l } { { x _ { t } = \\overline { { A } } x _ { t - 1 } + \\overline { { B } } u _ { t } } } \\\\ { { y _ { t } = C x _ { t } + D u _ { t } . } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            431,
+            348,
+            565,
+            387
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "$\\Delta t$ as a timescale. In most models, the length of dependencies they can capture is roughly proportional to $\\frac { 1 } { \\Delta t }$ . Thus we also refer to the step size $\\Delta t$ as a timescale. This is an intrinsic part of converting a continuous-time ODE into a discrete-time recurrence, and most ODE-based RNN models have it as an important and non-trainable hyperparameter [24, 47, 58]. On the other hand, in Section 3.2 we show that the gating mechanism of classical RNNs is a version of learning $\\Delta t$ . Moreover when viewed as a CNN, the timescale $\\Delta t$ can be viewed as controlling the width of the convolution kernel (Section 3.2). Ideally, all ODE-based sequence models would be able to automatically learn the proper timescales. ",
+        "bbox": [
+            173,
+            396,
+            826,
+            508
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Continuous-time memory. Consider an input function $u ( t )$ , a fixed probability measure $\\omega ( t )$ , and a sequence of $N$ basis functions such as polynomials. At every time $t$ , the history of $u$ before time $t$ can be projected onto this basis, which yields a vector of coefficients $\\boldsymbol { x } ( t ) \\in \\mathbb { R } ^ { \\tilde { N } }$ that represents an optimal approximation of the history of $u$ with respect to the provided measure $\\omega$ . The map taking the function $u ( t ) \\in \\mathbb { R }$ to coefficients $\\boldsymbol { x } ( t ) \\in \\mathbb { R } ^ { N }$ is called the High-Order Polynomial Projection Operator (HiPPO) with respect to the measure $\\omega$ . In special cases such as the uniform measure $\\omega = \\mathbb { I } \\{ [ 0 , 1 ] \\}$ and the exponentially-decaying measure $\\omega ( t ) = \\exp ( - t )$ , Gu et al. [24] showed that $x ( t )$ satisfies a differential equation ${ \\dot { x } } ( t ) = A ( t ) x ( t ) + B ( t ) u ( t )$ (i.e., (1)) and derived closed forms for the matrix $A$ . Their framework provides a principled way to design memory models handling long dependencies; however, they prove only these few special cases. ",
+        "bbox": [
+            173,
+            521,
+            825,
+            661
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 Linear State-Space Layers (LSSL) ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            679,
+            493,
+            696
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We define our main abstraction, a model family that generalizes recurrence and convolutions. Section 3.1 first formally defines the LSSL, then discusses how to compute it with multiple views. Conversely, Section 3.2 shows that LSSLs are related to mechanisms of the most popular RNNs. ",
+        "bbox": [
+            174,
+            710,
+            826,
+            752
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 Different Views of the LSSL ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            768,
+            406,
+            784
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Given a fixed state space representation $A , B , C , D$ , an LSSL is the sequence-to-sequence mapping defined by discretizing the linear state-space model (1) and (2). ",
+        "bbox": [
+            174,
+            792,
+            823,
+            823
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Concretely, an LSSL layer has parameters $A , B , C , D$ , and $\\Delta t$ . It operates on an input $\\boldsymbol { u } \\in \\mathbb { R } ^ { L \\times H }$ represefeature equence of length  defines a sequenc $L$ h timestep has an , which is combin $H$ -dimensional fea with a timescale vector. Eachto define an $h \\in [ H ]$ $( u _ { t } ^ { ( h ) } ) _ { t \\in [ L ] }$ $\\Delta t _ { h }$ output $\\boldsymbol { y } ^ { ( h ) } \\in \\mathbb { R } ^ { L }$ via the discretized state-space model (4)+(5). ",
+        "bbox": [
+            174,
+            827,
+            825,
+            891
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Computationally, the discrete-time LSSL can be viewed in multiple ways (Fig. 1). ",
+        "bbox": [
+            173,
+            896,
+            710,
+            912
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "As a recurrence. The recurrent state $\\boldsymbol { x } _ { t - 1 } \\in \\mathbb { R } ^ { H \\times N }$ carries the context of all inputs before time $t$ The current state $x _ { t }$ and output $y _ { t }$ can be computed by simply following equations $( 4 ) + ( 5 )$ . Thus the LSSL is a recurrent model with efficient and stateful inference, which can consume a (potentially unbounded) sequence of inputs while requiring fixed computation/storage per time step. ",
+        "bbox": [
+            174,
+            89,
+            825,
+            147
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "As a convolution. For simplicity let the initial state be $x _ { - 1 } = 0$ . Then $( 4 ) + ( 5 )$ explicitly yields ",
+        "bbox": [
+            165,
+            160,
+            805,
+            175
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fd4807e51f260253a8048dba1c0bbde101a0bff058b60c18d276c2e2f053cfb2.jpg",
+        "text": "$$\ny _ { k } = C \\left( \\overline { { A } } \\right) ^ { k } \\overline { { B } } u _ { 0 } + C \\left( \\overline { { A } } \\right) ^ { k - 1 } \\overline { { B } } u _ { 1 } + \\cdot \\cdot \\cdot + C \\overline { { A } } \\overline { { B } } u _ { k - 1 } + \\overline { { B } } u _ { k } + D u _ { k } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            276,
+            180,
+            722,
+            200
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Then $y$ is simply the (non-circular) convolution $y = \\mathcal { K } _ { L } ( \\overline { { A } } , \\overline { { B } } , C ) \\ast u + D u$ , where ",
+        "bbox": [
+            174,
+            205,
+            723,
+            223
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/20d9bd6c296e7fc8fbbd78044df915f5b25b046b65451b937427ffc40483d41f.jpg",
+        "text": "$$\n{ \\mathcal { K } } _ { L } ( A , B , C ) = \\left( C A ^ { i } B \\right) _ { i \\in [ L ] } \\in \\mathbb { R } ^ { L } = ( C B , C A B , \\ldots , C A ^ { L - 1 } B ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            271,
+            228,
+            725,
+            252
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Thus the LSSL can be viewed as a convolutional model where the entire output $y \\in \\mathbb { R } ^ { H \\times L }$ can be computed at once by a convolution, which can be efficiently implemented with three FFTs. ",
+        "bbox": [
+            173,
+            266,
+            823,
+            295
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The computational bottleneck. We make a note that the bottleneck of (i) the recurrence view is matrix-vector multiplication (MVM) by the discretized state matrix $\\overline { { A } }$ when simulating (4), and (ii) the convolutional view is computing the Krylov function $\\kappa _ { L }$ (7). Throughout this section we assumed the LSSL parameters were fixed, which means that $\\overline { { A } }$ and $\\mathcal { K } _ { L } ( A , B , C )$ can be cached for efficiency. However, learning the parameters $\\overline { { A } }$ and $\\Delta t$ would involve repeatedly re-computing these, which is infeasible in practice. We revisit and solve this problem in Section 4.2. ",
+        "bbox": [
+            173,
+            309,
+            825,
+            396
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 Expressivity of LSSLs ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            411,
+            367,
+            426
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For a model to be both recurrent and convolutional, one might expect it to be limited in other ways. Indeed, while [12, 44] also observe that certain recurrences can be replaced with a convolution, they note that it is not obvious if convolutions can be replaced by recurrences. Moreover, while the LSSL is a linear recurrence, popular RNN models are nonlinear sequence models with activation functions between each time step. We now show that LSSLs surprisingly do not have limited expressivity. ",
+        "bbox": [
+            174,
+            436,
+            825,
+            507
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Convolutions are LSSLs. A well-known fact about state-space systems $( 1 ) + ( 2 )$ is that the output $y$ is related to the input $u$ by a convolution $\\begin{array} { r } { y ( t ) = \\int h ( \\tau ) u ( \\bar { t } - \\tau ) \\dot { d } \\tau } \\end{array}$ with the impulse response $h$ of the system. Conversely, a convolutional filter $h$ that is a rational function of degree $N$ can be represented by a state-space model of size $N$ [59]. Thus, an arbitrary convolutional filter $h$ can be approximated by a rational function (e.g., by Padé approximants) and represented by an LSSL. ",
+        "bbox": [
+            174,
+            521,
+            825,
+            592
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In the particular case of LSSLs with HiPPO matrices (Sections 2 and 4.1), there is another intuitive interpretation of how LSSL relate to convolutions. Consider the special case when $A$ corresponds to a uniform measure (in the literature known as the LMU [58] or HiPPO-LegT [24] matrix). Then for a fixed $d t$ , equation (1) is simply memorizing the input within sliding windows of $\\frac { 1 } { \\Delta t }$ elements, and equation (2) extracts features from this window. Thus the LSSL can be interpreted as automatically learning convolution filters with a learnable kernel width. ",
+        "bbox": [
+            174,
+            597,
+            825,
+            680
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "RNNs are LSSLs. We show two results about RNNs that may be of broader interest. Our first result says that the ubiquitous gating mechanism of RNNs, commonly perceived as a heuristic to smooth optimization [28], is actually the analog of a step size or timescale $\\Delta t$ . ",
+        "bbox": [
+            174,
+            695,
+            825,
+            737
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Lemma 3.1. A (1-D) gated recurrence $x _ { t } = ( 1 - \\sigma ( z ) ) x _ { t - 1 } + \\sigma ( z ) u _ { t }$ , where $\\sigma$ is the sigmoid function and $z$ is an arbitrary expression, can be viewed as the $G B T ( \\alpha = 1 ,$ ) (i.e., backwards-Euler) discretization of a 1-D linear ODE ${ \\dot { x } } ( t ) = - x ( t ) + u ( t )$ . ",
+        "bbox": [
+            173,
+            741,
+            825,
+            785
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Proof. Applying a discretization requires a positive step size $\\Delta t$ . The simplest way to parameterize a positive function is via the exponential function $\\Delta t = \\exp ( z )$ applied to any expression $z$ . Substituting this into (3) with $A = - 1 , B = 1 , \\alpha = 1$ exactly produces the gated recurrence. □ ",
+        "bbox": [
+            173,
+            797,
+            826,
+            840
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "While Lemma 3.1 involves approximating continuous systems using discretization, the second result is about approximating them using Picard iteration (Section 2). Roughly speaking, each layer of a deep linear RNN can be viewed as successive Picard iterates $x _ { 0 } ( t ) , x _ { 1 } ( t ) , \\ldots$ approximating a function $x ( t )$ defined by a non-linear ODE. This shows that we do not lose modeling power by using linear instead of non-linear recurrences, and that the nonlinearity can instead be “moved” to the depth direction of deep neural networks to improve speed without sacrificing expressivity. ",
+        "bbox": [
+            174,
+            854,
+            825,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            92,
+            823,
+            119
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Lemma 3.2. (Infinitely) deep stacked LSSL layers of order $N = 1$ with position-wise non-linear functions can approximate any non-linear ODE $\\dot { x } ( t ) = - x + f ( t , x ( t ) )$ . ",
+        "bbox": [
+            173,
+            123,
+            823,
+            151
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We note that many of the most popular and effective RNN variants such as the LSTM [28], GRU [14], QRNN [5], and SRU [33], involve a hidden state $\\boldsymbol { x } _ { t } \\in \\mathbb { R } ^ { H }$ that involves independently “gating” the $H$ hidden units. Applying Lemma 3.1, they actually also approximate an ODE of the form in Lemma 3.2. Thus LSSLs and these popular RNN models can be seen to all approximate the same type of underlying continuous dynamics, by using Picard approximations in the depth direction and discretization (gates) in the time direction. Appendix C gives precise statements and proofs. ",
+        "bbox": [
+            173,
+            161,
+            826,
+            246
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.3 Deep LSSLs ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            261,
+            299,
+            276
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The basic LSSL is defined as a sequence-to-sequence map from $\\mathbb { R } ^ { L } \\to \\mathbb { R } ^ { L }$ on 1D sequences of length $L$ , parameterized by parameters $A \\in \\mathbb { R } ^ { \\tilde { N } \\times N } , B \\in \\hat { \\mathbb { R } } ^ { N \\times 1 } , C \\in \\mathbb { R } ^ { 1 \\times N } , D \\in \\mathbb { R } ^ { 1 \\times \\hat { 1 } } , \\Delta t \\in \\mathbb { R } .$ Given an input sequence with hidden dimension $H$ (in other words a feature dimension greater than 1), we simply broadcast the parameters $B , C , D , \\Delta t$ with an extra dimension $H$ . Each of these $H$ copies is learned independently, so that there are $H$ different versions of a 1D LSSL processing each of the input features independently. Overall, the standalone LSSL layer is a sequence-to-sequence map with the same interface as standard sequence model layers such as RNNs, CNNs, and Transformers. ",
+        "bbox": [
+            174,
+            286,
+            825,
+            383
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The full LSSL architecture in a deep neural network is defined similarly to standard sequence models such as deep ResNets and Transformers, involving stacking LSSL layers connected with normalization layers and residual connections. Full architecture details are described in Appendix B, including the initialization of $A$ and $\\Delta t$ , computational details, and other architectural details. ",
+        "bbox": [
+            174,
+            390,
+            825,
+            445
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 Combining LSSLs with Continuous-time Memorization ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            464,
+            668,
+            482
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In Section 3 we introduced the LSSL model and showed that it shares the strengths of convolutions and recurrences while also generalizing them. We now discuss and address its main limitations, in particular handling long dependencies (Section 4.1) and efficient computation (Section 4.2). ",
+        "bbox": [
+            174,
+            496,
+            825,
+            537
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 Incorporating Long Dependencies into LSSLs ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            554,
+            529,
+            569
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The generality of LSSLs means they can inherit the issues of recurrences and convolutions at addressing long dependencies (Section 1). For example, viewed as a recurrence, repeated multiplication by $\\overline { { A } }$ could suffer from the vanishing gradients problem [39, 44]. We confirm empirically that LSSLs with random state matrices $A$ are actually not effective (Section 5.4) as a generic sequence model. ",
+        "bbox": [
+            174,
+            579,
+            825,
+            636
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "However, one advantage of these mathematical continuous-time models is that they are theoretically analyzable, and specific $A$ matrices can be derived to address this issue. In particular, the HiPPO framework (Section 2) describes how to memorize a function in continuous time with respect to a measure $\\omega$ [24]. This operator mapping a function to a continuous representation of its past is denoted hippo $( \\omega )$ , and was shown to have the form of equation (1) in three special cases. However, these matrices are non-trainable in the sense that no other $A$ matrices were known to be hippo operators. ",
+        "bbox": [
+            174,
+            642,
+            825,
+            726
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To address this, we theoretically resolve the open question from [24], showing that hippo $( \\omega )$ for any measure $\\omega ^ { \\mathrm { ~ 1 ~ } }$ results in (1) with a structured matrix $A$ . ",
+        "bbox": [
+            173,
+            732,
+            823,
+            761
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Theorem 1 (Informal). For an arbitrary measure $\\omega$ , the optimal memorization operator hippo $( \\omega )$ has the form ${ \\dot { x } } ( t ) = A x ( t ) + B u ( t )$ (1) for $a$ low recurrence-width (LRW) [17] state matrix A. ",
+        "bbox": [
+            171,
+            763,
+            825,
+            792
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For measures covering the classical orthogonal polynomials (OPs) [52] (in particular, corresponding to Jacobi and Laguerre polynomials), there is even more structure. ",
+        "bbox": [
+            169,
+            803,
+            823,
+            830
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Corollary 4.1. For $\\omega$ corresponding to the classical $O P s ,$ , hippo $( \\omega )$ is 3-quasiseparable. ",
+        "bbox": [
+            171,
+            834,
+            754,
+            849
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Although beyond the scope of this section, we mention that LRW matrices are a type of structured matrix that have linear MVM [17]. In Appendix $\\mathrm { D }$ we define this class and prove Theorem 1. Quasi",
+        "bbox": [
+            176,
+            859,
+            826,
+            888
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "separable matrices are a related class of structured matrices with additional algorithmic properties.   \nWe define these matrices in Definition 4 and prove Corollary 4.1 in Appendix D.3. ",
+        "bbox": [
+            171,
+            90,
+            825,
+            119
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Theorem 1 tells us that a LSSL that uses a state matrix $A$ within a particular class of structured matrices would carry the theoretical interpretation of continuous-time memorization. Ideally, we would be able to automatically learn the best $A$ within this class; however, this runs into computational challenges which we address next (Section 4.2). For now, we define the LSSL-fixed or LSSL-f to be one where the $A$ matrix is fixed to one of the HiPPO matrices prescribed by [24]. ",
+        "bbox": [
+            174,
+            126,
+            825,
+            195
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 Theoretically Efficient Algorithms for the LSSL ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            213,
+            544,
+            229
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Although $A$ and $\\Delta t$ are the most critical parameters of an LSSL which govern the state-space (c.f. Section 4.1) and timescale (Sections 2 and 3.2), they are not feasible to train in a naive LSSL. In particular, Section 3.1 noted that it would require efficient matrix-vector multiplication (MVM) and Krylov function (7) for $\\overline { { A } }$ to compute the recurrent and convolutional views, respectively. However, the former seems to involve a matrix inversion (3), while the latter seems to require powering $\\overline { { A } }$ up $L$ times. ",
+        "bbox": [
+            174,
+            241,
+            826,
+            327
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this section, we show that the same restriction of $A$ to the class of quasiseparable (Corollary 4.1), which gives an LSSL the ability to theoretically remember long dependencies, simultaneously grants it computational efficiency. ",
+        "bbox": [
+            174,
+            333,
+            825,
+            375
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "First of all, it is known that quasiseparable matrices have efficient (linear-time) MVM [40]. We show that they also have fast Krylov functions, allowing efficient training with convolutions. ",
+        "bbox": [
+            173,
+            381,
+            823,
+            410
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Theorem 2. For any $k$ -quasiseparable matrix $A$ (with constant $k$ ) and arbitrary $B , C _ { i }$ , the Krylov function $\\mathcal { K } _ { L } ( A , B , C )$ can be computed in quasi-linear time and space $\\tilde { O } ( N + L )$ and logarithmic depth (i.e., is parallelizable). The operation count is in an exact arithmetic model, not accounting for bit complexity or numerical stability. ",
+        "bbox": [
+            173,
+            415,
+            825,
+            473
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We remark that Theorem 2 is non-obvious. To illustrate, it is easy to see that unrolling (7) for a general matrix $A$ takes time $L N ^ { 2 }$ . Even if $A$ is extremely structured with linear computation, it requires $L N$ operations and linear depth. The depth can be reduced with the squaring technique (batch multiply by ${ \\bar { A } } , A ^ { 2 } , A ^ { 4 } , \\ldots )$ , but this then requires $L N$ intermediate storage. In fact, the algorithm for Theorem 2 is quite sophisticated (Appendix E) and involves a divide-and-conquer recursion over matrices of polynomials, using the observation that (7) is related to the power series $C ( I - A x ) ^ { - 1 } B$ . ",
+        "bbox": [
+            174,
+            484,
+            825,
+            568
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Unless specified otherwise, the full LSSL refers to an LSSL with $A$ satisfying Corollary 4.1. In conclusion, learning within this structured matrix family simultaneously endows LSSLs with longrange memory through Theorem 1 and is theoretically computationally feasible through Theorem 2. We note the caveat that Theorem 2 is over exact arithmetic and not floating point numbers, and thus is treated more as a proof of concept that LSSLs can be computationally efficient in theory. We comment more on the limitations of the LSSL in Section 6. ",
+        "bbox": [
+            174,
+            574,
+            825,
+            657
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5 Empirical Evaluation ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            679,
+            385,
+            696
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We test LSSLs empirically on a range of time series datasets with sequences from length 160 up to 38000 (Sections 5.1 and 5.2), where they substantially improve over prior work. We additionally validate the computational and modeling benefits of LSSLs from generalizing all three main model families (Section 5.3), and analyze the benefits of incorporating principled memory representations that can be learned (Section 5.4). ",
+        "bbox": [
+            174,
+            712,
+            825,
+            782
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Baselines. Our tasks have extensive prior work and we evaluate against previously reported best results. We highlight our primary baselines, three very recent works explicitly designed for long sequences: CKConv (a continuous-time CNN) [44], UnICORNN (an ODE-inspired RNN) [47], and Neural Controlled/Rough Differential Equations (NCDE/NRDE) (a sophisticated NDE) [31, 37]. These are the only models we are aware of that have experimented with sequences of length ${ \\mathrm { > } } 1 0 \\mathrm { k }$ . ",
+        "bbox": [
+            174,
+            799,
+            825,
+            869
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.1 Image and Time Series Benchmarks ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            888,
+            464,
+            904
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/a0c1ee0c8a61237f716db61a1e312b6cd64aa25d8714720d529bd578535c9b1c.jpg",
+        "table_caption": [
+            "Table 1: (Pixel-by-pixel image classification.) (Top) our methods. (Middle) recurrent baselines. (Bottom) convolutional $^ +$ other baselines. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>sMNIST</td><td>pMNIST</td><td>sCIFAR</td></tr><tr><td>LSSL</td><td>99.53</td><td>98.76</td><td>84.65</td></tr><tr><td>LSSL-fixed</td><td>99.50</td><td>98.60</td><td>81.97</td></tr><tr><td>LipschitzRNN</td><td>99.4</td><td>96.3</td><td>64.2</td></tr><tr><td>LMUFFT[12]</td><td>-</td><td>98.49</td><td>-</td></tr><tr><td>UNIcoRNN [47]</td><td>=</td><td>98.4</td><td>1</td></tr><tr><td>HiPPO-RNN [24]</td><td>98.9</td><td>98.3</td><td>61.1</td></tr><tr><td>URGRU [25]</td><td>99.27</td><td>96.51</td><td>74.4</td></tr><tr><td>IndRNN [34]</td><td>99.0</td><td>96.0</td><td>1</td></tr><tr><td>Dilated RNN [8]</td><td>98.0</td><td>96.1</td><td>=</td></tr><tr><td>r-LSTM [56]</td><td>98.4</td><td>95.2</td><td>72.2</td></tr><tr><td>CKConv [44]</td><td>99.32</td><td>98.54</td><td>63.74</td></tr><tr><td>TrellisNet [4]</td><td>99.20</td><td>98.13</td><td>73.42</td></tr><tr><td>TCN [3]</td><td>99.0</td><td>97.2</td><td>1</td></tr><tr><td>Transformer [56]</td><td>98.9</td><td>97.9</td><td>62.2</td></tr></table>",
+        "bbox": [
+            173,
+            135,
+            495,
+            352
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/b6ae7158a1368b3fc579d0066105ea49943564b019318a5454df021a4c791665.jpg",
+        "table_caption": [
+            "Table 2: (Vital signs prediction.) RMSE for predicting respiratory rate (RR), heart rate (HR), and blood oxygen (SpO2). \\* indicates our own runs to complete results for the strongest baselines. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>RR</td><td>HR</td><td>SpO2</td></tr><tr><td>LSSL</td><td>0.350</td><td>0.432</td><td>0.141</td></tr><tr><td>LSSL-fixed</td><td>0.378</td><td>0.561</td><td>0.221</td></tr><tr><td>UnICORNN [47]</td><td>1.06</td><td>1.39</td><td>0.869*</td></tr><tr><td>coRNN [47]</td><td>1.45</td><td>1.81</td><td>-</td></tr><tr><td>CKConv</td><td>1.214*</td><td>2.05*</td><td>1.051*</td></tr><tr><td>NRDE [37]</td><td>1.49</td><td>2.97</td><td>1.29</td></tr><tr><td>IndRNN [47]</td><td>1.47</td><td>2.1</td><td>-</td></tr><tr><td>expRNN [47]</td><td>1.57</td><td>1.87</td><td>-</td></tr><tr><td>LSTM</td><td>2.28</td><td>10.7</td><td>=</td></tr><tr><td>Transformer</td><td>2.61*</td><td>12.2*</td><td>3.02*</td></tr><tr><td>XGBoost [55]</td><td>1.67</td><td>4.72</td><td>1.52</td></tr><tr><td>Random Forest [55]</td><td>1.85</td><td>5.69</td><td>1.74</td></tr><tr><td>Ridge Regress. [55]</td><td>3.86</td><td>17.3</td><td>4.16</td></tr></table>",
+        "bbox": [
+            529,
+            147,
+            823,
+            352
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/2c90ccca19ad02ebcc3350137398f629aa3a43db4f8326d7f8f3bbd69f345415.jpg",
+        "table_caption": [
+            "Table 3: (Sequential CelebA Classification.) "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"2\">LSSL-f ResNet</td></tr><tr><td>Att.</td><td>78.89 81.35</td></tr><tr><td>MSO 92.36</td><td>93.92</td></tr><tr><td>Smil.</td><td>90.95 92.89</td></tr><tr><td>WL</td><td>90.57 93.25</td></tr></table>",
+        "bbox": [
+            658,
+            397,
+            825,
+            474
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We test on the sequential MNIST, permuted MNIST, and sequential CIFAR tasks (Table 1), popular benchmarks which were originally designed to test the ability of recurrent models to capture long-term dependencies of length up to 1k [2]. LSSL sets SoTA on sCIFAR by more than 10 points. We note that all results were achieved with at least 5x fewer parameters than the previous SoTA (Appendix F). ",
+        "bbox": [
+            174,
+            382,
+            647,
+            465
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We additionally use the BDIMC healthcare datasets (Table 2), a suite of widely studied time series regression problems of length 4000 on estimating vital signs. LSSL reduces RMSE by more than two-thirds on all datasets. ",
+        "bbox": [
+            174,
+            472,
+            722,
+            513
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.2 Speech and Image Classification for Very Long Time Series ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            534,
+            620,
+            549
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Raw speech is challenging for ML models due to high-frequency sampling resulting in very long sequences. Traditional systems involve complex pipelines that require feeding mixed-and-matched hand-crafted features into DNNs [42]. Table 4 reports results for the Speech Commands (SC) dataset [31] for classification of 1-second audio clips. Few methods have made progress on the raw speech signal, instead requiring pre-processing with standard mel-frequency cepstrum coefficients (MFCC). By contrast, LSSL sets SoTA on this dataset while training on the raw signal. We note that MFCC extracts sliding window frequency coefficients and thus is related to the coefficients $x ( t )$ defined by LSSL-f (Section 2, Section 4.1, [24], Appendix D). Consequently, LSSL may be interpreted as automatically learning MFCC-type features in a trainable basis. ",
+        "bbox": [
+            174,
+            560,
+            825,
+            685
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "To stress-test the LSSL’s ability to handle extremely long sequences, we create a challenging new sequential-CelebA task, where we classify $1 7 8 \\times 2 1 8$ images $\\mathbf { \\mu } = 3 8 0 0 0$ -length sequences for 4 facial attributes: Attractive (Att.), Mouth Slightly Open (MSO), Smiling (Smil.), Wearing Lipstick (WL) [36]. We chose the 4 most class-balanced attributes to avoid well-known problems with class imbalance. LSSL-f comes close to matching the performance of a specialized ResNet-18 image classification architecture that has $1 0 \\times$ the parameters (Table 3). We emphasize we are the first to demonstrate that this is possible to do with a generic sequence model. ",
+        "bbox": [
+            174,
+            691,
+            825,
+            789
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.3 Advantages of Recurrent, Convolutional, and Continuous-time Models ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            808,
+            702,
+            823
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We validate that the generality of LSSLs endows it with the strengths of all three families. ",
+        "bbox": [
+            173,
+            835,
+            759,
+            849
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Convergence Speed. As a recurrent and NDE model that incorporates new theory for continuoustime memory (Section 4.1), the LSSL has strong inductive bias for sequential data, and converges rapidly to SoTA results on our benchmarks. With its convolutional view, training can be parallelized and it is also computationally efficient in practice. Table 5 compares the time it takes the LSSL-f to achieve SoTA, in either sample (measured by epochs) or computational (measured by wall clock) complexity. In all cases, LSSLs reached the target in a fraction of the time of the previous model. ",
+        "bbox": [
+            176,
+            856,
+            825,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/0839f7b63cdbb5b2c0abf8efa07be474802686d09348e611e19f56338002fc6e.jpg",
+        "table_caption": [
+            "Table 4: (Raw Speech Classification; Timescale Shift.) (Top): Raw signals (length 16000); $1  f$ indicates test-time change in sampling rate by a factor of $f$ . (Bottom): Pre-processed MFCC features used in prior work (length 161). $\\pmb { \\chi }$ denotes computationally infeasible. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>LSSL</td><td>LSSL-f</td><td>CKConv</td><td>UnICORNN</td><td>N(C/R)DE</td><td>ODE-RNN [45]</td><td>GRU-ODE [16]</td></tr><tr><td>1→1</td><td>95.87</td><td>90.64</td><td>71.66</td><td>11.02</td><td>16.49</td><td>X</td><td>X</td></tr><tr><td>1</td><td>88.66</td><td>78.01</td><td>65.96</td><td>11.07</td><td>15.12</td><td>X</td><td>X</td></tr><tr><td>MFCC</td><td>93.58</td><td>92.55</td><td>95.3</td><td>90.64</td><td>89.8</td><td>65.9</td><td>47.9</td></tr></table>",
+        "bbox": [
+            176,
+            136,
+            818,
+            209
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/5e7d762f841076429af4e7ff68c2d20a9426fd0476b73bc02820c7f460dbff29.jpg",
+        "table_caption": [
+            "Table 5: (Modeling and Computational Benefits of LSSLs.) In each benchmark category, we compare the number of epochs (ep.) it takes a LSSL-f to reach the previous SoTA (PSoTA) results as well as a near-SoTA target. We also report the wall clock time it took to reach PSoTA relative to the previous best model. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"3\">Permuted MNIST</td><td colspan=\"3\">BDIMC Heart Rate</td><td colspan=\"3\">Speech Commands RAW</td></tr><tr><td></td><td>98% Acc.</td><td>PSoTA</td><td>Time</td><td>1.5 RMSE</td><td>PSoTA</td><td>Time</td><td>65% Acc.</td><td>PSoTA</td><td>Time</td></tr><tr><td>LSSL-fixed</td><td>16 ep.</td><td>104 ep.</td><td>0.19×</td><td>9ep.</td><td>10 ep.</td><td>0.07×</td><td>9ep.</td><td>10 ep.</td><td>0.14×</td></tr><tr><td>CKConv</td><td>118ep.</td><td>200ep.</td><td>1.0×</td><td>X</td><td>X</td><td>X</td><td>188 ep.</td><td>280ep.</td><td>1.0×</td></tr><tr><td>UnICORNN</td><td>75 ep.</td><td>×</td><td>×</td><td>116 ep.</td><td>467 ep.</td><td>1.0×</td><td>X</td><td>×</td><td>X</td></tr></table>",
+        "bbox": [
+            173,
+            270,
+            825,
+            352
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            380,
+            823,
+            407
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Timescale Adaptation. Table 4 also reports the results of continuous-time models that are able to handle unique settings such as missing data in time series, or test-time shift in timescale (we note that this is a realistic problem, e.g., when deployed healthcare models are tested on EEG signals that are sampled at a different rate [48, 49]). We note that many of these baselines were custom designed for such settings, which is of independent interest. On the other hand, LSSLs perform timescale adaptation by simply changing its $\\Delta t$ values at inference time, while still outperforming the performance of prior methods with no shift. Additional results on the CharacterTrajectories dataset from prior work [31, 44] are in Appendix F, where LSSL is competitive with the best baselines. ",
+        "bbox": [
+            174,
+            414,
+            825,
+            525
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.4 LSSL Ablations: Learning the Memory Dynamics and Timescale ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            541,
+            665,
+            558
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We demonstrate that the $\\Delta t$ and $A$ parameters, which LSSLs are able to automatically learn in contrast to prior work, are indeed critical to the performance of these continuous-time models. We note that learning $\\Delta t$ adds only $O ( H )$ parameters and learning $A$ adds $O ( N )$ parameters, adding less than $1 \\%$ parameter count compared to the base models with $O ( H N )$ parameters. ",
+        "bbox": [
+            174,
+            568,
+            825,
+            625
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Memory dynamics $A$ . We validate that vanilla LSSLs suffer from the modeling issues described in Section 4. We tested that LSSLs with random $A$ matrices (normalized appropriately) perform very poorly (e.g., $62 \\%$ on pMNIST). Further, we note the consistent increase in performance from LSSL-f to LSSL despite the negligible parameter difference. These ablations show that (i) incorporating the theory of Theorem 1 is actually necessary for LSSLs, and (ii) further training the structured $A$ is additionally helpful, which can be interpreted as learning the measure for memorization (Section 4.1). ",
+        "bbox": [
+            174,
+            630,
+            825,
+            713
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Timescale $\\Delta t$ . Section 3.2 showed that LSSL’s ability to learn $\\Delta t$ is its direct generalization of the critical gating mechanism of popular RNNs, which previous ODE-based RNN models [12, 24, 47, 58] cannot learn. We note that on sCIFAR, LSSL-f with poorly-specified $\\Delta t$ gets only $4 9 . 3 \\%$ accuracy. Additional results in Appendix F show that learning $\\Delta t$ alone provides an orthogonal boost to learning $A$ , and visualizes the noticeable change in $\\Delta t$ over the course of training. ",
+        "bbox": [
+            174,
+            719,
+            825,
+            790
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 Discussion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            809,
+            292,
+            827
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this work we introduced a simple and principled model (LSSL) inspired by a fundamental representation of physical systems. We showed theoretically and empirically that it generalizes and inherits the strengths of the main families of modern time series models, that its main limitations of long-term memory can be resolved with new theory on continuous-time memorization, and that it is empirically effective on difficult tasks with very long sequences. ",
+        "bbox": [
+            174,
+            842,
+            825,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Related work. The LSSL is related to several rich lines of work on recurrent, convolutional, and continuous-time models, as well as sequence models addressing long dependencies. Appendix A provides an extended related work connecting these topics. ",
+        "bbox": [
+            173,
+            90,
+            823,
+            132
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tuning. Our models are very simple, consisting of identical L(inear)SSL layers with simple positionwise non-linear modules between layers (Appendix B). Our models were able to train at much higher learning rates than baselines and were not sensitive to hyperparameters, of which we did light tuning primarily on learning rate and dropout. In contrast to previous baselines [4, 31, 44], we did not use hyperparameters for improving stability and regularization such as weight decay, gradient clipping, weight norm, input dropout, etc. While the most competitive recent works introduce at least one hyperparameter of critical importance (e.g. depth and step size [37], $\\alpha$ and $\\Delta t$ [47], $\\omega _ { 0 }$ [44]) that are difficult to tune, the LSSL-fixed has only $\\Delta t$ , which the full LSSL can even learn automatically (at the expense of speed). ",
+        "bbox": [
+            174,
+            138,
+            825,
+            263
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Limitations. Sections 1 and 3 and Fig. 1 mention that a potential benefit of having the recurrent representation of LSSLs may endow it with efficient inference. While this is theoretically possible, this work did not experiment on any applications that leverage this. Follow-up work showed that it is indeed possible in practice to speed up some applications at inference time. ",
+        "bbox": [
+            174,
+            270,
+            825,
+            327
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Theorem 2’s algorithm is sophisticated (Appendix D) and was not implemented in the first version of this work. A follow-up to this paper found that it is not numerically stable and thus not usable on hardware. Thus the algorithmic contributions in Theorem 2 serve the purpose of a proof-of-concept that fast algorithms for the LSSL do exist in other computation models (i.e., arithmetic operations instead of floating point operations), and leave an open question as to whether fast, numerically stable, and practical algorithms for the LSSL exist. ",
+        "bbox": [
+            174,
+            332,
+            825,
+            415
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "As described in Appendix B, by freezing the $A$ matrix and $\\Delta t$ timescale, the LSSL-fixed is able to be computed much faster than the full LSSL, and is comparable to prior models in practice (Table 5). However, beyond computational complexity, there is also a consideration of space efficiency. Both the LSSL and LSSL-fixed suffer from a large amount of space overhead (described in Appendix B) – using $O ( N L )$ instead of $O ( L )$ space when working on a 1D sequence of length $L$ – that essentially stems from using the latent state representation of dimension $N$ . Consequently, the LSSL can be space inefficient and we used multi-GPU training for our largest experiments (speech and high resolution images, Tables 3 and 4). ",
+        "bbox": [
+            174,
+            421,
+            826,
+            532
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "These fundamental issues with computation and space complexity were revisited and resolved in follow-up work to this paper, where a new state space model (the Structured State Space) provided a new parameterization and algorithms for state spaces. ",
+        "bbox": [
+            178,
+            539,
+            821,
+            580
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Conclusion and future work. Modern deep learning models struggle in applications with very long temporal data such as speech, videos, and medical time-series. We hope that our conceptual and technical contributions can lead to new capabilities with simple, principled, and less engineered models. We note that our pixel-level image classification experiments, which use no heuristics (batch norm, auxiliary losses) or extra information (data augmentation), perform similar to early convnet models with vastly more parameters, and is in the spirit of recent attempts at unifying data modalities with a generic sequence model [18]. Our speech results demonstrate the possibility of learning better features than hand-crafted processing pipelines used widely in speech applications. We are excited about potential downstream applications, such as training other downstream models on top of pre-trained state space features. ",
+        "bbox": [
+            174,
+            587,
+            825,
+            726
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgments ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            746,
+            303,
+            761
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We thank Arjun Desai, Ananya Kumar, Laurel Orr, Sabri Eyuboglu, Dan Fu, Mayee Chen, Sarah Hooper, Simran Arora, and Trenton Chang for helpful feedback on earlier drafts. We thank David Romero and James Morrill for discussions and additional results for baselines used in our experiments. This work was done with the support of Google Cloud credits under HAI proposals 540994170283 and 578192719349. AR and IJ are supported under NSF grant CCF-1763481. KS is supported by the Wu Tsai Neuroscience Interdisciplinary Graduate Fellowship. We gratefully acknowledge the support of NIH under No. U54EB020405 (Mobilize), NSF under Nos. CCF1763315 (Beyond Sparsity), CCF1563078 (Volume to Velocity), and 1937301 (RTML); ONR under No. N000141712266 (Unifying Weak Supervision); ONR N00014-20-1-2480: Understanding and Applying Non-Euclidean Geometry in Machine Learning; N000142012275 (NEPTUNE); the Moore Foundation, NXP, Xilinx, ",
+        "bbox": [
+            174,
+            772,
+            825,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "LETI-CEA, Intel, IBM, Microsoft, NEC, Toshiba, TSMC, ARM, Hitachi, BASF, Accenture, Ericsson, Qualcomm, Analog Devices, the Okawa Foundation, American Family Insurance, Google Cloud, Salesforce, Total, the HAI-AWS Cloud Credits for Research program, the Stanford Data Science Initiative (SDSI), and members of the Stanford DAWN project: Facebook, Google, and VMWare. The Mobilize Center is a Biomedical Technology Resource Center, funded by the NIH National Institute of Biomedical Imaging and Bioengineering through Grant P41EB027060. The U.S. Government is authorized to reproduce and distribute reprints for Governmental purposes notwithstanding any copyright notation thereon. Any opinions, findings, and conclusions or recommendations expressed in this material are those of the authors and do not necessarily reflect the views, policies, or endorsements, either expressed or implied, of NIH, ONR, or the U.S. Government. ",
+        "bbox": [
+            173,
+            90,
+            826,
+            229
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            250,
+            266,
+            266
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[1] George B. (George Brown) Arfken, Hans Jürgen Weber, and Frank E Harris. Mathematical methods for physicists : a comprehensive guide / George B. Arfken, Hans J. Weber, Frank E. Harris. Academic Press, Amsterdam, 7th ed. edition, 2013. ISBN 0-12-384654-4.   \n[2] Martin Arjovsky, Amar Shah, and Yoshua Bengio. Unitary evolution recurrent neural networks. In The International Conference on Machine Learning (ICML), pages 1120–1128, 2016.   \n[3] Shaojie Bai, J Zico Kolter, and Vladlen Koltun. An empirical evaluation of generic convolutional and recurrent networks for sequence modeling. arXiv preprint arXiv:1803.01271, 2018.   \n[4] Shaojie Bai, J Zico Kolter, and Vladlen Koltun. Trellis networks for sequence modeling. In The International Conference on Learning Representations (ICLR), 2019.   \n[5] James Bradbury, Stephen Merity, Caiming Xiong, and Richard Socher. Quasi-recurrent neural networks. arXiv preprint arXiv:1611.01576, 2016.   \n[6] John Charles Butcher and Nicolette Goodwin. Numerical methods for ordinary differential equations, volume 2. Wiley Online Library, 2008.   \n[7] Bo Chang, Minmin Chen, Eldad Haber, and Ed H Chi. Antisymmetricrnn: A dynamical system view on recurrent neural networks. In International Conference on Learning Representations, 2019.   \n[8] Shiyu Chang, Yang Zhang, Wei Han, Mo Yu, Xiaoxiao Guo, Wei Tan, Xiaodong Cui, Michael Witbrock, Mark Hasegawa-Johnson, and Thomas S Huang. Dilated recurrent neural networks. In Advances in Neural Information Processing Systems (NeurIPS), 2017.   \n[9] Zhengping Che, Sanjay Purushotham, Kyunghyun Cho, David Sontag, and Yan Liu. Recurrent neural networks for multivariate time series with missing values. Scientific reports, 8(1):1–12, 2018.   \n[10] Tian Qi Chen, Yulia Rubanova, Jesse Bettencourt, and David K Duvenaud. Neural ordinary differential equations. In Advances in neural information processing systems, pages 6571–6583, 2018.   \n[11] T. S. Chihara. An introduction to orthogonal polynomials. Dover Books on Mathematics. Dover Publications, 2011. ISBN 9780486479293.   \n[12] Narsimha Chilkuri and Chris Eliasmith. Parallelizing legendre memory unit training. The International Conference on Machine Learning (ICML), 2021.   \n[13] François Chollet. Xception: Deep learning with depthwise separable convolutions. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 1251–1258, 2017.   \n[14] Junyoung Chung, Caglar Gulcehre, KyungHyun Cho, and Yoshua Bengio. Empirical evaluation of gated recurrent neural networks on sequence modeling. arXiv preprint arXiv:1412.3555, 2014. ",
+        "bbox": [
+            173,
+            275,
+            826,
+            917
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[15] Jared Quincy Davis, Albert Gu, Tri Dao, Krzysztof Choromanski, Christopher Ré, Percy Liang, and Chelsea Finn. Catformer: Designing stable transformers via sensitivity analysis. In The International Conference on Machine Learning (ICML), 2021. ",
+        "bbox": [
+            171,
+            90,
+            823,
+            133
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[16] Edward De Brouwer, Jaak Simm, Adam Arany, and Yves Moreau. Gru-ode-bayes: Continuous modeling of sporadically-observed time series. In Advances in Neural Information Processing Systems (NeurIPS), 2019. ",
+        "bbox": [
+            173,
+            142,
+            823,
+            184
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[17] Christopher De Sa, Albert Gu, Rohan Puttagunta, Christopher Ré, and Atri Rudra. A twopronged progress in structured dense matrix vector multiplication. In Proceedings of the Twenty-Ninth Annual ACM-SIAM Symposium on Discrete Algorithms, pages 1060–1079. SIAM, 2018. ",
+        "bbox": [
+            173,
+            193,
+            826,
+            250
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[18] Alexey Dosovitskiy, Lucas Beyer, Alexander Kolesnikov, Dirk Weissenborn, Xiaohua Zhai, Thomas Unterthiner, Mostafa Dehghani, Matthias Minderer, Georg Heigold, Sylvain Gelly, et al. An image is worth 16x16 words: Transformers for image recognition at scale. arXiv preprint arXiv:2010.11929, 2020. ",
+        "bbox": [
+            173,
+            258,
+            826,
+            314
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[19] Y. Eidelman and I. Gohberg. On a new class of structured matrices. Integral Equations and Operator Theory, 34, 1999. ",
+        "bbox": [
+            171,
+            323,
+            823,
+            352
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[20] N Benjamin Erichson, Omri Azencot, Alejandro Queiruga, Liam Hodgkinson, and Michael W Mahoney. Lipschitz recurrent neural networks. In International Conference on Learning Representations, 2021. ",
+        "bbox": [
+            173,
+            361,
+            825,
+            404
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[21] Karl J Friston, Lee Harrison, and Will Penny. Dynamic causal modelling. Neuroimage, 19(4): 1273–1302, 2003. ",
+        "bbox": [
+            174,
+            411,
+            823,
+            440
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[22] Ken-ichi Funahashi and Yuichi Nakamura. Approximation of dynamical systems by continuous time recurrent neural networks. Neural networks, 6(6):801–806, 1993. ",
+        "bbox": [
+            173,
+            449,
+            821,
+            478
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[23] Gene H Golub and Charles F Van Loan. Matrix computations, volume 3. JHU press, 2013. ",
+        "bbox": [
+            174,
+            486,
+            805,
+            502
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[24] Albert Gu, Tri Dao, Stefano Ermon, Atri Rudra, and Christopher Ré. Hippo: Recurrent memory with optimal polynomial projections. In Hugo Larochelle, Marc’Aurelio Ranzato, Raia Hadsell, Maria-Florina Balcan, and Hsuan-Tien Lin, editors, Advances in Neural Information Processing Systems 33: Annual Conference on Neural Information Processing Systems 2020, NeurIPS 2020, December 6-12, 2020, virtual, 2020. URL https://proceedings.neurips. cc/paper/2020/hash/102f0bb6efb3a6128a3c750dd16729be-Abstract.html. ",
+        "bbox": [
+            173,
+            510,
+            826,
+            594
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[25] Albert Gu, Caglar Gulcehre, Tom Le Paine, Matt Hoffman, and Razvan Pascanu. Improving the gating mechanism of recurrent neural networks. In The International Conference on Machine Learning (ICML), 2020. ",
+        "bbox": [
+            174,
+            603,
+            823,
+            646
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[26] Ramin Hasani, Mathias Lechner, Alexander Amini, Lucas Liebenwein, Max Tschaikowski, Gerald Teschl, and Daniela Rus. Closed-form continuous-depth models. arXiv preprint arXiv:2106.13898, 2021. ",
+        "bbox": [
+            174,
+            654,
+            823,
+            696
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[27] Ramin Hasani, Mathias Lechner, Alexander Amini, Daniela Rus, and Radu Grosu. Liquid time-constant networks. In Proceedings of the AAAI Conference on Artificial Intelligence, 2021. ",
+        "bbox": [
+            173,
+            705,
+            825,
+            734
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[28] Sepp Hochreiter and Jürgen Schmidhuber. Long short-term memory. Neural computation, 9(8): 1735–1780, 1997. ",
+        "bbox": [
+            173,
+            742,
+            825,
+            771
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[29] Ian D Jordan, Piotr Aleksander Sokół, and Il Memming Park. Gated recurrent units viewed through the lens of continuous time dynamical systems. Frontiers in computational neuroscience, page 67, 2021. ",
+        "bbox": [
+            173,
+            780,
+            825,
+            823
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[30] Anil Kag, Ziming Zhang, and Venkatesh Saligrama. Rnns incrementally evolving on an equilibrium manifold: A panacea for vanishing and exploding gradients? In International Conference on Learning Representations, 2020. ",
+        "bbox": [
+            174,
+            832,
+            823,
+            875
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[31] Patrick Kidger, James Morrill, James Foster, and Terry Lyons. Neural controlled differential equations for irregular time series. arXiv preprint arXiv:2005.08926, 2020. ",
+        "bbox": [
+            173,
+            882,
+            820,
+            911
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[32] Mathias Lechner and Ramin Hasani. Learning long-term dependencies in irregularly-sampled time series. arXiv preprint arXiv:2006.04418, 2020.   \n[33] Tao Lei, Yu Zhang, Sida I Wang, Hui Dai, and Yoav Artzi. Simple recurrent units for highly parallelizable recurrence. arXiv preprint arXiv:1709.02755, 2017.   \n[34] Shuai Li, Wanqing Li, Chris Cook, Ce Zhu, and Yanbo Gao. Independently recurrent neural network (IndRNN): Building a longer and deeper RNN. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 5457–5466, 2018.   \n[35] Liyuan Liu, Xiaodong Liu, Jianfeng Gao, Weizhu Chen, and Jiawei Han. Understanding the difficulty of training transformers. The International Conference on Machine Learning (ICML), 2020.   \n[36] Ziwei Liu, Ping Luo, Xiaogang Wang, and Xiaoou Tang. Deep learning face attributes in the wild. In ICCV, pages 3730–3738. IEEE Computer Society, 2015. ISBN 978-1-4673-8391-2. URL http://dblp.uni-trier.de/db/conf/iccv/iccv2015.html#LiuLWT15.   \n[37] James Morrill, Cristopher Salvi, Patrick Kidger, James Foster, and Terry Lyons. Neural rough differential equations for long time series. The International Conference on Machine Learning (ICML), 2021.   \n[38] Murphy Yuezhen Niu, Lior Horesh, and Isaac Chuang. Recurrent neural networks in the eye of differential equations. arXiv preprint arXiv:1904.12933, 2019.   \n[39] Razvan Pascanu, Tomas Mikolov, and Yoshua Bengio. On the difficulty of training recurrent neural networks. In International conference on machine learning, pages 1310–1318, 2013.   \n[40] Clément Pernet. Computing with quasiseparable matrices. In Proceedings of the ACM on International Symposium on Symbolic and Algebraic Computation, pages 389–396, 2016.   \n[41] KB Petersen and MS Pedersen. The matrix cookbook, version 20121115. Technical Univ. Denmark, Kongens Lyngby, Denmark, Tech. Rep, 3274, 2012.   \n[42] M. Ravanelli, T. Parcollet, and Y. Bengio. The pytorch-kaldi speech recognition toolkit. In In Proc. of ICASSP, 2019.   \n[43] David W Romero, Robert-Jan Bruintjes, Jakub M Tomczak, Erik J Bekkers, Mark Hoogendoorn, and Jan C van Gemert. Flexconv: Continuous kernel convolutions with differentiable kernel sizes. arXiv preprint arXiv:2110.08059, 2021.   \n[44] David W Romero, Anna Kuzina, Erik J Bekkers, Jakub M Tomczak, and Mark Hoogendoorn. Ckconv: Continuous kernel convolution for sequential data. arXiv preprint arXiv:2102.02611, 2021.   \n[45] Yulia Rubanova, Tian Qi Chen, and David K Duvenaud. Latent ordinary differential equations for irregularly-sampled time series. In Advances in Neural Information Processing Systems, pages 5321–5331, 2019.   \n[46] T. Konstantin Rusch and Siddhartha Mishra. Coupled oscillatory recurrent neural network (cornn): An accurate and (gradient) stable architecture for learning long time dependencies. In International Conference on Learning Representations, 2021.   \n[47] T Konstantin Rusch and Siddhartha Mishra. Unicornn: A recurrent model for learning very long time dependencies. The International Conference on Machine Learning (ICML), 2021.   \n[48] Khaled Saab, Jared Dunnmon, Christopher Ré, Daniel Rubin, and Christopher Lee-Messer. Weak supervision as an efficient approach for automated seizure detection in electroencephalography. NPJ Digital Medicine, 3(1):1–12, 2020.   \n[49] Vinit Shah, Eva Von Weltin, Silvia Lopez, James Riley McHugh, Lillian Veloso, Meysam Golmohammadi, Iyad Obeid, and Joseph Picone. The Temple University hospital seizure detection corpus. Frontiers in neuroinformatics, 12:83, 2018.   \n[50] Jie Shen, Tao Tang, and Li-Lian Wang. Orthogonal Polynomials and Related Approximation Results, pages 47–140. Springer Berlin Heidelberg, Berlin, Heidelberg, 2011. ISBN 978- 3-540-71041-7. doi: 10.1007/978-3-540-71041-7_3. URL https://doi.org/10.1007/ 978-3-540-71041-7_3.   \n[51] Victor Shoup. A computational introduction to number theory and algebra. Cambridge university press, 2009.   \n[52] G. Szegö. Orthogonal Polynomials. Number v.23 in American Mathematical Society colloquium publications. American Mathematical Society, 1967. ISBN 9780821889527.   \n[53] G. Szego.˝ Orthogonal Polynomials. American Mathematical Society: Colloquium publications. American Mathematical Society, 1975. ISBN 9780821810231.   \n[54] Corentin Tallec and Yann Ollivier. Can recurrent neural networks warp time? In The International Conference on Learning Representations (ICLR), 2018.   \n[55] Chang Wei Tan, Christoph Bergmeir, Francois Petitjean, and Geoffrey I Webb. Time series extrinsic regression. Data Mining and Knowledge Discovery, pages 1–29, 2021. doi: https: //doi.org/10.1007/s10618-021-00745-9.   \n[56] Trieu H Trinh, Andrew M Dai, Minh-Thang Luong, and Quoc V Le. Learning longer-term dependencies in RNNs with auxiliary losses. In The International Conference on Machine Learning (ICML), 2018.   \n[57] Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Lukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Advances in Neural Information Processing Systems (NeurIPS), 2017.   \n[58] Aaron Voelker, Ivana Kajic, and Chris Eliasmith. Legendre memory units: Continuous-time ´ representation in recurrent neural networks. In Advances in Neural Information Processing Systems, pages 15544–15553, 2019.   \n[59] Robert L Williams, Douglas A Lawrence, et al. Linear state-space control systems. Wiley Online Library, 2007.   \n[60] Max A Woodbury. Inverting modified matrices. Memorandum report, 42:106, 1950.   \n[61] Guofeng Zhang, Tongwen Chen, and Xiang Chen. Performance recovery in digital implementation of analogue systems. SIAM journal on control and optimization, 45(6):2207–2223, 2007.   \n[62] Huaguang Zhang, Zhanshan Wang, and Derong Liu. A comprehensive review of stability analysis of continuous-time recurrent neural networks. IEEE Transactions on Neural Networks and Learning Systems, 25(7):1229–1262, 2014. ",
+        "bbox": [
+            169,
+            51,
+            828,
+            912
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            169,
+            90,
+            828,
+            669
+        ],
+        "page_idx": 13
+    }
+]