Add files using upload-large-folder tool

parse/train/-1AAgrS5FF/-1AAgrS5FF.md

@@ -0,0 +1,316 @@
+# ImageBART: Bidirectional Context with Multinomial Diffusion for Autoregressive Image Synthesis
+
+Patrick Esser∗ Robin Rombach∗ Andreas Blattmann∗ Björn Ommer Ludwig Maximilian University of Munich & IWR, Heidelberg University, Germany https://compvis.github.io/imagebart/
+
+# Abstract
+
+Autoregressive models and their sequential factorization of the data likelihood have recently demonstrated great potential for image representation and synthesis. Nevertheless, they incorporate image context in a linear 1D order by attending only to previously synthesized image patches above or to the left. Not only is this unidirectional, sequential bias of attention unnatural for images as it disregards large parts of a scene until synthesis is almost complete. It also processes the entire image on a single scale, thus ignoring more global contextual information up to the gist of the entire scene. As a remedy we incorporate a coarse-to-fine hierarchy of context by combining the autoregressive formulation with a multinomial diffusion process: Whereas a multistage diffusion process successively removes information to coarsen an image, we train a (short) Markov chain to invert this process. In each stage, the resulting autoregressive ImageBART model progressively incorporates context from previous stages in a coarse-to-fine manner. Experiments show greatly improved image modification capabilities over autoregressive models while also providing high-fidelity image generation, both of which are enabled through efficient training in a compressed latent space. Specifically, our approach can take unrestricted, user-provided masks into account to perform local image editing. Thus, in contrast to pure autoregressive models, it can solve free-form image inpainting and, in the case of conditional models, local, text-guided image modification without requiring mask-specific training.
+
+# 1 Introduction
+
+Spurred by the increasingly popular attention mechanism, a remarkably simple principle has driven progress in deep generative modeling over the past few years: Factorizing the likelihood of the data in an autoregressive (AR) fashion
+
+$$
+p ( \boldsymbol x ) = \prod _ { i } p _ { \boldsymbol \theta } ( x _ { i } | \boldsymbol x _ { < i } )
+$$
+
+and subsequently learning the conditional transition probabilities with an expressive neural network such as a transformer [75]. The success of this approach is evident in domains as diverse as language modeling [7], music generation [16], neural machine translation [46, 76], and (conditional) image synthesis [54, 8]. However, especially for the latter task of image synthesis, which is also the focus of this work, the high dimensionality and redundancy present in the data challenges the direct applicability of this approach.
+
+Missing Bidirectional Context Autoregressive models which represent images as a sequence from the top-left to the bottom-right have demonstrated impressive performance in sampling novel images and completing the lower half of a given image [8, 21]. However, the unidirectional, fixed ordering of sequence elements not only imposes a perceptually unnatural bias to attention in images by only considering context information from left or above. It also limits practical applicability to image modification: Imagine that you only have the lower half of an image and are looking for a completion of the upper half then these models fail at this minor variation of the completion task. The importance of contextual information from both directions [36] has also been recognized in the context of language modeling [14, 45]. However, simply allowing bidirectional context as in [14] does not provide a valid factorization of the density function for a generative model. Furthermore, the sequential sampling strategy introduces a gap between training and inference, as training relies on so-called teacher-forcing [3] (where ground truth is provided for each step) and inference is performed on previously sampled tokens. This exposure bias can introduce significant accumulations of errors during the generation process, affecting sample quality and coherence [57].
+
+Global Context & Control via Multinomial Diffusion We propose a coarse-to-fine approach that addresses the unidirectional bias of generative autoregressive models and their exposure bias as well as the lacking global context. We formulate learning the data density as a hierarchical problem. A coarser stage provides compressed contextual side information about the entire image for the autoregressive process on the next finer stage. We utilize a diffusion process to gradually eliminate information and compress the data, yielding a hierarchy of increasingly abstract and compact representations. The first scale of this approach is a discrete representation learning task (cf. [74, 58, 16, 21, 78, 56]). Subsequently, we further compress this learned representation via a fixed, multinomial diffusion process [65, 30]. We then invert this process by training a Markov chain to recover the data from this hierarchy. Each Markovian transition is modeled autoregressively but it simultaneously attends to the preceding state in the hierarchy, which provides crucial global context to each individual autoregressive step. As each of this steps can also be interpreted as learning a denoising cloze task [45], where missing tokens at the next finer stage are “refilled” with a bidirectional encoder and an autoregressive decoder, we dub our approach ImageBART.
+
+Contributions of our work Our approach tackles high-fidelity image synthesis with autoregressive models by learning to invert a fixed multinomial diffusion process in a discrete space of compact image representations to successively introduce context. This reduces both the often encountered exposure bias of AR models and also enables locally controlled, user-interactive image editing. Additionally, our model effectively handles a variety of conditional synthesis tasks and our introduced hierarchy corresponds to a successively compressed image representation. We observe that our model sample visually plausible images while still enabling a trade-off between reconstruction capability and compression rate.
+
+# 2 Related Work
+
+Latent Variable Models Among likelihood-based approaches, latent variable models represent a data distribution with the help of unobserved latent variables. For example, Variational Autoencoders (VAEs) [38, 59] encode data points into a lower dimensional latent variable with a factorized distribution. This makes them easy to sample, interpolate [44, 37] and modify [77]. In a conditional setting [39], latent variables which are independent from the conditioning lead to disentangled representations [31, 69, 48, 60, 5]. A hierarchy of latent variables [66] gives mutli-scale representations of the data. Unfortunately, even the deepest instantiations of these models [47, 71, 10] lack in sample quality compared to other generative models and are oftentimes restricted to highly regular datasets.
+
+Autoregressive Models AR models represent a distribution as a product of conditional, learnable factors via the chain rule of probability densities. While this makes them powerful models for density estimation [70, 24], their samples often lack global consistency. Especially on image data modeled with convolutional architectures [73, 62], this has been attributed to a locality bias of convolutional neural networks (CNNs) which biases the model towards strong local correlations between neighboring pixels at the expense of a proper modeling of coherence [40, 22]. This leads to samples resembling texture patterns without discernible global structure. Attempts to fix this properties by including explicit latent variables [27, 9, 22] have not been overly successful, mainly due the expressiveness of AR models, providing little incentive for learning additional latent variables.
+
+Generative Models on Improved Representations Another successful line of work first learn an improved image representation and subsequently learn a generative model for this representation [74, 12]. Most works [58, 21, 56] learn a discrete representation which is subsequently modeled autoregressively but approaches using continuous representations in combination with VAEs [12], or normalizing flows [1, 60, 20, 4, 18], exist too. Learning a compact representation enables the use of transformers for autoregressive modeling [8], which avoids the locality bias of CNNs, can be used for the synthesis of complex scenes conditioned on text as in DALL-E [56], and, when combined with adversarial learning [25], enables sampling of coherent high-resolution images [21]. However, AR modeling of a learned representation still limits applications compared to latent variable models. Their samples can still exert artifacts resulting from a sequential modeling of components, and, since these models are always trained by “teacher-forcing”, they are susceptible to an exposure bias [3, 57, 26, 63, 43].
+
+![](images/b7b317357ba825b0b6bb911e364d249117d96d5e3065512839c26052664640d0.jpg)  
+Figure 1: Overview over our approach: We first learn a compressed, discrete image representation $x _ { 1 }$ and subsequently our generative ImageBART model reverts a fixed multinomial diffusion process via a Markov Chain, where the individual transition probabilities are modeled as independent autoregressive encoder-decoder models. This introduces a coarse-to-fine hierarchy such that each individual AR model can attend to global context from its preceding scale in the hierarchy.
+
+Diffusion Probabilistic Models Diffusion probabilistic models revert a fixed, diffusion process with a learned Markov Chain [65]. Being directly applied in pixel space, however, downstream analysis reveals that these models tend to optimize subtle details of the modeled data, which have little contribution to the sample quality [29, 15], particularly hindering applications on high-resolution and -complexity datasets. By using a multinomial diffusion process [30] (recently generalized by [2]) on a compressed, discrete representation of images, we circumvent these issues. Diffusion probabilistic models require a very large number of diffusion steps in order to model the reverse process with a model distribution that factorizes over components. Because our approach uses autoregressively factorized models for the reverse process, we can reduce the required number of steps and obtain significant improvements in sampling speed and the ability to model complex datasets.
+
+# 3 Method
+
+# 3.1 Hierarchical Generative Models
+
+To tackle the difficult problem of modeling a highly complex distribution $p ( x )$ of high-dimensional images $x$ , we (i) introduce bidirectional context into an otherwise unidirectional autoregressive factorization of $p ( x )$ as in Eq. (1) and (ii) reduce the difficulty of the learning problem with a hierarchical approach. To do so, we learn a sequence of distributions $( p _ { \theta } ^ { t } ) _ { t = 0 } ^ { T }$ , such that each distribution $p _ { \theta } ^ { t - 1 }$ models a slightly more complex distribution with the help of a slightly simpler distribution $p _ { \theta } ^ { t }$ one level above. This introduces a coarse-to-fine hierarchy of image representations $x _ { 0 : T } : = ( x _ { t } ) _ { t = 0 } ^ { T }$ , such that an $x _ { t - 1 }$ is modeled conditioned on $x _ { t }$ , i.e. $x _ { t - 1 } \sim p _ { \theta } ^ { t - 1 } ( x _ { t - 1 } | x _ { t } )$ and defines a reverse Markov Chain for $x = : x _ { 0 }$ as $\begin{array} { r } { p _ { \theta } ( x _ { 0 } ) = p _ { \theta } ^ { T } ( x _ { T } ) \prod _ { t = 1 } ^ { T } p _ { \theta } ^ { t - 1 } ( x _ { t - 1 } \vert x _ { t } ) } \end{array}$ . Since our goal is to approximate the original distribution $p ( x )$ with $p _ { \theta } ( x _ { 0 } )$ , we introduce a forward Markov Chain, $\begin{array} { r } { q _ { \theta } ( x _ { 1 : T } | x _ { 0 } ) = \prod _ { t = 1 } ^ { T } q _ { \theta } ^ { t } ( x _ { t } | x _ { t - 1 } ) } \end{array}$ , to obtain a tractable upper bound on the Kullback-Leibler (KL) divergence between $p$ and $p _ { \theta }$ , $\mathbb { K L } ( p ( x _ { 0 } ) \Vert p _ { \boldsymbol \theta } ( x _ { 0 } ) ) = : K \bar { \mathcal { L } }$ , using the evidence lower bound (ELBO). With $q _ { \theta } ^ { T } ( x _ { T } | x _ { T - 1 } ) : = p _ { \theta } ^ { T } ( x _ { T } )$ , we obtain
+
+$$
+K \mathcal { L } \leq \underbrace { \mathbb { E } _ { x _ { 0 } , x _ { 1 } } \log \frac { p ( x _ { 0 } ) } { p _ { \theta } ^ { 0 } ( x _ { 0 } | x _ { 1 } ) } } _ { = : L _ { 1 } \to \mathrm { d i s c r e t e r e p r . l e a r n i n g } } + \sum _ { t = 2 } ^ { T } \underbrace { \mathbb { E } _ { x _ { 0 } , x _ { t } } \mathbb { K } \mathbb { L } ( q _ { \theta } ^ { t - 1 } ( x _ { t - 1 } | x _ { t } , x _ { 0 } ) | | p _ { \theta } ^ { t - 1 } ( x _ { t - 1 } | x _ { t } ) ) } _ { = : L _ { t } \to \mathrm { d e c o u p l e d ~ w i t h ~ d i f f u s i o n ~ p r o c e s s } }
+$$
+
+We use $L _ { 1 }$ to learn a compressed and discrete representation of images, such that subsequent stages of the hierarchy do not need to model redundant information (Sec. 3.2). With $L _ { t } , t > 1$ we learn a model that can rely on global context from a coarser representation $x _ { t }$ to model the representation $x _ { t - 1 }$ (Sec. 3.3). See Fig. 1 for an overview of the proposed model.
+
+# 3.2 Learning a compact, discrete representation for images
+
+Since the first stage of the hierarchical process is the one that operates directly on the data, we assign it a separate role. To avoid that the optimization of $L _ { t }$ $( t = 1 , \ldots , T )$ in Eq. (2) unnecessarily wastes capacity on redundant details in the input images—which is an often encountered property of pixel-based likelihood models [74, 21, 50]—we take $\begin{array} { r } { L _ { 1 } = \mathbb { E } _ { p ( x _ { 0 } ) q _ { \theta } ^ { 1 } ( x _ { 1 } | x _ { 0 } ) } \log \frac { p ( x _ { 0 } ) } { p _ { \theta } ^ { 0 } ( x _ { 0 } | x _ { 1 } ) } } \end{array}$ to be the reconstruction term for a discrete autoencoder model. This has the advantage that we can directly build on work in neural discrete representation learning, which has impressively demonstrated that discrete representations can be used for high-quality synthesis of diverse images while achieving strong compression. In particular, [49] and [21] have shown that adding an adversarial realism prior to the usual autoencoder objective helps to produce more realistic images at higher compression rates by locally trading reconstruction fidelity for realism.
+
+More specifically, we follow [21] to encode images into a low-dimensional representation which is then vector-quantized with a learned codebook of size $K$ to obtain $\{ 0 , \dotsc , \dot { K } - 1 \} ^ { h \times w } \ni x _ { 1 } \sim$ $q _ { \theta } ^ { 1 } ( x _ { 1 } | x _ { 0 } )$ deterministically as the index of the closest codebook entry. The encoder is a convolutional neural network (CNN) with four downsampling steps, such that $h = H / 1 6$ and $w = W / 1 6$ for any input image $\boldsymbol { x } _ { 0 } \in \mathbb { R } ^ { H \times W \times 3 }$ . For downstream autoregressive learning, this representation is then unrolled into a discrete sequence of length $N = h \cdot w$ . To recover an image from $x _ { 1 }$ , we utilize a CNN decoder $G$ , such that the reverse model is specified as
+
+$$
+- \log p _ { \theta } ^ { 0 } ( x _ { 0 } | x _ { 1 } ) \propto f _ { r e c } ( x _ { 0 } , G _ { \theta } ( x _ { 1 } ) ) + \log D _ { \phi } ( G _ { \theta } ( x _ { 1 } ) ) = : L _ { r e c } ( x _ { 0 } , x _ { 1 } ; \theta ) + L _ { a d v } ( x _ { 1 } ; \theta , \phi )
+$$
+
+Here, $f _ { r e c }$ denotes the perceptual similarity metric [23, 32, 19, 80] (known as LPIPS) and $D _ { \phi }$ denotes a patch-based adversarial discriminator [25]. Note that, due to the deterministic training, the likelihood in Eq. (3) is likely to be degenerate. $D _ { \phi }$ is optimized to differentiate original images $x _ { 0 }$ from their reconstruction $G _ { \theta } ( x _ { 1 } )$ using simultaneous gradient ascent, such that the objective for learning the optimal parameters $\{ \theta ^ { * } , \phi ^ { * } \}$ reads:
+
+$$
+\{ \theta ^ { * } , \phi ^ { * } \} = \arg \operatorname* { m i n } _ { \theta } \operatorname* { m a x } _ { \phi } \Big ( L _ { r e c } ( x _ { 0 } , x _ { 1 } ; \theta ) - L _ { a d v } ( x _ { 1 } ; \theta , \phi ) + \log D _ { \phi } ( x _ { 0 } ) + L _ { c b } ( \theta ) \Big )
+$$
+
+The optimization of $\theta$ via this objective includes the parameters of the encoder and decoder in addition to the parameters of the learned codebook, trained via the codebook loss $L _ { c b }$ as in [74, 21].
+
+# 3.3 Parallel learning of hierarchies
+
+Under suitable choices for $p _ { \theta } , q _ { \theta }$ , one can directly optimize these chains over $\sum _ { t } L _ { t }$ . However, the objectives $L _ { t }$ of the hierarchy levels are coupled through the forward chain $q _ { \theta }$ , which makes this optimization problem difficult. With expressive reverse models $p _ { \theta } ^ { t - 1 }$ , the latent variables $x _ { t }$ are often ignored by the model [22] and the scale of the different level-objectives can be vastly different, resulting in a lot of gradient noise that hinders the optimization [52]. In the continuous case, reweighting schemes for the objective can be derived [29] based on a connection to score matching models [67]. However, since we are working with a discrete $x _ { 1 }$ , there is no analogue available.
+
+While we could follow the approach taken for the first level and sequentially optimize over the objectives $L _ { t }$ , this is a rather slow process since each level $t - 1$ needs to be converged before we can start solving level $t$ . However, this sequential dependence is only introduced through the forward models $q _ { \theta } ^ { t }$ and since $q _ { \theta } ^ { 1 }$ already learns a strong representation, we can choose simpler and fixed, predefined forward processes for $q _ { \theta } ^ { t } , t > 1$ . The goal of these processes, i.e., generating a hierarchy of distributions by reducing information in each transition, can be readily achieved by, e.g., randomly masking [14], removing [45] or replacing [30] a fraction of the components of $x _ { t - 1 }$ .
+
+Multinomial diffusion This process of randomly replacing a fraction $\beta _ { t }$ of the components with random entries can be described as a multinomial diffusion process [30], a natural generalization of binomial diffusion [65]. The only parameter $\theta$ of $q _ { \theta } ^ { t }$ is therefore $\beta _ { t }$ , which we consider to be fixed. Using the standard basis $e ( k ) = ( \delta _ { j k } ) _ { j = 1 } ^ { K }$ , the forward process can be written as a product of categorical distributions $\mathcal { C }$ specified in terms of the probabilities over the codebook indices:
+
+$$
+q _ { \theta } ^ { t } ( x _ { t } | x _ { t - 1 } ) = \prod _ { i = 1 } ^ { N } { \mathcal { C } } ( x _ { t } ^ { i } | ( 1 - \beta _ { t } ) e ( x _ { t - 1 } ^ { i } ) + \beta _ { t } \mathbb { 1 } / K ) , \quad t > 1
+$$
+
+where $\mathbb { 1 } = ( 1 ) _ { j = 1 } ^ { K }$ is the all one vector. It then follows that after $t - 1$ steps, on average, a fraction of $\begin{array} { r } { \bar { \alpha } _ { t } : = \prod _ { l = 2 } ^ { t } ( 1 - \beta _ { t } ) } \end{array}$ entries from $x _ { 1 }$ remain unchanged in $x _ { t }$ , i.e.
+
+$$
+q _ { \theta } ^ { t } \big ( x _ { t } | x _ { 1 } \big ) = \prod _ { i = 1 } ^ { N } \mathcal { C } \big ( x _ { t } ^ { i } | \bar { \alpha } _ { t } e \big ( x _ { 1 } ^ { i } \big ) + \big ( 1 - \bar { \alpha } _ { t } \big ) \mathbb { 1 } / K \big ) , \quad t > 1 .
+$$
+
+This enables computation of the posterior $\begin{array} { r } { q _ { \theta } ( x _ { t - 1 } \vert x _ { t } , x _ { 1 } ) = \frac { q _ { \theta } ^ { t } ( x _ { t } \vert x _ { t - 1 } ) q _ { \theta } ( x _ { t - 1 } \vert x _ { 1 } ) } { q _ { \theta } ( x _ { t } \vert x _ { 1 } ) } } \end{array}$ for $t > 2$ , and, using the fact that $q _ { \theta } ^ { 1 }$ is deterministic, we can rewrite $L _ { t }$ as
+
+$$
+\mathbb { E } _ { p ( x _ { 0 } ) } \mathbb { E } _ { q _ { \theta } ( x _ { t } | x _ { 1 } ) } \mathbb { K L } \big ( q _ { \theta } ^ { t - 1 } ( x _ { t - 1 } | x _ { t } , x _ { 1 } ) \| p _ { \theta } ^ { t - 1 } ( x _ { t - 1 } | x _ { t } ) \big ) , \quad t > 2
+$$
+
+such that the KL term can now be computed analytically for $t > 2$ . For $t = 2$ , we use a single sample Monte-Carlo estimate for the maximum likelihood reformulation, i.e.
+
+$$
+\begin{array} { r } { \arg \operatorname* { m i n } L _ { 2 } = \arg \operatorname* { m a x } \mathbb { E } _ { p ( x _ { 0 } ) } \mathbb { E } _ { q _ { \theta } ^ { 2 } ( x _ { 2 } | x _ { 1 } ) } \log p _ { \theta } ^ { 1 } ( x _ { 1 } | x _ { 2 } ) . } \end{array}
+$$
+
+Finally, we set $p _ { \theta } ^ { T }$ to be a uniform distribution. This completes the definition of the reverse chain $p _ { \theta }$ , which can now be started from a random sample for $x _ { T } \sim p _ { \theta } ^ { T } ( x _ { T } )$ , denoised sequentially through $x _ { t - 1 } \sim p _ { \theta } ^ { t - 1 } ( x _ { t - 1 } | x _ { t } )$ for $t = T , \dots , 2$ , and finally be decoded to a data sample $x _ { 0 } = G ( x _ { 1 } )$ .
+
+Reverse diffusion models Under what conditions can we recover the true data distribution? By rewriting $\textstyle \sum _ { t } L _ { t }$ , we can see from
+
+$$
+\mathbb { K L } ( p ( x _ { 0 } ) \| p _ { \theta } ( x _ { 0 } ) ) \leq \sum _ { t = 1 } ^ { T } \mathbb { K L } ( q _ { \theta } ( x _ { t - 1 } | x _ { t } ) \| p _ { \theta } ^ { t - 1 } ( x _ { t - 1 } | x _ { t } ) )
+$$
+
+that this is possible as long as all reverse models are expressive enough to represent the true reverse processes defined by $q _ { \theta }$ . For the first level, we can ensure this by making $x _ { 1 }$ large enough such that the reconstruction error becomes negligible. For the diffusion process, previous image models [65, 29, 68, 30] relied on the fact that, in the limit $\beta _ { t } \to 0$ , the form of the true reverse process has the same functional form as the forward diffusion process [65, 41]. In particular, this allows modeling of the reverse process with a distribution factorized over the components. However, to make $q _ { \theta } ^ { T - 1 }$ close to a uniform distribution requires a very large $T$ (in the order of 1000 steps) with small $\beta _ { t }$ . Training such a large number of reverse models is only feasible with shared weights for the models, but this requires a delicate reweighting [29] of the objective and currently no suitable reweighting is known for the discrete case considered here.
+
+Thus, to be able to recover the true data distribution with a modest number of reverse models that can be trained fully parallel, and without weight-sharing, we model each reverse process autoregressively. We use an encoder-decoder transformer architecture [75], such that the decoder models the reverse process for $x _ { t - 1 }$ autoregressively with the help of global context obtained by cross-attending to the encoder’s representation of $x _ { t }$ as visualized in Fig. 1. Note that the need for autoregressive modeling gets reduced for small $\beta _ { t }$ , which we can adjust for by reducing the number of decoder layers compared to encoder layers. The use of the compression model described in Sec. 3.2, however, allows to utilize full-attention based transformer architectures to implement the autoregressive scales.
+
+# 4 Experiments
+
+Sec. 4.1 evaluates the quality ImageBART achieves in image synthesis. Since we especially want to increase the controllability of the generative process, we evaluate the performance of ImageBART on class- and text-conditional image generation in Sec. 4.2. The ability of our approach to attend to global context enables a new level of localized control which is not possible with previous, purely autoregressive approaches as demonstrated in Sec. 4.3. Finally, Sec. 4.4 presents ablations on model and architecture choices.
+
+![](images/6dab2543f9aa70309e45c4de1c0b6c5bdb358bb4b6b062f23c886c9bf17f6839.jpg)  
+Figure 2: Samples from our models. Top row: FFHQ, LSUN-Cats, Middle row: LSUN-Bedrooms, LSUNChurches, Bottom row: ImageNet.
+
+<table><tr><td>Method</td><td>Cats Beds</td><td>Churches</td><td></td><td>FFHQ</td><td></td><td>ImageBART</td><td>DDPM</td><td>SSDE</td></tr><tr><td>VDVAE [10]</td><td>1</td><td>1</td><td>1</td><td>28.5</td><td rowspan="2">Churches</td><td rowspan="2"></td><td rowspan="2"></td><td rowspan="2">健</td></tr><tr><td>DDPM [29]</td><td>19.75</td><td>4.90</td><td>7.89</td><td>1</td></tr><tr><td>StyleGAN2 [34]</td><td>7.25</td><td>2.35</td><td>3.86</td><td>3.8</td><td>Cats</td><td></td><td></td><td></td></tr><tr><td>BigGAN [6]</td><td>1</td><td>1</td><td>1</td><td>12.4</td><td>cIN (c14)</td><td></td><td></td><td></td></tr><tr><td>DCT[50]</td><td>1</td><td>6.40</td><td>7.56</td><td>13.06</td><td>cIN (c323)</td><td></td><td></td><td></td></tr><tr><td>TT[21]</td><td>17.31</td><td>6.35</td><td>7.81</td><td>11.4</td><td>cIN (c963)</td><td></td><td></td><td></td></tr><tr><td>ImageBART</td><td>15.09</td><td>5.51</td><td>7.32</td><td>9.57</td><td></td><td></td><td></td><td></td></tr></table>
+
+Table 1: Left: FIDs on the LSUN-{Churches,Beds,Cats} [79] and FFHQ [33] datasets. Right: Corresponding qualitative comparisons. Qualitative comparisons with TT can be found in Fig. 20 and Fig. 21
+
+# 4.1 High-Fidelity Image Synthesis with ImageBART
+
+In this section we present qualitative and quantitative results on images synthesized by our approach. We train models at resolution $2 5 6 \times 2 5 6$ for unconditional generation on FFHQ [33], LSUN -Cats, -Churches and -Bedrooms [79] and on class-conditional synthesis on ImageNet (cIN) [13].
+
+Effective Discrete Representations Learning the full hierarchy as described in Eq. (2) and without unnecessary redundancies in the data requires to first learn a strong compression model via the objective in Eq. (4). [21] demonstrated how to effectively train such a model and we directly utilize the publicly available pretrained models. For training on LSUN, we finetune an ImageNet pretrained model for one epoch on each dataset. As the majority of codebook entries remains unused, we shrink the codebook to those entries which are actually used (evaluated on the validation split of ImageNet) and assign a random entry for eventual outliers. This procedure yields an effective, compact representation on which we subsequently train ImageBART.
+
+Training Details As described in Sec. 3.3, we use an encoder-decoder structure to model the reverse Markov Chain $p _ { \theta } ^ { t - 1 } ( x _ { t - 1 } | x _ { t } ) , \ t < T ,$ , where the encoder is a bidirectional transformer model and decoder is implemented as an AR transformer. As the context for the last scale is pure noise, we employ a decoder-only variant to model $p _ { \theta } ^ { T - 1 } ( x _ { T - 1 } | x _ { T } )$ . Furthermore, to account for the different complexities of the datasets, we adjust the number of multinomial diffusion steps for each dataset accordingly. For FFHQ we choose a chain of length $T = 3$ , such that the total model consists of (i) the compression stage and (ii) $n = 2$ transformer models trained in parallel via the objective described in Eq.(7). Similarly, we set $n = 3$ for each of the LSUN models and $n = 5$ for the ImageNet model.
+
+<table><tr><td rowspan="2"></td><td colspan="4">rejection rate for cIN sampling</td></tr><tr><td>1.0</td><td>0.5</td><td>0.25</td><td>0.05</td></tr><tr><td>FID</td><td>21.19</td><td>13.12</td><td>9.77</td><td>7.44</td></tr><tr><td>IS</td><td>61.6±0.8</td><td>109.5±2.3</td><td>146.2±3.8</td><td>273.5±4.1</td></tr></table>
+
+<table><tr><td colspan="3">Text-conditional image synthesis on CC [64]</td></tr><tr><td>Method</td><td>FID↓ IS↑</td><td>CLIP-score ↑</td></tr><tr><td>TT[21]</td><td>28.86</td><td>13.11±0.43 0.20±0.03</td></tr><tr><td>ImageBART 22.61</td><td>15.27±0.59</td><td>0.23±0.03</td></tr></table>
+
+Table 2: Quantitative analysis on conditional models. Left: Results on class conditional Imagenet for different rejection rates, see also Fig, 20 in the supplemental. Right: Results of text-conditional ImageBART and comparison with TT [21] on the CC test set. Corresponding qualitative comparisons can be found in Fig. 21.
+
+![](images/23609c1e1e2babddfb1fde79cad0fb58708ff1b0cd031c8a0ccd5e01557b8c6f.jpg)  
+Figure 3: Samples from text-conditional ImageBART. Best 2 of 32 with reranking as in [56].
+
+Results For each of these settings, Fig. 2 depicts samples of size $2 5 6 \times 2 5 6$ generated with ImageBART and a single pass through the learned Markov Chain, demonstrating that our model is able to produce realistic and coherent samples. This is further confirmed by a quantitative analysis in Tab. 1, where we compare FID scores of competing likelihood-based and score-based methods such as TT [21] and DDPM [29]. Regarding other works on diffusion models such as [29] and [68] operating directly in pixel space, we observe that these approaches perform roughly equivalently well in terms of FID for datasets of low complexity (e.g. LSUN-Bedrooms and-Churches). For more complex datasets (LSUN-Cats, cIN), however, our method outperforms these pixel-based approaches, which can also be seen qualitatively on the right in Tab. 1. See Fig. 20 for a comparison on ImageNet.
+
+# 4.2 Conditional Markov Chains for Controlled Image Synthesis
+
+Being a sequence-to-sequence model, our approach allows for flexible and arbitrary conditioning by simply preprending tokens, similar to [21, 56]. More specifically, each learned transition $p _ { \theta } ^ { t - 1 } \dot { ( x } _ { t - 1 } \dot { | x _ { t } , c ) }$ , $t > 1$ of the Markov chain is then additionally conditioned on a representation $c$ e.g. a single token in the case of the class-conditional model of Sec. 4.1. Note that the compression model $p _ { \theta } ^ { 0 }$ remains unchanged.
+
+Text-to-Image Synthesis Besides class-conditional modeling on ImageNet, we also learn a textconditional model on Conceptual Captions (CC) [64, 51]. We obtain $c$ by using the publicly available tokenizer of the CLIP model [55], yielding a conditioning sequence of length 77. To model the dataset, we choose $T = 5$ and thus train $n = 4$ transformer models independently. For the $p _ { \theta } ^ { 0 }$ , we directly transfer the compression model from Sec. 4.1, trained on the ImageNet dataset.
+
+Fig. 3 visualizes synthetic samples obtained with this model for various “image-cloze” tasks. Our resulting model is able to attend to semantic variations in the conditioning sentence (e.g. a change of weather for imagery of mountains) and renders the corresponding images accordingly. In Tab. 2, we evaluate FID [28] and Inception Scores (IS) [61] to measure the quality of synthesized images, as well as cosine similarity between CLIP [55] embeddings of the text prompts and the synthesized images to measure how well the image reflects the text. ImageBART improves all metrics upon [21]. Fig. 21 in the supplement provides corresponding qualitative examples for user-defined text inputs.
+
+Resolutions Beyond $\mathbf { 2 5 6 \times 2 5 6 }$ Pixels. Our approach is not restricted to generating images of size $2 5 6 \times 2 5 6$ pixels. Although trained on a fixed resolution, we can apply our models in a patch-wise manner, where we use the sliding attention window of [21] for each scale $t > 0$ . As we now incorporate more and more global context while decoding with the Markov chain (which can be thought of as widening a noisy receptive field), ImageBART is able to render consistent images in the megapixel regime. See for example Fig. 4, where we use our text-conditional model to render an image of size $3 0 0 \times 1 8 0 0$ pixel and interpolate between two different text prompts. More examples, especially also for semantically guided synthesis, can be found in Sec. A.2.
+
+![](images/ebb58974d2f9dfea8cc6e99357c21c61ddaabeb9e2b180889e1ae338ba73eab2.jpg)  
+Figure 4: ImageBART is capable of generating high-resolution images. Here, we condition it on text prompts and interpolate between the two descriptions depicted above the image (see also Sec. 4.2).
+
+# 4.3 Beyond Conditional Models: Local Editing with Autoregressive Models
+
+Recent autoregressive approaches, which use a CNN to learn a discrete representation [74], partially alleviate the issues of pixel-wise autoregressive models by working on larger image patches. However, as we show in Fig. 5, even approaches which use adversarial learning to maximize the amount of context encoded in the discrete representation [21] cannot produce completions of the upper half of an image which are consistent with a given lower half.
+
+While our approach also models each transition autoregressively from the top-left to the bottom-right, the ability to attend to global context from the previous scale enables consistent completions of arbitrary order, e.g. right-to-left. To achieve this, we mask the diffusion process as described in Sec. A.3. For a user-specified mask $m$ (e.g. the upper half of an image as in Fig. 5), this results in a forward-backward process pt−θ $p _ { \theta } ^ { t - 1 | t - 1 , m }$ , which, by definition, leaves the unmasked context intact. The reverse process then denoises the unmasked entries to make them consistent with the given context.
+
+Fig. 5 (bottom) visualizes this mixing process, where we use a model with $T = 3$ . The first column shows the masked input. To start the process we set all masked entries to random entries. The first two columns then show (decoded) samples from the masked reverse processes $p _ { \theta } ^ { 2 , m }$ and p1,θ $p _ { \theta } ^ { 1 , m }$ , which still display inconsistencies. The remaining columns show the trajectory of the process $p _ { \theta } ^ { 1 | 1 , m }$ , which demonstrates how the model iteratively adjusts its samples according to the given context until it converges to a globally consistent sample. For illustration, we show the analog trajectory obtained with [21], but because it can only attend to unidirectional context, this trajectory is equivalent to a sequence of independent samples and therefore fails to achieve global consistency.
+
+The masked process can be used with arbitrary masks, which enables localized image editing with free, hand-drawn masks as shown in Fig. 6. Note that our model does not need to be trained specifically for this task, which also avoids generalization problems associated with training on masks [81]. Combining this property with the conditional models from Sec. 4.2 allows for especially interesting novel applications, where local image regions are modified based on user specified class or text prompts, as shown in Fig. 7.
+
+![](images/03b84378714d34185ad00d3dfa7f6d9b9d60e5564bcb7f99d99f030e1caa096c.jpg)  
+Figure 5: Without global context, AR models fail at completing upper halfs, contrasting ImageBART.
+
+![](images/798638d2e9717d750afc7165a5042aa56c5dbf030da17d3a7940b687c4221ace.jpg)  
+Figure 6: Local editing application using markov chain of length 16 on FFHQ. By incorporating bidirectional context ImageBART is able to solve this unconditional inpainting task (cf. Sec. 4.3).
+
+![](images/e36976b238d2f4e276c66ae208d9062eeb14211964ef27d411452dd127613584.jpg)  
+Figure 7: Conditionally guided inpainting results obtained from conditional ImageBART trained on the i) ImageNet (top row) and ii) Conceptual Captions (bottom row) datasets.
+
+# 4.4 Ablations
+
+On the Number of Diffusion Steps In this section we analyze the effect of varying the number of diffusion steps (denoted by $T$ ). To do so, we perform an experiment for unconditional training on the FFHQ dataset, where we train a Taming Transformers (TT) baseline (corresponding to the case $T = 2$ within our framework) with 800M parameters and three variants of ImageBART with $T = 3$ $( 2 \mathrm { x } 4 0 0 \mathrm { M } )$ , $T = 5$ $( 4 \mathrm { x } 2 0 0 \mathrm { M } )$ and $T = 9$ (8x100M), respectively. Note that for a fair comparison, all models use the same first level for compression, and we fix the number of remaining parameters to $8 0 0 \mathbf { M }$ and distribute them equally across all scales. All models were trained with the same computational budget and evaluated at the best validation checkpoint.
+
+In Tab. 3, we assess both the pure synthesis and the modification ability of ImageBART by computing FID scores on samples and modified images (in the case of upper half completion as in Fig. 5). For both tasks, we use a single pass through the reverse Markov chain. We observe that the modification performance increases monotonically with the number of scales, which highlights the improved image manipulation abilities of our approach. For unconditional generation, we observe a similar trend, although FID seems to plateau beyond $T = 5$ .
+
+Joint vs. Independent Training While it is possible to optimize Eq. (2) jointly across all scales, we found that training is more robust when training all scales independently. Besides the usual separation of training the compression model $p _ { \theta } ^ { 0 }$ and the generative model $p _ { \theta } ^ { t \geq 1 }$ , training the latter in parallel over multiple scales avoids the tedious weighting of the loss contribution from different scales; an often encountered problem in other denoising diffusion probabilistic models [29].
+
+Efficiency with Less Decoder Layers As we implement the conditional transition probabilities $p _ { \theta } ^ { t - 1 }$ with an encoder-decoder transformer architecture, we are interested in the effect of altering the ratio of encoder and decoder layers in the model. Recent work has provided evidence that it is possible to significantly reduce the number of decoder layers and thus also decrease autoregressive decoding speed while maintaining high quality [35]. We perform an experiment on LSUN-Churches, where we analyze the effect of different layer-ratios on synthesis quality (measured by FID) and on decoding speed when fixing the total number of model parameters to 200M. The results in the left part of Fig. 8 confirms that it is indeed possible to reduce the number of decoder layers while maintaining satisfactory FID scores with higher decoding efficiency. We identity a favorable trade-off between four and six decoder layers and transfer this setting to our other experiments.
+
+<table><tr><td colspan="3">Unconditional Generation</td><td colspan="3">Upper Half Completion</td></tr><tr><td>method</td><td>FID↓</td><td>IS个</td><td>method</td><td>FID↓</td><td>IS↑</td></tr><tr><td>TT(T= 2)</td><td>12.44</td><td>4.42 ± 0.05</td><td>TT(T= 2)</td><td>11.80</td><td>4.48 ± 0.10</td></tr><tr><td>ImageBART (T = 3)</td><td>12.55</td><td>3.98± 0.07</td><td>ImageBART(T= 3)</td><td>9.25</td><td>4.49 ± 0.13</td></tr><tr><td>ImageBART(T=5)</td><td>10.69</td><td>4.27 ± 0.05</td><td>ImageBART(T= 5)</td><td>6.87</td><td>4.81 ± 0.13</td></tr><tr><td>ImageBART (T = 9)</td><td>10.81</td><td>4.49 ± 0.05</td><td>ImageBART (T = 9)</td><td>6.64</td><td>4.86 ± 0.15</td></tr></table>
+
+Table 3: Assessing the effect of different $\overline { { T } }$ with a fixed number of parameters distributed equally over all scales. All models are trained on FFHQ. Left: Full image generation results. Right: Using the example of upper image completion, we evaluate the ability to complete and modifiy an image, see Sec. 4.3 and 4.4.
+
+![](images/505dcbb4d8a10672f2407a866d0081a4515c4138ff21f9ffadab74eae8b65903.jpg)  
+Figure 8: Left: Effect of number of encoder vs. decoder layers for a fixed total number of model parameters $( ( 1 9 5 \pm 5 ) M )$ , evaluated on LSUN-Churches. FIDs are evaluated w.r.t $3 \times 2 5 0 0 \mathrm { k }$ samples. The plot shows 3 standard deviations. All models are trained jointly over three scales. Right: Our model achieves better sampling performance than state of the art diffusion models (SSDE [68], DDPM [29], ADM [15]) and also approaches the inference speed of TT [21], which only consists of a single autoregressive stage. Reducing the number of scales increases inference speed at the expense of controllability. Experiments were conducted on a single NVIDIA A100 and are reported averaged over 1000 samples with a batch size of 50, evaluated on FFHQ while using the same number of trainable parameters $( 8 0 0 \mathrm { m } )$ for all AR models.
+
+Finally, we compare our model in terms of sampling speed with the recent state-of-the-art generative diffusion [29, 68] and AR models [21]. The results are summarized in Fig. 8. While consistently being faster than all pixel-based models due to training in a compressed latent space, the increase in runtime w.r.t. [21] is moderate due to the use of encoder-decoder transformers, i.e., a a decrease in pure decoder layers. If a faster runtime is desired, the speed can be further increased by reducing the number of decoder layers even more, see also the discussion in Sec. A.5.
+
+# 5 Conclusion
+
+We have proposed ImageBART, a hierarchical approach to introduce bidirectional context into autoregressive transformer models for high-fidelity controllable image synthesis. We invert a multinomial diffusion process by training a Markov chain to gradually incorporate context in a coarse-to-fine manner. Our study shows that this approach (i) introduces a natural hierarchical representation of images, with consecutive levels carrying more information than previous ones. (see also Fig. 9). (ii) It alleviates the unnatural unidirectional ordering of pure autoregressive models for image representation through global context from previous levels of the hierarchy. (iii) It enables global and local manipulation of a given input, a feat previously out-of-reach for ARMs. (iv) We additionally show that our model can be efficiently conditioned on various representations, allowing for a large class of conditional image synthesis tasks such as semantically guided generation or text-to-image synthesis.
+
+# Acknowledgments
+
+Many thanks to Phil Wang for providing https://github.com/lucidrains/x-transformers and all the other great PyTorch implementations.
+
+# Funding and Transparency Statement
+
+Funding in direct support of this work: German Research Foundation (DFG) projects 371923335 and 421703927, German Federal Ministry for Economic Affairs and Energy within the project ’KI-Absicherung - Safe AI for automated driving’.
+
+# Checklist
+
+1. For all authors...
+
+(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   
+(b) Did you describe the limitations of your work? [Yes] See supplementary.   
+(c) Did you discuss any potential negative societal impacts of your work? [Yes] See supplementary.   
+(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes]
+
+2. If you are including theoretical results...
+
+(a) Did you state the full set of assumptions of all theoretical results? [N/A] (b) Did you include complete proofs of all theoretical results? [N/A]
+
+3. If you ran experiments...
+
+(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [No] Including the code while maintaining anonymity is difficult; it will be published after deanonymization.   
+(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] We include most relevant details in the supplementary and the full code release will contain the precise values.   
+(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [Yes] Yes, wherever this does not introduce irresponsible waste of computational resources.   
+(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [Yes] The supplementary contains an overview of used hardware.
+
+4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets...
+
+(a) If your work uses existing assets, did you cite the creators? [Yes]   
+(b) Did you mention the license of the assets? [No] Licenses will be included along with the code release.   
+(c) Did you include any new assets either in the supplemental material or as a URL? [No]   
+(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A]   
+(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [Yes] See supplementary.
+
+5. If you used crowdsourcing or conducted research with human subjects...
+
+(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   
+(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   
+(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A]
+
+# References
+
+[1] R. Abdal, P. Zhu, N. J. Mitra, and P. Wonka. Styleflow: Attribute-conditioned exploration of stylegangenerated images using conditional continuous normalizing flows. ACM Trans. Graph., 40(3), May 2021. ISSN 0730-0301. doi: 10.1145/3447648. URL https://doi.org/10.1145/3447648.   
+[2] J. Austin, D. Johnson, J. Ho, D. Tarlow, and R. v. d. Berg. Structured denoising diffusion models in discrete state-spaces. arXiv preprint arXiv:2107.03006, 2021.   
+[3] S. Bengio, O. Vinyals, N. Jaitly, and N. Shazeer. Scheduled sampling for sequence prediction with recurrent neural networks. CoRR, abs/1506.03099, 2015. [4] A. Blattmann, T. Milbich, M. Dorkenwald, and B. Ommer. Behavior-driven synthesis of human dynamics. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pages 12236–12246, June 2021.   
+[5] A. Blattmann, T. Milbich, M. Dorkenwald, and B. Ommer. ipoke: Poking a still image for controlled stochastic video synthesis. In Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), pages 14707–14717, October 2021.   
+[6] A. Brock, J. Donahue, and K. Simonyan. Large scale GAN training for high fidelity natural image synthesis. In Int. Conf. Learn. Represent., 2019.   
+[7] T. B. Brown, B. Mann, N. Ryder, M. Subbiah, J. Kaplan, P. Dhariwal, A. Neelakantan, P. Shyam, G. Sastry, A. Askell, S. Agarwal, A. Herbert-Voss, G. Krueger, T. Henighan, R. Child, A. Ramesh, D. M. Ziegler, J. Wu, C. Winter, C. Hesse, M. Chen, E. Sigler, M. Litwin, S. Gray, B. Chess, J. Clark, C. Berner, S. McCandlish, A. Radford, I. Sutskever, and D. Amodei. Language models are few-shot learners. In NeurIPS, 2020. [8] M. Chen, A. Radford, R. Child, J. Wu, H. Jun, D. Luan, and I. Sutskever. Generative pretraining from pixels. In ICML, volume 119 of Proceedings of Machine Learning Research, pages 1691–1703. PMLR, 2020. [9] X. Chen, D. P. Kingma, T. Salimans, Y. Duan, P. Dhariwal, J. Schulman, I. Sutskever, and P. Abbeel. Variational lossy autoencoder. CoRR, abs/1611.02731, 2016.   
+[10] R. Child. Very deep vaes generalize autoregressive models and can outperform them on images. CoRR, abs/2011.10650, 2020.   
+[11] K. Crawford and T. Paglen. Excavating ai: The politics of training sets for machine learning, 2019. URL https://excavating.ai.   
+[12] B. Dai and D. P. Wipf. Diagnosing and enhancing VAE models. In ICLR (Poster). OpenReview.net, 2019.   
+[13] J. Deng, W. Dong, R. Socher, L. Li, K. Li, and F. Li. Imagenet: A large-scale hierarchical image database. In CVPR, pages 248–255. IEEE Computer Society, 2009.   
+[14] J. Devlin, M. Chang, K. Lee, and K. Toutanova. BERT: pre-training of deep bidirectional transformers for language understanding. CoRR, abs/1810.04805, 2018.   
+[15] P. Dhariwal and A. Nichol. Diffusion models beat gans on image synthesis. CoRR, abs/2105.05233, 2021. URL https://arxiv.org/abs/2105.05233.   
+[16] P. Dhariwal, H. Jun, C. Payne, J. W. Kim, A. Radford, and I. Sutskever. Jukebox: A generative model for music. CoRR, abs/2005.00341, 2020.   
+[17] S. Dieleman. Musings on typicality, 2020. URL https://benanne.github.io/2020/09/01/ typicality.html.   
+[18] M. Dorkenwald, T. Milbich, A. Blattmann, R. Rombach, K. G. Derpanis, and B. Ommer. Stochastic image-to-video synthesis using cinns. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pages 3742–3753, June 2021.   
+[19] A. Dosovitskiy and T. Brox. Generating images with perceptual similarity metrics based on deep networks. In NIPS, pages 658–666, 2016.   
+[20] P. Esser, R. Rombach, and B. Ommer. A disentangling invertible interpretation network for explaining latent representations. CoRR, abs/2004.13166, 2020.   
+[21] P. Esser, R. Rombach, and B. Ommer. Taming transformers for high-resolution image synthesis. CoRR, abs/2012.09841, 2020.   
+[22] J. D. Fauw, S. Dieleman, and K. Simonyan. Hierarchical autoregressive image models with auxiliary decoders. CoRR, abs/1903.04933, 2019.   
+[23] L. A. Gatys, A. S. Ecker, and M. Bethge. Image style transfer using convolutional neural networks. In CVPR, pages 2414–2423. IEEE Computer Society, 2016.   
+[24] M. Germain, K. Gregor, I. Murray, and H. Larochelle. MADE: masked autoencoder for distribution estimation. CoRR, abs/1502.03509, 2015.   
+[25] I. J. Goodfellow, J. Pouget-Abadie, M. Mirza, B. Xu, D. Warde-Farley, S. Ozair, A. C. Courville, and Y. Bengio. Generative adversarial networks. CoRR, 2014.   
+[26] A. Goyal, A. Lamb, Y. Zhang, S. Zhang, A. C. Courville, and Y. Bengio. Professor forcing: A new algorithm for training recurrent networks. In NIPS, pages 4601–4609, 2016.   
+[27] I. Gulrajani, K. Kumar, F. Ahmed, A. A. Taïga, F. Visin, D. Vázquez, and A. C. Courville. Pixelvae: A latent variable model for natural images. CoRR, abs/1611.05013, 2016.   
+[28] M. Heusel, H. Ramsauer, T. Unterthiner, B. Nessler, and S. Hochreiter. Gans trained by a two time-scale update rule converge to a local nash equilibrium. In Adv. Neural Inform. Process. Syst., pages 6626–6637, 2017.   
+[29] J. Ho, A. Jain, and P. Abbeel. Denoising diffusion probabilistic models. In NeurIPS, 2020.   
+[30] E. Hoogeboom, D. Nielsen, P. Jaini, P. Forré, and M. Welling. Argmax flows and multinomial diffusion: Towards non-autoregressive language models. CoRR, abs/2102.05379, 2021.   
+[31] A. H. Jha, S. Anand, M. Singh, and V. S. R. Veeravasarapu. Disentangling factors of variation with cycle-consistent variational auto-encoders. In ECCV (3), volume 11207 of Lecture Notes in Computer Science, pages 829–845. Springer, 2018.   
+[32] J. Johnson, A. Alahi, and L. Fei-Fei. Perceptual losses for real-time style transfer and super-resolution. In ECCV (2), volume 9906 of Lecture Notes in Computer Science, pages 694–711. Springer, 2016.   
+[33] T. Karras, S. Laine, and T. Aila. A style-based generator architecture for generative adversarial networks. In 2019 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), 2019.   
+[34] T. Karras, S. Laine, M. Aittala, J. Hellsten, J. Lehtinen, and T. Aila. Analyzing and improving the image quality of stylegan. CoRR, abs/1912.04958, 2019.   
+[35] J. Kasai, N. Pappas, H. Peng, J. Cross, and N. A. Smith. Deep encoder, shallow decoder: Reevaluating non-autoregressive machine translation, 2021.   
+[36] S. Khan, M. Naseer, M. Hayat, S. W. Zamir, F. S. Khan, and M. Shah. Transformers in vision: A survey. CoRR, abs/2101.01169, 2021.   
+[37] Y. Kilcher, A. Lucchi, and T. Hofmann. Semantic interpolation in implicit models. CoRR, abs/1710.11381, 2017.   
+[38] D. P. Kingma and M. Welling. Auto-Encoding Variational Bayes. In 2nd International Conference on Learning Representations, ICLR, 2014.   
+[39] D. P. Kingma, D. J. Rezende, S. Mohamed, and M. Welling. Semi-supervised learning with deep generative models. CoRR, abs/1406.5298, 2014.   
+[40] A. Kolesnikov and C. H. Lampert. Pixelcnn models with auxiliary variables for natural image modeling. In ICML, volume 70 of Proceedings of Machine Learning Research, pages 1905–1914. PMLR, 2017.   
+[41] A. Kolmogoroff. Über die analytischen methoden in der wahrscheinlichkeitsrechnung. Mathematische Annalen, 104:415–458, 1931. URL http://eudml.org/doc/159476.   
+[42] A. Krizhevsky. Learning multiple layers of features from tiny images. 2009.   
+[43] R. Leblond, J. Alayrac, A. Osokin, and S. Lacoste-Julien. SEARNN: training rnns with global-local losses. CoRR, abs/1706.04499, 2017.   
+[44] D. Lesniak, I. Sieradzki, and I. T. Podolak. Distribution-interpolation trade off in generative models. In ICLR (Poster). OpenReview.net, 2019.   
+[45] M. Lewis, Y. Liu, N. Goyal, M. Ghazvininejad, A. Mohamed, O. Levy, V. Stoyanov, and L. Zettlemoyer. BART: denoising sequence-to-sequence pre-training for natural language generation, translation, and comprehension. In ACL, pages 7871–7880. Association for Computational Linguistics, 2020.   
+[46] N. Li, S. Liu, Y. Liu, S. Zhao, and M. Liu. Neural speech synthesis with transformer network. In AAAI, pages 6706–6713. AAAI Press, 2019.   
+[47] L. Maaløe, M. Fraccaro, V. Liévin, and O. Winther. BIVA: A very deep hierarchy of latent variables for generative modeling. In NeurIPS, pages 6548–6558, 2019.   
+[48] M. Mathieu, J. J. Zhao, P. Sprechmann, A. Ramesh, and Y. LeCun. Disentangling factors of variation in deep representations using adversarial training. CoRR, abs/1611.03383, 2016.   
+[49] F. Mentzer, G. Toderici, M. Tschannen, and E. Agustsson. High-fidelity generative image compression. In NeurIPS, 2020.   
+[50] C. Nash, J. Menick, S. Dieleman, and P. W. Battaglia. Generating images with sparse representations. CoRR, abs/2103.03841, 2021.   
+[51] E. G. Ng, B. Pang, P. Sharma, and R. Soricut. Understanding guided image captioning performance across domains. arXiv preprint arXiv:2012.02339, 2020.   
+[52] A. Nichol and P. Dhariwal. Improved denoising diffusion probabilistic models. CoRR, abs/2102.09672, 2021.   
+[53] T. Park, M.-Y. Liu, T.-C. Wang, and J.-Y. Zhu. Semantic image synthesis with spatially-adaptive normalization. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, 2019.   
+[54] N. Parmar, A. Vaswani, J. Uszkoreit, L. Kaiser, N. Shazeer, A. Ku, and D. Tran. Image transformer. In ICML, volume 80 of Proceedings of Machine Learning Research, pages 4052–4061. PMLR, 2018.   
+[55] A. Radford, J. W. Kim, C. Hallacy, A. Ramesh, G. Goh, S. Agarwal, G. Sastry, A. Askell, P. Mishkin, J. Clark, G. Krueger, and I. Sutskever. Learning transferable visual models from natural language supervision. CoRR, abs/2103.00020, 2021.   
+[56] A. Ramesh, M. Pavlov, G. Goh, S. Gray, C. Voss, A. Radford, M. Chen, and I. Sutskever. Zero-shot text-to-image generation. CoRR, abs/2102.12092, 2021.   
+[57] M. Ranzato, S. Chopra, M. Auli, and W. Zaremba. Sequence level training with recurrent neural networks. In ICLR (Poster), 2016.   
+[58] A. Razavi, A. van den Oord, and O. Vinyals. Generating diverse high-fidelity images with VQ-VAE-2. In NeurIPS, pages 14837–14847, 2019.   
+[59] D. J. Rezende, S. Mohamed, and D. Wierstra. Stochastic backpropagation and approximate inference in deep generative models. In Proceedings of the 31st International Conference on International Conference on Machine Learning, ICML, 2014.   
+[60] R. Rombach, P. Esser, and B. Ommer. Network-to-network translation with conditional invertible neural networks. In NeurIPS, 2020.   
+[61] T. Salimans, I. Goodfellow, W. Zaremba, V. Cheung, A. Radford, and X. Chen. Improved techniques for training gans. In NIPS, 2016.   
+[62] T. Salimans, A. Karpathy, X. Chen, and D. P. Kingma. Pixelcnn $^ { + + }$ : Improving the pixelcnn with discretized logistic mixture likelihood and other modifications. CoRR, abs/1701.05517, 2017.   
+[63] F. Schmidt. Generalization in generation: A closer look at exposure bias. In NGT@EMNLP-IJCNLP, pages 157–167. Association for Computational Linguistics, 2019.   
+[64] P. Sharma, N. Ding, S. Goodman, and R. Soricut. Conceptual captions: A cleaned, hypernymed, image alt-text dataset for automatic image captioning. In Proceedings of ACL, 2018.   
+[65] J. Sohl-Dickstein, E. A. Weiss, N. Maheswaranathan, and S. Ganguli. Deep unsupervised learning using nonequilibrium thermodynamics. CoRR, abs/1503.03585, 2015.   
+[66] C. K. Sønderby, T. Raiko, L. Maaløe, S. K. Sønderby, and O. Winther. Ladder variational autoencoders. In NIPS, pages 3738–3746, 2016.   
+[67] Y. Song and S. Ermon. Generative modeling by estimating gradients of the data distribution. In NeurIPS, pages 11895–11907, 2019.   
+[68] Y. Song, J. Sohl-Dickstein, D. P. Kingma, A. Kumar, S. Ermon, and B. Poole. Score-based generative modeling through stochastic differential equations. CoRR, abs/2011.13456, 2020.   
+[69] A. Szabó, Q. Hu, T. Portenier, M. Zwicker, and P. Favaro. Challenges in disentangling independent factors of variation. In ICLR (Workshop). OpenReview.net, 2018.   
+[70] B. Uria, M. Côté, K. Gregor, I. Murray, and H. Larochelle. Neural autoregressive distribution estimation. CoRR, abs/1605.02226, 2016.   
+[71] A. Vahdat and J. Kautz. NVAE: A deep hierarchical variational autoencoder. In NeurIPS, 2020.   
+[72] A. van den Oord, N. Kalchbrenner, L. Espeholt, k. kavukcuoglu, O. Vinyals, and A. Graves. Conditional image generation with pixelcnn decoders. In Advances in Neural Information Processing Systems, 2016.   
+[73] A. van den Oord, N. Kalchbrenner, O. Vinyals, L. Espeholt, A. Graves, and K. Kavukcuoglu. Conditional image generation with pixelcnn decoders. CoRR, abs/1606.05328, 2016.   
+[74] A. van den Oord, O. Vinyals, and K. Kavukcuoglu. Neural discrete representation learning. In NIPS, pages 6306–6315, 2017.   
+[75] A. Vaswani, N. Shazeer, N. Parmar, J. Uszkoreit, L. Jones, A. N. Gomez, L. Kaiser, and I. Polosukhin. Attention is all you need. In NIPS, pages 5998–6008, 2017.   
+[76] C. Wang, Y. Tang, X. Ma, A. Wu, D. Okhonko, and J. Pino. fairseq s2t: Fast speech-to-text modeling with fairseq, 2020.   
+[77] T. White. Sampling generative networks: Notes on a few effective techniques. CoRR, abs/1609.04468, 2016.   
+[78] W. Yan, Y. Zhang, P. Abbeel, and A. Srinivas. Videogpt: Video generation using VQ-VAE and transformers. CoRR, abs/2104.10157, 2021.   
+[79] F. Yu, Y. Zhang, S. Song, A. Seff, and J. Xiao. LSUN: construction of a large-scale image dataset using deep learning with humans in the loop. CoRR, abs/1506.03365, 2015.   
+[80] R. Zhang, P. Isola, A. A. Efros, E. Shechtman, and O. Wang. The unreasonable effectiveness of deep features as a perceptual metric. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2018.   
+[81] C. Zheng, T. Cham, and J. Cai. Tfill: Image completion via a transformer-based architecture. CoRR, abs/2104.00845, 2021.

parse/train/-1AAgrS5FF/-1AAgrS5FF_content_list.json

@@ -0,0 +1,1274 @@
+[
+    {
+        "type": "text",
+        "text": "ImageBART: Bidirectional Context with Multinomial Diffusion for Autoregressive Image Synthesis ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            122,
+            820,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Patrick Esser∗ Robin Rombach∗ Andreas Blattmann∗ Björn Ommer Ludwig Maximilian University of Munich & IWR, Heidelberg University, Germany https://compvis.github.io/imagebart/ ",
+        "bbox": [
+            214,
+            226,
+            782,
+            268
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            303,
+            535,
+            320
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Autoregressive models and their sequential factorization of the data likelihood have recently demonstrated great potential for image representation and synthesis. Nevertheless, they incorporate image context in a linear 1D order by attending only to previously synthesized image patches above or to the left. Not only is this unidirectional, sequential bias of attention unnatural for images as it disregards large parts of a scene until synthesis is almost complete. It also processes the entire image on a single scale, thus ignoring more global contextual information up to the gist of the entire scene. As a remedy we incorporate a coarse-to-fine hierarchy of context by combining the autoregressive formulation with a multinomial diffusion process: Whereas a multistage diffusion process successively removes information to coarsen an image, we train a (short) Markov chain to invert this process. In each stage, the resulting autoregressive ImageBART model progressively incorporates context from previous stages in a coarse-to-fine manner. Experiments show greatly improved image modification capabilities over autoregressive models while also providing high-fidelity image generation, both of which are enabled through efficient training in a compressed latent space. Specifically, our approach can take unrestricted, user-provided masks into account to perform local image editing. Thus, in contrast to pure autoregressive models, it can solve free-form image inpainting and, in the case of conditional models, local, text-guided image modification without requiring mask-specific training. ",
+        "bbox": [
+            232,
+            334,
+            766,
+            612
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            637,
+            312,
+            655
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Spurred by the increasingly popular attention mechanism, a remarkably simple principle has driven progress in deep generative modeling over the past few years: Factorizing the likelihood of the data in an autoregressive (AR) fashion ",
+        "bbox": [
+            176,
+            670,
+            823,
+            712
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d65c6f6ba029d829b3b83f63ee25e9bf84de02fb29d087e0995759f5d2447896.jpg",
+        "text": "$$\np ( \\boldsymbol x ) = \\prod _ { i } p _ { \\boldsymbol \\theta } ( x _ { i } | \\boldsymbol x _ { < i } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            423,
+            718,
+            575,
+            752
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "and subsequently learning the conditional transition probabilities with an expressive neural network such as a transformer [75]. The success of this approach is evident in domains as diverse as language modeling [7], music generation [16], neural machine translation [46, 76], and (conditional) image synthesis [54, 8]. However, especially for the latter task of image synthesis, which is also the focus of this work, the high dimensionality and redundancy present in the data challenges the direct applicability of this approach. ",
+        "bbox": [
+            174,
+            757,
+            823,
+            842
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Missing Bidirectional Context Autoregressive models which represent images as a sequence from the top-left to the bottom-right have demonstrated impressive performance in sampling novel images and completing the lower half of a given image [8, 21]. However, the unidirectional, fixed ordering of sequence elements not only imposes a perceptually unnatural bias to attention in images by only considering context information from left or above. It also limits practical applicability to image modification: Imagine that you only have the lower half of an image and are looking for a completion of the upper half then these models fail at this minor variation of the completion task. The importance of contextual information from both directions [36] has also been recognized in the context of language modeling [14, 45]. However, simply allowing bidirectional context as in [14] does not provide a valid factorization of the density function for a generative model. Furthermore, the sequential sampling strategy introduces a gap between training and inference, as training relies on so-called teacher-forcing [3] (where ground truth is provided for each step) and inference is performed on previously sampled tokens. This exposure bias can introduce significant accumulations of errors during the generation process, affecting sample quality and coherence [57]. ",
+        "bbox": [
+            174,
+            848,
+            825,
+            890
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            92,
+            825,
+            243
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Global Context & Control via Multinomial Diffusion We propose a coarse-to-fine approach that addresses the unidirectional bias of generative autoregressive models and their exposure bias as well as the lacking global context. We formulate learning the data density as a hierarchical problem. A coarser stage provides compressed contextual side information about the entire image for the autoregressive process on the next finer stage. We utilize a diffusion process to gradually eliminate information and compress the data, yielding a hierarchy of increasingly abstract and compact representations. The first scale of this approach is a discrete representation learning task (cf. [74, 58, 16, 21, 78, 56]). Subsequently, we further compress this learned representation via a fixed, multinomial diffusion process [65, 30]. We then invert this process by training a Markov chain to recover the data from this hierarchy. Each Markovian transition is modeled autoregressively but it simultaneously attends to the preceding state in the hierarchy, which provides crucial global context to each individual autoregressive step. As each of this steps can also be interpreted as learning a denoising cloze task [45], where missing tokens at the next finer stage are “refilled” with a bidirectional encoder and an autoregressive decoder, we dub our approach ImageBART. ",
+        "bbox": [
+            174,
+            250,
+            825,
+            443
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Contributions of our work Our approach tackles high-fidelity image synthesis with autoregressive models by learning to invert a fixed multinomial diffusion process in a discrete space of compact image representations to successively introduce context. This reduces both the often encountered exposure bias of AR models and also enables locally controlled, user-interactive image editing. Additionally, our model effectively handles a variety of conditional synthesis tasks and our introduced hierarchy corresponds to a successively compressed image representation. We observe that our model sample visually plausible images while still enabling a trade-off between reconstruction capability and compression rate. ",
+        "bbox": [
+            174,
+            449,
+            825,
+            560
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            585,
+            321,
+            603
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Latent Variable Models Among likelihood-based approaches, latent variable models represent a data distribution with the help of unobserved latent variables. For example, Variational Autoencoders (VAEs) [38, 59] encode data points into a lower dimensional latent variable with a factorized distribution. This makes them easy to sample, interpolate [44, 37] and modify [77]. In a conditional setting [39], latent variables which are independent from the conditioning lead to disentangled representations [31, 69, 48, 60, 5]. A hierarchy of latent variables [66] gives mutli-scale representations of the data. Unfortunately, even the deepest instantiations of these models [47, 71, 10] lack in sample quality compared to other generative models and are oftentimes restricted to highly regular datasets. ",
+        "bbox": [
+            174,
+            621,
+            826,
+            732
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Autoregressive Models AR models represent a distribution as a product of conditional, learnable factors via the chain rule of probability densities. While this makes them powerful models for density estimation [70, 24], their samples often lack global consistency. Especially on image data modeled with convolutional architectures [73, 62], this has been attributed to a locality bias of convolutional neural networks (CNNs) which biases the model towards strong local correlations between neighboring pixels at the expense of a proper modeling of coherence [40, 22]. This leads to samples resembling texture patterns without discernible global structure. Attempts to fix this properties by including explicit latent variables [27, 9, 22] have not been overly successful, mainly due the expressiveness of AR models, providing little incentive for learning additional latent variables. ",
+        "bbox": [
+            174,
+            738,
+            825,
+            863
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Generative Models on Improved Representations Another successful line of work first learn an improved image representation and subsequently learn a generative model for this representation [74, 12]. Most works [58, 21, 56] learn a discrete representation which is subsequently modeled autoregressively but approaches using continuous representations in combination with VAEs [12], or normalizing flows [1, 60, 20, 4, 18], exist too. Learning a compact representation enables the use of transformers for autoregressive modeling [8], which avoids the locality bias of CNNs, can be used for the synthesis of complex scenes conditioned on text as in DALL-E [56], and, when combined with adversarial learning [25], enables sampling of coherent high-resolution images [21]. However, AR modeling of a learned representation still limits applications compared to latent variable models. Their samples can still exert artifacts resulting from a sequential modeling of components, and, since these models are always trained by “teacher-forcing”, they are susceptible to an exposure bias [3, 57, 26, 63, 43]. ",
+        "bbox": [
+            174,
+            869,
+            823,
+            925
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/b7b317357ba825b0b6bb911e364d249117d96d5e3065512839c26052664640d0.jpg",
+        "image_caption": [
+            "Figure 1: Overview over our approach: We first learn a compressed, discrete image representation $x _ { 1 }$ and subsequently our generative ImageBART model reverts a fixed multinomial diffusion process via a Markov Chain, where the individual transition probabilities are modeled as independent autoregressive encoder-decoder models. This introduces a coarse-to-fine hierarchy such that each individual AR model can attend to global context from its preceding scale in the hierarchy. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            87,
+            823,
+            339
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            421,
+            825,
+            534
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Diffusion Probabilistic Models Diffusion probabilistic models revert a fixed, diffusion process with a learned Markov Chain [65]. Being directly applied in pixel space, however, downstream analysis reveals that these models tend to optimize subtle details of the modeled data, which have little contribution to the sample quality [29, 15], particularly hindering applications on high-resolution and -complexity datasets. By using a multinomial diffusion process [30] (recently generalized by [2]) on a compressed, discrete representation of images, we circumvent these issues. Diffusion probabilistic models require a very large number of diffusion steps in order to model the reverse process with a model distribution that factorizes over components. Because our approach uses autoregressively factorized models for the reverse process, we can reduce the required number of steps and obtain significant improvements in sampling speed and the ability to model complex datasets. ",
+        "bbox": [
+            173,
+            539,
+            825,
+            678
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 Method ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            696,
+            269,
+            714
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 Hierarchical Generative Models ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            728,
+            436,
+            743
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To tackle the difficult problem of modeling a highly complex distribution $p ( x )$ of high-dimensional images $x$ , we (i) introduce bidirectional context into an otherwise unidirectional autoregressive factorization of $p ( x )$ as in Eq. (1) and (ii) reduce the difficulty of the learning problem with a hierarchical approach. To do so, we learn a sequence of distributions $( p _ { \\theta } ^ { t } ) _ { t = 0 } ^ { T }$ , such that each distribution $p _ { \\theta } ^ { t - 1 }$ models a slightly more complex distribution with the help of a slightly simpler distribution $p _ { \\theta } ^ { t }$ one level above. This introduces a coarse-to-fine hierarchy of image representations $x _ { 0 : T } : = ( x _ { t } ) _ { t = 0 } ^ { T }$ , such that an $x _ { t - 1 }$ is modeled conditioned on $x _ { t }$ , i.e. $x _ { t - 1 } \\sim p _ { \\theta } ^ { t - 1 } ( x _ { t - 1 } | x _ { t } )$ and defines a reverse Markov Chain for $x = : x _ { 0 }$ as $\\begin{array} { r } { p _ { \\theta } ( x _ { 0 } ) = p _ { \\theta } ^ { T } ( x _ { T } ) \\prod _ { t = 1 } ^ { T } p _ { \\theta } ^ { t - 1 } ( x _ { t - 1 } \\vert x _ { t } ) } \\end{array}$ . Since our goal is to approximate the original distribution $p ( x )$ with $p _ { \\theta } ( x _ { 0 } )$ , we introduce a forward Markov Chain, $\\begin{array} { r } { q _ { \\theta } ( x _ { 1 : T } | x _ { 0 } ) = \\prod _ { t = 1 } ^ { T } q _ { \\theta } ^ { t } ( x _ { t } | x _ { t - 1 } ) } \\end{array}$ , to obtain a tractable upper bound on the Kullback-Leibler (KL) divergence between $p$ and $p _ { \\theta }$ , $\\mathbb { K L } ( p ( x _ { 0 } ) \\Vert p _ { \\boldsymbol \\theta } ( x _ { 0 } ) ) = : K \\bar { \\mathcal { L } }$ , using the evidence lower bound (ELBO). With $q _ { \\theta } ^ { T } ( x _ { T } | x _ { T - 1 } ) : = p _ { \\theta } ^ { T } ( x _ { T } )$ , we obtain ",
+        "bbox": [
+            173,
+            747,
+            825,
+            912
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            89,
+            513,
+            107
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fd9924a8249a7f61f8035fd61ba17cb9dc0028161f8a4d65013784031295878b.jpg",
+        "text": "$$\nK \\mathcal { L } \\leq \\underbrace { \\mathbb { E } _ { x _ { 0 } , x _ { 1 } } \\log \\frac { p ( x _ { 0 } ) } { p _ { \\theta } ^ { 0 } ( x _ { 0 } | x _ { 1 } ) } } _ { = : L _ { 1 } \\to \\mathrm { d i s c r e t e r e p r . l e a r n i n g } } + \\sum _ { t = 2 } ^ { T } \\underbrace { \\mathbb { E } _ { x _ { 0 } , x _ { t } } \\mathbb { K } \\mathbb { L } ( q _ { \\theta } ^ { t - 1 } ( x _ { t - 1 } | x _ { t } , x _ { 0 } ) | | p _ { \\theta } ^ { t - 1 } ( x _ { t - 1 } | x _ { t } ) ) } _ { = : L _ { t } \\to \\mathrm { d e c o u p l e d ~ w i t h ~ d i f f u s i o n ~ p r o c e s s } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            228,
+            112,
+            767,
+            171
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We use $L _ { 1 }$ to learn a compressed and discrete representation of images, such that subsequent stages of the hierarchy do not need to model redundant information (Sec. 3.2). With $L _ { t } , t > 1$ we learn a model that can rely on global context from a coarser representation $x _ { t }$ to model the representation $x _ { t - 1 }$ (Sec. 3.3). See Fig. 1 for an overview of the proposed model. ",
+        "bbox": [
+            176,
+            183,
+            823,
+            238
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 Learning a compact, discrete representation for images ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            255,
+            596,
+            270
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Since the first stage of the hierarchical process is the one that operates directly on the data, we assign it a separate role. To avoid that the optimization of $L _ { t }$ $( t = 1 , \\ldots , T )$ in Eq. (2) unnecessarily wastes capacity on redundant details in the input images—which is an often encountered property of pixel-based likelihood models [74, 21, 50]—we take $\\begin{array} { r } { L _ { 1 } = \\mathbb { E } _ { p ( x _ { 0 } ) q _ { \\theta } ^ { 1 } ( x _ { 1 } | x _ { 0 } ) } \\log \\frac { p ( x _ { 0 } ) } { p _ { \\theta } ^ { 0 } ( x _ { 0 } | x _ { 1 } ) } } \\end{array}$ to be the reconstruction term for a discrete autoencoder model. This has the advantage that we can directly build on work in neural discrete representation learning, which has impressively demonstrated that discrete representations can be used for high-quality synthesis of diverse images while achieving strong compression. In particular, [49] and [21] have shown that adding an adversarial realism prior to the usual autoencoder objective helps to produce more realistic images at higher compression rates by locally trading reconstruction fidelity for realism. ",
+        "bbox": [
+            173,
+            272,
+            825,
+            419
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "More specifically, we follow [21] to encode images into a low-dimensional representation which is then vector-quantized with a learned codebook of size $K$ to obtain $\\{ 0 , \\dotsc , \\dot { K } - 1 \\} ^ { h \\times w } \\ni x _ { 1 } \\sim$ $q _ { \\theta } ^ { 1 } ( x _ { 1 } | x _ { 0 } )$ deterministically as the index of the closest codebook entry. The encoder is a convolutional neural network (CNN) with four downsampling steps, such that $h = H / 1 6$ and $w = W / 1 6$ for any input image $\\boldsymbol { x } _ { 0 } \\in \\mathbb { R } ^ { H \\times W \\times 3 }$ . For downstream autoregressive learning, this representation is then unrolled into a discrete sequence of length $N = h \\cdot w$ . To recover an image from $x _ { 1 }$ , we utilize a CNN decoder $G$ , such that the reverse model is specified as ",
+        "bbox": [
+            173,
+            424,
+            825,
+            522
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/93cfaa181dd1afc549a42073b5718be3412e73b007d8b00ed44c1e6df30dc189.jpg",
+        "text": "$$\n- \\log p _ { \\theta } ^ { 0 } ( x _ { 0 } | x _ { 1 } ) \\propto f _ { r e c } ( x _ { 0 } , G _ { \\theta } ( x _ { 1 } ) ) + \\log D _ { \\phi } ( G _ { \\theta } ( x _ { 1 } ) ) = : L _ { r e c } ( x _ { 0 } , x _ { 1 } ; \\theta ) + L _ { a d v } ( x _ { 1 } ; \\theta , \\phi )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            181,
+            526,
+            795,
+            545
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Here, $f _ { r e c }$ denotes the perceptual similarity metric [23, 32, 19, 80] (known as LPIPS) and $D _ { \\phi }$ denotes a patch-based adversarial discriminator [25]. Note that, due to the deterministic training, the likelihood in Eq. (3) is likely to be degenerate. $D _ { \\phi }$ is optimized to differentiate original images $x _ { 0 }$ from their reconstruction $G _ { \\theta } ( x _ { 1 } )$ using simultaneous gradient ascent, such that the objective for learning the optimal parameters $\\{ \\theta ^ { * } , \\phi ^ { * } \\}$ reads: ",
+        "bbox": [
+            173,
+            549,
+            826,
+            619
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a6bea8878f37bad1055acd383b6974b56250ab933df0e6eab4aae7fbc1778c6e.jpg",
+        "text": "$$\n\\{ \\theta ^ { * } , \\phi ^ { * } \\} = \\arg \\operatorname* { m i n } _ { \\theta } \\operatorname* { m a x } _ { \\phi } \\Big ( L _ { r e c } ( x _ { 0 } , x _ { 1 } ; \\theta ) - L _ { a d v } ( x _ { 1 } ; \\theta , \\phi ) + \\log D _ { \\phi } ( x _ { 0 } ) + L _ { c b } ( \\theta ) \\Big )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            217,
+            625,
+            779,
+            655
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The optimization of $\\theta$ via this objective includes the parameters of the encoder and decoder in addition to the parameters of the learned codebook, trained via the codebook loss $L _ { c b }$ as in [74, 21]. ",
+        "bbox": [
+            174,
+            660,
+            826,
+            689
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.3 Parallel learning of hierarchies ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            704,
+            428,
+            719
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Under suitable choices for $p _ { \\theta } , q _ { \\theta }$ , one can directly optimize these chains over $\\sum _ { t } L _ { t }$ . However, the objectives $L _ { t }$ of the hierarchy levels are coupled through the forward chain $q _ { \\theta }$ , which makes this optimization problem difficult. With expressive reverse models $p _ { \\theta } ^ { t - 1 }$ , the latent variables $x _ { t }$ are often ignored by the model [22] and the scale of the different level-objectives can be vastly different, resulting in a lot of gradient noise that hinders the optimization [52]. In the continuous case, reweighting schemes for the objective can be derived [29] based on a connection to score matching models [67]. However, since we are working with a discrete $x _ { 1 }$ , there is no analogue available. ",
+        "bbox": [
+            173,
+            723,
+            825,
+            821
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "While we could follow the approach taken for the first level and sequentially optimize over the objectives $L _ { t }$ , this is a rather slow process since each level $t - 1$ needs to be converged before we can start solving level $t$ . However, this sequential dependence is only introduced through the forward models $q _ { \\theta } ^ { t }$ and since $q _ { \\theta } ^ { 1 }$ already learns a strong representation, we can choose simpler and fixed, predefined forward processes for $q _ { \\theta } ^ { t } , t > 1$ . The goal of these processes, i.e., generating a hierarchy of distributions by reducing information in each transition, can be readily achieved by, e.g., randomly masking [14], removing [45] or replacing [30] a fraction of the components of $x _ { t - 1 }$ . ",
+        "bbox": [
+            173,
+            827,
+            825,
+            925
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Multinomial diffusion This process of randomly replacing a fraction $\\beta _ { t }$ of the components with random entries can be described as a multinomial diffusion process [30], a natural generalization of binomial diffusion [65]. The only parameter $\\theta$ of $q _ { \\theta } ^ { t }$ is therefore $\\beta _ { t }$ , which we consider to be fixed. Using the standard basis $e ( k ) = ( \\delta _ { j k } ) _ { j = 1 } ^ { K }$ , the forward process can be written as a product of categorical distributions $\\mathcal { C }$ specified in terms of the probabilities over the codebook indices: ",
+        "bbox": [
+            174,
+            90,
+            825,
+            162
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/621cf3c92f2a7ff37a4af90a6839da99298643ce3798e46ddc3090504d3a1b14.jpg",
+        "text": "$$\nq _ { \\theta } ^ { t } ( x _ { t } | x _ { t - 1 } ) = \\prod _ { i = 1 } ^ { N } { \\mathcal { C } } ( x _ { t } ^ { i } | ( 1 - \\beta _ { t } ) e ( x _ { t - 1 } ^ { i } ) + \\beta _ { t } \\mathbb { 1 } / K ) , \\quad t > 1\n$$",
+        "text_format": "latex",
+        "bbox": [
+            297,
+            167,
+            700,
+            210
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbb { 1 } = ( 1 ) _ { j = 1 } ^ { K }$ is the all one vector. It then follows that after $t - 1$ steps, on average, a fraction of $\\begin{array} { r } { \\bar { \\alpha } _ { t } : = \\prod _ { l = 2 } ^ { t } ( 1 - \\beta _ { t } ) } \\end{array}$ entries from $x _ { 1 }$ remain unchanged in $x _ { t }$ , i.e. ",
+        "bbox": [
+            173,
+            215,
+            823,
+            251
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f8b9a745f7e5898895b688e2dcd29e47568dd38103f74bdc8d3fd2a67428d6d9.jpg",
+        "text": "$$\nq _ { \\theta } ^ { t } \\big ( x _ { t } | x _ { 1 } \\big ) = \\prod _ { i = 1 } ^ { N } \\mathcal { C } \\big ( x _ { t } ^ { i } | \\bar { \\alpha } _ { t } e \\big ( x _ { 1 } ^ { i } \\big ) + \\big ( 1 - \\bar { \\alpha } _ { t } \\big ) \\mathbb { 1 } / K \\big ) , \\quad t > 1 .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            308,
+            255,
+            691,
+            299
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "This enables computation of the posterior $\\begin{array} { r } { q _ { \\theta } ( x _ { t - 1 } \\vert x _ { t } , x _ { 1 } ) = \\frac { q _ { \\theta } ^ { t } ( x _ { t } \\vert x _ { t - 1 } ) q _ { \\theta } ( x _ { t - 1 } \\vert x _ { 1 } ) } { q _ { \\theta } ( x _ { t } \\vert x _ { 1 } ) } } \\end{array}$ for $t > 2$ , and, using the fact that $q _ { \\theta } ^ { 1 }$ is deterministic, we can rewrite $L _ { t }$ as ",
+        "bbox": [
+            174,
+            304,
+            825,
+            342
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/26875d930c5da3a41254c4aa397ff97a20fe03ad876d28ecc01c03b5bbb85953.jpg",
+        "text": "$$\n\\mathbb { E } _ { p ( x _ { 0 } ) } \\mathbb { E } _ { q _ { \\theta } ( x _ { t } | x _ { 1 } ) } \\mathbb { K L } \\big ( q _ { \\theta } ^ { t - 1 } ( x _ { t - 1 } | x _ { t } , x _ { 1 } ) \\| p _ { \\theta } ^ { t - 1 } ( x _ { t - 1 } | x _ { t } ) \\big ) , \\quad t > 2\n$$",
+        "text_format": "latex",
+        "bbox": [
+            284,
+            345,
+            714,
+            366
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "such that the KL term can now be computed analytically for $t > 2$ . For $t = 2$ , we use a single sample Monte-Carlo estimate for the maximum likelihood reformulation, i.e. ",
+        "bbox": [
+            173,
+            368,
+            823,
+            397
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/aaff8b4104a99952da3434bca204caf9ce152f90e25fe2fd67e1d336fa6313c4.jpg",
+        "text": "$$\n\\begin{array} { r } { \\arg \\operatorname* { m i n } L _ { 2 } = \\arg \\operatorname* { m a x } \\mathbb { E } _ { p ( x _ { 0 } ) } \\mathbb { E } _ { q _ { \\theta } ^ { 2 } ( x _ { 2 } | x _ { 1 } ) } \\log p _ { \\theta } ^ { 1 } ( x _ { 1 } | x _ { 2 } ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            316,
+            401,
+            679,
+            422
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Finally, we set $p _ { \\theta } ^ { T }$ to be a uniform distribution. This completes the definition of the reverse chain $p _ { \\theta }$ , which can now be started from a random sample for $x _ { T } \\sim p _ { \\theta } ^ { T } ( x _ { T } )$ , denoised sequentially through $x _ { t - 1 } \\sim p _ { \\theta } ^ { t - 1 } ( x _ { t - 1 } | x _ { t } )$ for $t = T , \\dots , 2$ , and finally be decoded to a data sample $x _ { 0 } = G ( x _ { 1 } )$ . ",
+        "bbox": [
+            173,
+            428,
+            826,
+            474
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Reverse diffusion models Under what conditions can we recover the true data distribution? By rewriting $\\textstyle \\sum _ { t } L _ { t }$ , we can see from ",
+        "bbox": [
+            173,
+            487,
+            823,
+            517
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/083b5e8546c75796710b48c54bfcc1872541da0ee186521c47d1644c3c7206e1.jpg",
+        "text": "$$\n\\mathbb { K L } ( p ( x _ { 0 } ) \\| p _ { \\theta } ( x _ { 0 } ) ) \\leq \\sum _ { t = 1 } ^ { T } \\mathbb { K L } ( q _ { \\theta } ( x _ { t - 1 } | x _ { t } ) \\| p _ { \\theta } ^ { t - 1 } ( x _ { t - 1 } | x _ { t } ) )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            300,
+            522,
+            696,
+            565
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "that this is possible as long as all reverse models are expressive enough to represent the true reverse processes defined by $q _ { \\theta }$ . For the first level, we can ensure this by making $x _ { 1 }$ large enough such that the reconstruction error becomes negligible. For the diffusion process, previous image models [65, 29, 68, 30] relied on the fact that, in the limit $\\beta _ { t } \\to 0$ , the form of the true reverse process has the same functional form as the forward diffusion process [65, 41]. In particular, this allows modeling of the reverse process with a distribution factorized over the components. However, to make $q _ { \\theta } ^ { T - 1 }$ close to a uniform distribution requires a very large $T$ (in the order of 1000 steps) with small $\\beta _ { t }$ . Training such a large number of reverse models is only feasible with shared weights for the models, but this requires a delicate reweighting [29] of the objective and currently no suitable reweighting is known for the discrete case considered here. ",
+        "bbox": [
+            173,
+            569,
+            825,
+            709
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Thus, to be able to recover the true data distribution with a modest number of reverse models that can be trained fully parallel, and without weight-sharing, we model each reverse process autoregressively. We use an encoder-decoder transformer architecture [75], such that the decoder models the reverse process for $x _ { t - 1 }$ autoregressively with the help of global context obtained by cross-attending to the encoder’s representation of $x _ { t }$ as visualized in Fig. 1. Note that the need for autoregressive modeling gets reduced for small $\\beta _ { t }$ , which we can adjust for by reducing the number of decoder layers compared to encoder layers. The use of the compression model described in Sec. 3.2, however, allows to utilize full-attention based transformer architectures to implement the autoregressive scales. ",
+        "bbox": [
+            173,
+            715,
+            826,
+            827
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            859,
+            312,
+            876
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Sec. 4.1 evaluates the quality ImageBART achieves in image synthesis. Since we especially want to increase the controllability of the generative process, we evaluate the performance of ImageBART on class- and text-conditional image generation in Sec. 4.2. The ability of our approach to attend to global context enables a new level of localized control which is not possible with previous, purely autoregressive approaches as demonstrated in Sec. 4.3. Finally, Sec. 4.4 presents ablations on model and architecture choices. ",
+        "bbox": [
+            174,
+            882,
+            821,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/6dab2543f9aa70309e45c4de1c0b6c5bdb358bb4b6b062f23c886c9bf17f6839.jpg",
+        "image_caption": [
+            "Figure 2: Samples from our models. Top row: FFHQ, LSUN-Cats, Middle row: LSUN-Bedrooms, LSUNChurches, Bottom row: ImageNet. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            90,
+            820,
+            309
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/e89b0572d02da60e49c35ce37375f33948653d88f2d4998a26e96ce521587004.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Table 1: Left: FIDs on the LSUN-{Churches,Beds,Cats} [79] and FFHQ [33] datasets. Right: Corresponding qualitative comparisons. Qualitative comparisons with TT can be found in Fig. 20 and Fig. 21 "
+        ],
+        "table_body": "<table><tr><td>Method</td><td>Cats Beds</td><td>Churches</td><td></td><td>FFHQ</td><td></td><td>ImageBART</td><td>DDPM</td><td>SSDE</td></tr><tr><td>VDVAE [10]</td><td>1</td><td>1</td><td>1</td><td>28.5</td><td rowspan=\"2\">Churches</td><td rowspan=\"2\"></td><td rowspan=\"2\"></td><td rowspan=\"2\">健</td></tr><tr><td>DDPM [29]</td><td>19.75</td><td>4.90</td><td>7.89</td><td>1</td></tr><tr><td>StyleGAN2 [34]</td><td>7.25</td><td>2.35</td><td>3.86</td><td>3.8</td><td>Cats</td><td></td><td></td><td></td></tr><tr><td>BigGAN [6]</td><td>1</td><td>1</td><td>1</td><td>12.4</td><td>cIN (c14)</td><td></td><td></td><td></td></tr><tr><td>DCT[50]</td><td>1</td><td>6.40</td><td>7.56</td><td>13.06</td><td>cIN (c323)</td><td></td><td></td><td></td></tr><tr><td>TT[21]</td><td>17.31</td><td>6.35</td><td>7.81</td><td>11.4</td><td>cIN (c963)</td><td></td><td></td><td></td></tr><tr><td>ImageBART</td><td>15.09</td><td>5.51</td><td>7.32</td><td>9.57</td><td></td><td></td><td></td><td></td></tr></table>",
+        "bbox": [
+            176,
+            361,
+            823,
+            506
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            554,
+            825,
+            609
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 High-Fidelity Image Synthesis with ImageBART ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            617,
+            549,
+            632
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In this section we present qualitative and quantitative results on images synthesized by our approach. We train models at resolution $2 5 6 \\times 2 5 6$ for unconditional generation on FFHQ [33], LSUN -Cats, -Churches and -Bedrooms [79] and on class-conditional synthesis on ImageNet (cIN) [13]. ",
+        "bbox": [
+            174,
+            635,
+            826,
+            675
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Effective Discrete Representations Learning the full hierarchy as described in Eq. (2) and without unnecessary redundancies in the data requires to first learn a strong compression model via the objective in Eq. (4). [21] demonstrated how to effectively train such a model and we directly utilize the publicly available pretrained models. For training on LSUN, we finetune an ImageNet pretrained model for one epoch on each dataset. As the majority of codebook entries remains unused, we shrink the codebook to those entries which are actually used (evaluated on the validation split of ImageNet) and assign a random entry for eventual outliers. This procedure yields an effective, compact representation on which we subsequently train ImageBART. ",
+        "bbox": [
+            174,
+            681,
+            825,
+            792
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Training Details As described in Sec. 3.3, we use an encoder-decoder structure to model the reverse Markov Chain $p _ { \\theta } ^ { t - 1 } ( x _ { t - 1 } | x _ { t } ) , \\ t < T ,$ , where the encoder is a bidirectional transformer model and decoder is implemented as an AR transformer. As the context for the last scale is pure noise, we employ a decoder-only variant to model $p _ { \\theta } ^ { T - 1 } ( x _ { T - 1 } | x _ { T } )$ . Furthermore, to account for the different complexities of the datasets, we adjust the number of multinomial diffusion steps for each dataset accordingly. For FFHQ we choose a chain of length $T = 3$ , such that the total model consists of (i) the compression stage and (ii) $n = 2$ transformer models trained in parallel via the objective described in Eq.(7). Similarly, we set $n = 3$ for each of the LSUN models and $n = 5$ for the ImageNet model. ",
+        "bbox": [
+            173,
+            797,
+            825,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/8aa6a5ee5574a42041051f4e0c6bc21b99a5e65c4ad69234015837de67fc999c.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\"></td><td colspan=\"4\">rejection rate for cIN sampling</td></tr><tr><td>1.0</td><td>0.5</td><td>0.25</td><td>0.05</td></tr><tr><td>FID</td><td>21.19</td><td>13.12</td><td>9.77</td><td>7.44</td></tr><tr><td>IS</td><td>61.6±0.8</td><td>109.5±2.3</td><td>146.2±3.8</td><td>273.5±4.1</td></tr></table>",
+        "bbox": [
+            176,
+            88,
+            491,
+            161
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/66bcc3ea2572a2b592264f9c90b9df549e99aeb2148669a4f666eb1130621697.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"3\">Text-conditional image synthesis on CC [64]</td></tr><tr><td>Method</td><td>FID↓ IS↑</td><td>CLIP-score ↑</td></tr><tr><td>TT[21]</td><td>28.86</td><td>13.11±0.43 0.20±0.03</td></tr><tr><td>ImageBART 22.61</td><td>15.27±0.59</td><td>0.23±0.03</td></tr></table>",
+        "bbox": [
+            503,
+            88,
+            816,
+            161
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 2: Quantitative analysis on conditional models. Left: Results on class conditional Imagenet for different rejection rates, see also Fig, 20 in the supplemental. Right: Results of text-conditional ImageBART and comparison with TT [21] on the CC test set. Corresponding qualitative comparisons can be found in Fig. 21. ",
+        "bbox": [
+            173,
+            171,
+            826,
+            210
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/23609c1e1e2babddfb1fde79cad0fb58708ff1b0cd031c8a0ccd5e01557b8c6f.jpg",
+        "image_caption": [
+            "Figure 3: Samples from text-conditional ImageBART. Best 2 of 32 with reranking as in [56]. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            220,
+            838,
+            358
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Results For each of these settings, Fig. 2 depicts samples of size $2 5 6 \\times 2 5 6$ generated with ImageBART and a single pass through the learned Markov Chain, demonstrating that our model is able to produce realistic and coherent samples. This is further confirmed by a quantitative analysis in Tab. 1, where we compare FID scores of competing likelihood-based and score-based methods such as TT [21] and DDPM [29]. Regarding other works on diffusion models such as [29] and [68] operating directly in pixel space, we observe that these approaches perform roughly equivalently well in terms of FID for datasets of low complexity (e.g. LSUN-Bedrooms and-Churches). For more complex datasets (LSUN-Cats, cIN), however, our method outperforms these pixel-based approaches, which can also be seen qualitatively on the right in Tab. 1. See Fig. 20 for a comparison on ImageNet. ",
+        "bbox": [
+            174,
+            402,
+            825,
+            527
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 Conditional Markov Chains for Controlled Image Synthesis ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            550,
+            629,
+            565
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Being a sequence-to-sequence model, our approach allows for flexible and arbitrary conditioning by simply preprending tokens, similar to [21, 56]. More specifically, each learned transition $p _ { \\theta } ^ { t - 1 } \\dot { ( x } _ { t - 1 } \\dot { | x _ { t } , c ) }$ , $t > 1$ of the Markov chain is then additionally conditioned on a representation $c$ e.g. a single token in the case of the class-conditional model of Sec. 4.1. Note that the compression model $p _ { \\theta } ^ { 0 }$ remains unchanged. ",
+        "bbox": [
+            174,
+            571,
+            825,
+            642
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Text-to-Image Synthesis Besides class-conditional modeling on ImageNet, we also learn a textconditional model on Conceptual Captions (CC) [64, 51]. We obtain $c$ by using the publicly available tokenizer of the CLIP model [55], yielding a conditioning sequence of length 77. To model the dataset, we choose $T = 5$ and thus train $n = 4$ transformer models independently. For the $p _ { \\theta } ^ { 0 }$ , we directly transfer the compression model from Sec. 4.1, trained on the ImageNet dataset. ",
+        "bbox": [
+            174,
+            648,
+            825,
+            718
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Fig. 3 visualizes synthetic samples obtained with this model for various “image-cloze” tasks. Our resulting model is able to attend to semantic variations in the conditioning sentence (e.g. a change of weather for imagery of mountains) and renders the corresponding images accordingly. In Tab. 2, we evaluate FID [28] and Inception Scores (IS) [61] to measure the quality of synthesized images, as well as cosine similarity between CLIP [55] embeddings of the text prompts and the synthesized images to measure how well the image reflects the text. ImageBART improves all metrics upon [21]. Fig. 21 in the supplement provides corresponding qualitative examples for user-defined text inputs. ",
+        "bbox": [
+            173,
+            724,
+            825,
+            821
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Resolutions Beyond $\\mathbf { 2 5 6 \\times 2 5 6 }$ Pixels. Our approach is not restricted to generating images of size $2 5 6 \\times 2 5 6$ pixels. Although trained on a fixed resolution, we can apply our models in a patch-wise manner, where we use the sliding attention window of [21] for each scale $t > 0$ . As we now incorporate more and more global context while decoding with the Markov chain (which can be thought of as widening a noisy receptive field), ImageBART is able to render consistent images in the megapixel regime. See for example Fig. 4, where we use our text-conditional model to render an image of size $3 0 0 \\times 1 8 0 0$ pixel and interpolate between two different text prompts. More examples, especially also for semantically guided synthesis, can be found in Sec. A.2. ",
+        "bbox": [
+            174,
+            828,
+            823,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/ebb58974d2f9dfea8cc6e99357c21c61ddaabeb9e2b180889e1ae338ba73eab2.jpg",
+        "image_caption": [
+            "Figure 4: ImageBART is capable of generating high-resolution images. Here, we condition it on text prompts and interpolate between the two descriptions depicted above the image (see also Sec. 4.2). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            98,
+            821,
+            179
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            218,
+            825,
+            247
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.3 Beyond Conditional Models: Local Editing with Autoregressive Models ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            265,
+            707,
+            281
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Recent autoregressive approaches, which use a CNN to learn a discrete representation [74], partially alleviate the issues of pixel-wise autoregressive models by working on larger image patches. However, as we show in Fig. 5, even approaches which use adversarial learning to maximize the amount of context encoded in the discrete representation [21] cannot produce completions of the upper half of an image which are consistent with a given lower half. ",
+        "bbox": [
+            174,
+            285,
+            825,
+            354
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "While our approach also models each transition autoregressively from the top-left to the bottom-right, the ability to attend to global context from the previous scale enables consistent completions of arbitrary order, e.g. right-to-left. To achieve this, we mask the diffusion process as described in Sec. A.3. For a user-specified mask $m$ (e.g. the upper half of an image as in Fig. 5), this results in a forward-backward process pt−θ $p _ { \\theta } ^ { t - 1 | t - 1 , m }$ , which, by definition, leaves the unmasked context intact. The reverse process then denoises the unmasked entries to make them consistent with the given context. ",
+        "bbox": [
+            173,
+            361,
+            825,
+            448
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Fig. 5 (bottom) visualizes this mixing process, where we use a model with $T = 3$ . The first column shows the masked input. To start the process we set all masked entries to random entries. The first two columns then show (decoded) samples from the masked reverse processes $p _ { \\theta } ^ { 2 , m }$ and p1,θ $p _ { \\theta } ^ { 1 , m }$ , which still display inconsistencies. The remaining columns show the trajectory of the process $p _ { \\theta } ^ { 1 | 1 , m }$ , which demonstrates how the model iteratively adjusts its samples according to the given context until it converges to a globally consistent sample. For illustration, we show the analog trajectory obtained with [21], but because it can only attend to unidirectional context, this trajectory is equivalent to a sequence of independent samples and therefore fails to achieve global consistency. ",
+        "bbox": [
+            173,
+            453,
+            825,
+            570
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The masked process can be used with arbitrary masks, which enables localized image editing with free, hand-drawn masks as shown in Fig. 6. Note that our model does not need to be trained specifically for this task, which also avoids generalization problems associated with training on masks [81]. Combining this property with the conditional models from Sec. 4.2 allows for especially interesting novel applications, where local image regions are modified based on user specified class or text prompts, as shown in Fig. 7. ",
+        "bbox": [
+            173,
+            577,
+            826,
+            660
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/03b84378714d34185ad00d3dfa7f6d9b9d60e5564bcb7f99d99f030e1caa096c.jpg",
+        "image_caption": [
+            "Figure 5: Without global context, AR models fail at completing upper halfs, contrasting ImageBART. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            672,
+            828,
+            883
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/798638d2e9717d750afc7165a5042aa56c5dbf030da17d3a7940b687c4221ace.jpg",
+        "image_caption": [
+            "Figure 6: Local editing application using markov chain of length 16 on FFHQ. By incorporating bidirectional context ImageBART is able to solve this unconditional inpainting task (cf. Sec. 4.3). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            90,
+            820,
+            231
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/e36976b238d2f4e276c66ae208d9062eeb14211964ef27d411452dd127613584.jpg",
+        "image_caption": [
+            "Figure 7: Conditionally guided inpainting results obtained from conditional ImageBART trained on the i) ImageNet (top row) and ii) Conceptual Captions (bottom row) datasets. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            284,
+            816,
+            501
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.4 Ablations ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            555,
+            279,
+            570
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "On the Number of Diffusion Steps In this section we analyze the effect of varying the number of diffusion steps (denoted by $T$ ). To do so, we perform an experiment for unconditional training on the FFHQ dataset, where we train a Taming Transformers (TT) baseline (corresponding to the case $T = 2$ within our framework) with 800M parameters and three variants of ImageBART with $T = 3$ $( 2 \\mathrm { x } 4 0 0 \\mathrm { M } )$ , $T = 5$ $( 4 \\mathrm { x } 2 0 0 \\mathrm { M } )$ and $T = 9$ (8x100M), respectively. Note that for a fair comparison, all models use the same first level for compression, and we fix the number of remaining parameters to $8 0 0 \\mathbf { M }$ and distribute them equally across all scales. All models were trained with the same computational budget and evaluated at the best validation checkpoint. ",
+        "bbox": [
+            174,
+            583,
+            825,
+            694
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In Tab. 3, we assess both the pure synthesis and the modification ability of ImageBART by computing FID scores on samples and modified images (in the case of upper half completion as in Fig. 5). For both tasks, we use a single pass through the reverse Markov chain. We observe that the modification performance increases monotonically with the number of scales, which highlights the improved image manipulation abilities of our approach. For unconditional generation, we observe a similar trend, although FID seems to plateau beyond $T = 5$ . ",
+        "bbox": [
+            174,
+            700,
+            825,
+            784
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Joint vs. Independent Training While it is possible to optimize Eq. (2) jointly across all scales, we found that training is more robust when training all scales independently. Besides the usual separation of training the compression model $p _ { \\theta } ^ { 0 }$ and the generative model $p _ { \\theta } ^ { t \\geq 1 }$ , training the latter in parallel over multiple scales avoids the tedious weighting of the loss contribution from different scales; an often encountered problem in other denoising diffusion probabilistic models [29]. ",
+        "bbox": [
+            174,
+            790,
+            825,
+            862
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Efficiency with Less Decoder Layers As we implement the conditional transition probabilities $p _ { \\theta } ^ { t - 1 }$ with an encoder-decoder transformer architecture, we are interested in the effect of altering the ratio of encoder and decoder layers in the model. Recent work has provided evidence that it is possible to significantly reduce the number of decoder layers and thus also decrease autoregressive decoding speed while maintaining high quality [35]. We perform an experiment on LSUN-Churches, where we analyze the effect of different layer-ratios on synthesis quality (measured by FID) and on decoding speed when fixing the total number of model parameters to 200M. The results in the left part of Fig. 8 confirms that it is indeed possible to reduce the number of decoder layers while maintaining satisfactory FID scores with higher decoding efficiency. We identity a favorable trade-off between four and six decoder layers and transfer this setting to our other experiments. ",
+        "bbox": [
+            174,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/6c37231fb8cbf82cdd6df6de394035f0a730cdaebea732319a33dc13cdc1b38b.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Table 3: Assessing the effect of different $\\overline { { T } }$ with a fixed number of parameters distributed equally over all scales. All models are trained on FFHQ. Left: Full image generation results. Right: Using the example of upper image completion, we evaluate the ability to complete and modifiy an image, see Sec. 4.3 and 4.4. "
+        ],
+        "table_body": "<table><tr><td colspan=\"3\">Unconditional Generation</td><td colspan=\"3\">Upper Half Completion</td></tr><tr><td>method</td><td>FID↓</td><td>IS个</td><td>method</td><td>FID↓</td><td>IS↑</td></tr><tr><td>TT(T= 2)</td><td>12.44</td><td>4.42 ± 0.05</td><td>TT(T= 2)</td><td>11.80</td><td>4.48 ± 0.10</td></tr><tr><td>ImageBART (T = 3)</td><td>12.55</td><td>3.98± 0.07</td><td>ImageBART(T= 3)</td><td>9.25</td><td>4.49 ± 0.13</td></tr><tr><td>ImageBART(T=5)</td><td>10.69</td><td>4.27 ± 0.05</td><td>ImageBART(T= 5)</td><td>6.87</td><td>4.81 ± 0.13</td></tr><tr><td>ImageBART (T = 9)</td><td>10.81</td><td>4.49 ± 0.05</td><td>ImageBART (T = 9)</td><td>6.64</td><td>4.86 ± 0.15</td></tr></table>",
+        "bbox": [
+            200,
+            88,
+            792,
+            184
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/505dcbb4d8a10672f2407a866d0081a4515c4138ff21f9ffadab74eae8b65903.jpg",
+        "image_caption": [
+            "Figure 8: Left: Effect of number of encoder vs. decoder layers for a fixed total number of model parameters $( ( 1 9 5 \\pm 5 ) M )$ , evaluated on LSUN-Churches. FIDs are evaluated w.r.t $3 \\times 2 5 0 0 \\mathrm { k }$ samples. The plot shows 3 standard deviations. All models are trained jointly over three scales. Right: Our model achieves better sampling performance than state of the art diffusion models (SSDE [68], DDPM [29], ADM [15]) and also approaches the inference speed of TT [21], which only consists of a single autoregressive stage. Reducing the number of scales increases inference speed at the expense of controllability. Experiments were conducted on a single NVIDIA A100 and are reported averaged over 1000 samples with a batch size of 50, evaluated on FFHQ while using the same number of trainable parameters $( 8 0 0 \\mathrm { m } )$ for all AR models. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            262,
+            823,
+            390
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            530,
+            825,
+            627
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Finally, we compare our model in terms of sampling speed with the recent state-of-the-art generative diffusion [29, 68] and AR models [21]. The results are summarized in Fig. 8. While consistently being faster than all pixel-based models due to training in a compressed latent space, the increase in runtime w.r.t. [21] is moderate due to the use of encoder-decoder transformers, i.e., a a decrease in pure decoder layers. If a faster runtime is desired, the speed can be further increased by reducing the number of decoder layers even more, see also the discussion in Sec. A.5. ",
+        "bbox": [
+            174,
+            633,
+            825,
+            717
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            751,
+            297,
+            768
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We have proposed ImageBART, a hierarchical approach to introduce bidirectional context into autoregressive transformer models for high-fidelity controllable image synthesis. We invert a multinomial diffusion process by training a Markov chain to gradually incorporate context in a coarse-to-fine manner. Our study shows that this approach (i) introduces a natural hierarchical representation of images, with consecutive levels carrying more information than previous ones. (see also Fig. 9). (ii) It alleviates the unnatural unidirectional ordering of pure autoregressive models for image representation through global context from previous levels of the hierarchy. (iii) It enables global and local manipulation of a given input, a feat previously out-of-reach for ARMs. (iv) We additionally show that our model can be efficiently conditioned on various representations, allowing for a large class of conditional image synthesis tasks such as semantically guided generation or text-to-image synthesis. ",
+        "bbox": [
+            174,
+            786,
+            825,
+            925
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgments ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            89,
+            330,
+            106
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Many thanks to Phil Wang for providing https://github.com/lucidrains/x-transformers and all the other great PyTorch implementations. ",
+        "bbox": [
+            173,
+            119,
+            823,
+            147
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Funding and Transparency Statement ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            166,
+            495,
+            184
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Funding in direct support of this work: German Research Foundation (DFG) projects 371923335 and 421703927, German Federal Ministry for Economic Affairs and Energy within the project ’KI-Absicherung - Safe AI for automated driving’. ",
+        "bbox": [
+            174,
+            196,
+            825,
+            239
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Checklist ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            257,
+            254,
+            273
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "1. For all authors... ",
+        "bbox": [
+            214,
+            284,
+            339,
+            297
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   \n(b) Did you describe the limitations of your work? [Yes] See supplementary.   \n(c) Did you discuss any potential negative societal impacts of your work? [Yes] See supplementary.   \n(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes] ",
+        "bbox": [
+            238,
+            301,
+            825,
+            404
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "2. If you are including theoretical results... ",
+        "bbox": [
+            214,
+            406,
+            493,
+            421
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you state the full set of assumptions of all theoretical results? [N/A] (b) Did you include complete proofs of all theoretical results? [N/A] ",
+        "bbox": [
+            236,
+            424,
+            738,
+            455
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "3. If you ran experiments... ",
+        "bbox": [
+            214,
+            458,
+            393,
+            472
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [No] Including the code while maintaining anonymity is difficult; it will be published after deanonymization.   \n(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] We include most relevant details in the supplementary and the full code release will contain the precise values.   \n(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [Yes] Yes, wherever this does not introduce irresponsible waste of computational resources.   \n(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [Yes] The supplementary contains an overview of used hardware. ",
+        "bbox": [
+            238,
+            476,
+            825,
+            660
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... ",
+        "bbox": [
+            212,
+            664,
+            823,
+            679
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "(a) If your work uses existing assets, did you cite the creators? [Yes]   \n(b) Did you mention the license of the assets? [No] Licenses will be included along with the code release.   \n(c) Did you include any new assets either in the supplemental material or as a URL? [No]   \n(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A]   \n(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [Yes] See supplementary. ",
+        "bbox": [
+            238,
+            683,
+            825,
+            799
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "5. If you used crowdsourcing or conducted research with human subjects... ",
+        "bbox": [
+            214,
+            803,
+            705,
+            818
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   \n(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   \n(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A] ",
+        "bbox": [
+            238,
+            820,
+            825,
+            909
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            90,
+            266,
+            106
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[1] R. Abdal, P. Zhu, N. J. Mitra, and P. Wonka. Styleflow: Attribute-conditioned exploration of stylegangenerated images using conditional continuous normalizing flows. ACM Trans. Graph., 40(3), May 2021. ISSN 0730-0301. doi: 10.1145/3447648. URL https://doi.org/10.1145/3447648.   \n[2] J. Austin, D. Johnson, J. Ho, D. Tarlow, and R. v. d. Berg. Structured denoising diffusion models in discrete state-spaces. arXiv preprint arXiv:2107.03006, 2021.   \n[3] S. Bengio, O. Vinyals, N. Jaitly, and N. Shazeer. Scheduled sampling for sequence prediction with recurrent neural networks. CoRR, abs/1506.03099, 2015. [4] A. Blattmann, T. Milbich, M. Dorkenwald, and B. Ommer. Behavior-driven synthesis of human dynamics. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pages 12236–12246, June 2021.   \n[5] A. Blattmann, T. Milbich, M. Dorkenwald, and B. Ommer. ipoke: Poking a still image for controlled stochastic video synthesis. In Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), pages 14707–14717, October 2021.   \n[6] A. Brock, J. Donahue, and K. Simonyan. Large scale GAN training for high fidelity natural image synthesis. In Int. Conf. Learn. Represent., 2019.   \n[7] T. B. Brown, B. Mann, N. Ryder, M. Subbiah, J. Kaplan, P. Dhariwal, A. Neelakantan, P. Shyam, G. Sastry, A. Askell, S. Agarwal, A. Herbert-Voss, G. Krueger, T. Henighan, R. Child, A. Ramesh, D. M. Ziegler, J. Wu, C. Winter, C. Hesse, M. Chen, E. Sigler, M. Litwin, S. Gray, B. Chess, J. Clark, C. Berner, S. McCandlish, A. Radford, I. Sutskever, and D. Amodei. Language models are few-shot learners. In NeurIPS, 2020. [8] M. Chen, A. Radford, R. Child, J. Wu, H. Jun, D. Luan, and I. Sutskever. Generative pretraining from pixels. In ICML, volume 119 of Proceedings of Machine Learning Research, pages 1691–1703. PMLR, 2020. [9] X. Chen, D. P. Kingma, T. Salimans, Y. Duan, P. Dhariwal, J. Schulman, I. Sutskever, and P. Abbeel. Variational lossy autoencoder. CoRR, abs/1611.02731, 2016.   \n[10] R. Child. Very deep vaes generalize autoregressive models and can outperform them on images. CoRR, abs/2011.10650, 2020.   \n[11] K. Crawford and T. Paglen. Excavating ai: The politics of training sets for machine learning, 2019. URL https://excavating.ai.   \n[12] B. Dai and D. P. Wipf. Diagnosing and enhancing VAE models. In ICLR (Poster). OpenReview.net, 2019.   \n[13] J. Deng, W. Dong, R. Socher, L. Li, K. Li, and F. Li. Imagenet: A large-scale hierarchical image database. In CVPR, pages 248–255. IEEE Computer Society, 2009.   \n[14] J. Devlin, M. Chang, K. Lee, and K. Toutanova. BERT: pre-training of deep bidirectional transformers for language understanding. CoRR, abs/1810.04805, 2018.   \n[15] P. Dhariwal and A. Nichol. Diffusion models beat gans on image synthesis. CoRR, abs/2105.05233, 2021. URL https://arxiv.org/abs/2105.05233.   \n[16] P. Dhariwal, H. Jun, C. Payne, J. W. Kim, A. Radford, and I. Sutskever. Jukebox: A generative model for music. CoRR, abs/2005.00341, 2020.   \n[17] S. Dieleman. Musings on typicality, 2020. URL https://benanne.github.io/2020/09/01/ typicality.html.   \n[18] M. Dorkenwald, T. Milbich, A. Blattmann, R. Rombach, K. G. Derpanis, and B. Ommer. Stochastic image-to-video synthesis using cinns. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pages 3742–3753, June 2021.   \n[19] A. Dosovitskiy and T. Brox. Generating images with perceptual similarity metrics based on deep networks. In NIPS, pages 658–666, 2016.   \n[20] P. Esser, R. Rombach, and B. Ommer. A disentangling invertible interpretation network for explaining latent representations. CoRR, abs/2004.13166, 2020.   \n[21] P. Esser, R. Rombach, and B. Ommer. Taming transformers for high-resolution image synthesis. CoRR, abs/2012.09841, 2020.   \n[22] J. D. Fauw, S. Dieleman, and K. Simonyan. Hierarchical autoregressive image models with auxiliary decoders. CoRR, abs/1903.04933, 2019.   \n[23] L. A. Gatys, A. S. Ecker, and M. Bethge. Image style transfer using convolutional neural networks. In CVPR, pages 2414–2423. IEEE Computer Society, 2016.   \n[24] M. Germain, K. Gregor, I. Murray, and H. Larochelle. MADE: masked autoencoder for distribution estimation. CoRR, abs/1502.03509, 2015.   \n[25] I. J. Goodfellow, J. Pouget-Abadie, M. Mirza, B. Xu, D. Warde-Farley, S. Ozair, A. C. Courville, and Y. Bengio. Generative adversarial networks. CoRR, 2014.   \n[26] A. Goyal, A. Lamb, Y. Zhang, S. Zhang, A. C. Courville, and Y. Bengio. Professor forcing: A new algorithm for training recurrent networks. In NIPS, pages 4601–4609, 2016.   \n[27] I. Gulrajani, K. Kumar, F. Ahmed, A. A. Taïga, F. Visin, D. Vázquez, and A. C. Courville. Pixelvae: A latent variable model for natural images. CoRR, abs/1611.05013, 2016.   \n[28] M. Heusel, H. Ramsauer, T. Unterthiner, B. Nessler, and S. Hochreiter. Gans trained by a two time-scale update rule converge to a local nash equilibrium. In Adv. Neural Inform. Process. Syst., pages 6626–6637, 2017.   \n[29] J. Ho, A. Jain, and P. Abbeel. Denoising diffusion probabilistic models. In NeurIPS, 2020.   \n[30] E. Hoogeboom, D. Nielsen, P. Jaini, P. Forré, and M. Welling. Argmax flows and multinomial diffusion: Towards non-autoregressive language models. CoRR, abs/2102.05379, 2021.   \n[31] A. H. Jha, S. Anand, M. Singh, and V. S. R. Veeravasarapu. Disentangling factors of variation with cycle-consistent variational auto-encoders. In ECCV (3), volume 11207 of Lecture Notes in Computer Science, pages 829–845. Springer, 2018.   \n[32] J. Johnson, A. Alahi, and L. Fei-Fei. Perceptual losses for real-time style transfer and super-resolution. In ECCV (2), volume 9906 of Lecture Notes in Computer Science, pages 694–711. Springer, 2016.   \n[33] T. Karras, S. Laine, and T. Aila. A style-based generator architecture for generative adversarial networks. In 2019 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), 2019.   \n[34] T. Karras, S. Laine, M. Aittala, J. Hellsten, J. Lehtinen, and T. Aila. Analyzing and improving the image quality of stylegan. CoRR, abs/1912.04958, 2019.   \n[35] J. Kasai, N. Pappas, H. Peng, J. Cross, and N. A. Smith. Deep encoder, shallow decoder: Reevaluating non-autoregressive machine translation, 2021.   \n[36] S. Khan, M. Naseer, M. Hayat, S. W. Zamir, F. S. Khan, and M. Shah. Transformers in vision: A survey. CoRR, abs/2101.01169, 2021.   \n[37] Y. Kilcher, A. Lucchi, and T. Hofmann. Semantic interpolation in implicit models. CoRR, abs/1710.11381, 2017.   \n[38] D. P. Kingma and M. Welling. Auto-Encoding Variational Bayes. In 2nd International Conference on Learning Representations, ICLR, 2014.   \n[39] D. P. Kingma, D. J. Rezende, S. Mohamed, and M. Welling. Semi-supervised learning with deep generative models. CoRR, abs/1406.5298, 2014.   \n[40] A. Kolesnikov and C. H. Lampert. Pixelcnn models with auxiliary variables for natural image modeling. In ICML, volume 70 of Proceedings of Machine Learning Research, pages 1905–1914. PMLR, 2017.   \n[41] A. Kolmogoroff. Über die analytischen methoden in der wahrscheinlichkeitsrechnung. Mathematische Annalen, 104:415–458, 1931. URL http://eudml.org/doc/159476.   \n[42] A. Krizhevsky. Learning multiple layers of features from tiny images. 2009.   \n[43] R. Leblond, J. Alayrac, A. Osokin, and S. Lacoste-Julien. SEARNN: training rnns with global-local losses. CoRR, abs/1706.04499, 2017.   \n[44] D. Lesniak, I. Sieradzki, and I. T. Podolak. Distribution-interpolation trade off in generative models. In ICLR (Poster). OpenReview.net, 2019.   \n[45] M. Lewis, Y. Liu, N. Goyal, M. Ghazvininejad, A. Mohamed, O. Levy, V. Stoyanov, and L. Zettlemoyer. BART: denoising sequence-to-sequence pre-training for natural language generation, translation, and comprehension. In ACL, pages 7871–7880. Association for Computational Linguistics, 2020.   \n[46] N. Li, S. Liu, Y. Liu, S. Zhao, and M. Liu. Neural speech synthesis with transformer network. In AAAI, pages 6706–6713. AAAI Press, 2019.   \n[47] L. Maaløe, M. Fraccaro, V. Liévin, and O. Winther. BIVA: A very deep hierarchy of latent variables for generative modeling. In NeurIPS, pages 6548–6558, 2019.   \n[48] M. Mathieu, J. J. Zhao, P. Sprechmann, A. Ramesh, and Y. LeCun. Disentangling factors of variation in deep representations using adversarial training. CoRR, abs/1611.03383, 2016.   \n[49] F. Mentzer, G. Toderici, M. Tschannen, and E. Agustsson. High-fidelity generative image compression. In NeurIPS, 2020.   \n[50] C. Nash, J. Menick, S. Dieleman, and P. W. Battaglia. Generating images with sparse representations. CoRR, abs/2103.03841, 2021.   \n[51] E. G. Ng, B. Pang, P. Sharma, and R. Soricut. Understanding guided image captioning performance across domains. arXiv preprint arXiv:2012.02339, 2020.   \n[52] A. Nichol and P. Dhariwal. Improved denoising diffusion probabilistic models. CoRR, abs/2102.09672, 2021.   \n[53] T. Park, M.-Y. Liu, T.-C. Wang, and J.-Y. Zhu. Semantic image synthesis with spatially-adaptive normalization. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, 2019.   \n[54] N. Parmar, A. Vaswani, J. Uszkoreit, L. Kaiser, N. Shazeer, A. Ku, and D. Tran. Image transformer. In ICML, volume 80 of Proceedings of Machine Learning Research, pages 4052–4061. PMLR, 2018.   \n[55] A. Radford, J. W. Kim, C. Hallacy, A. Ramesh, G. Goh, S. Agarwal, G. Sastry, A. Askell, P. Mishkin, J. Clark, G. Krueger, and I. Sutskever. Learning transferable visual models from natural language supervision. CoRR, abs/2103.00020, 2021.   \n[56] A. Ramesh, M. Pavlov, G. Goh, S. Gray, C. Voss, A. Radford, M. Chen, and I. Sutskever. Zero-shot text-to-image generation. CoRR, abs/2102.12092, 2021.   \n[57] M. Ranzato, S. Chopra, M. Auli, and W. Zaremba. Sequence level training with recurrent neural networks. In ICLR (Poster), 2016.   \n[58] A. Razavi, A. van den Oord, and O. Vinyals. Generating diverse high-fidelity images with VQ-VAE-2. In NeurIPS, pages 14837–14847, 2019.   \n[59] D. J. Rezende, S. Mohamed, and D. Wierstra. Stochastic backpropagation and approximate inference in deep generative models. In Proceedings of the 31st International Conference on International Conference on Machine Learning, ICML, 2014.   \n[60] R. Rombach, P. Esser, and B. Ommer. Network-to-network translation with conditional invertible neural networks. In NeurIPS, 2020.   \n[61] T. Salimans, I. Goodfellow, W. Zaremba, V. Cheung, A. Radford, and X. Chen. Improved techniques for training gans. In NIPS, 2016.   \n[62] T. Salimans, A. Karpathy, X. Chen, and D. P. Kingma. Pixelcnn $^ { + + }$ : Improving the pixelcnn with discretized logistic mixture likelihood and other modifications. CoRR, abs/1701.05517, 2017.   \n[63] F. Schmidt. Generalization in generation: A closer look at exposure bias. In NGT@EMNLP-IJCNLP, pages 157–167. Association for Computational Linguistics, 2019.   \n[64] P. Sharma, N. Ding, S. Goodman, and R. Soricut. Conceptual captions: A cleaned, hypernymed, image alt-text dataset for automatic image captioning. In Proceedings of ACL, 2018.   \n[65] J. Sohl-Dickstein, E. A. Weiss, N. Maheswaranathan, and S. Ganguli. Deep unsupervised learning using nonequilibrium thermodynamics. CoRR, abs/1503.03585, 2015.   \n[66] C. K. Sønderby, T. Raiko, L. Maaløe, S. K. Sønderby, and O. Winther. Ladder variational autoencoders. In NIPS, pages 3738–3746, 2016.   \n[67] Y. Song and S. Ermon. Generative modeling by estimating gradients of the data distribution. In NeurIPS, pages 11895–11907, 2019.   \n[68] Y. Song, J. Sohl-Dickstein, D. P. Kingma, A. Kumar, S. Ermon, and B. Poole. Score-based generative modeling through stochastic differential equations. CoRR, abs/2011.13456, 2020.   \n[69] A. Szabó, Q. Hu, T. Portenier, M. Zwicker, and P. Favaro. Challenges in disentangling independent factors of variation. In ICLR (Workshop). OpenReview.net, 2018.   \n[70] B. Uria, M. Côté, K. Gregor, I. Murray, and H. Larochelle. Neural autoregressive distribution estimation. CoRR, abs/1605.02226, 2016.   \n[71] A. Vahdat and J. Kautz. NVAE: A deep hierarchical variational autoencoder. In NeurIPS, 2020.   \n[72] A. van den Oord, N. Kalchbrenner, L. Espeholt, k. kavukcuoglu, O. Vinyals, and A. Graves. Conditional image generation with pixelcnn decoders. In Advances in Neural Information Processing Systems, 2016.   \n[73] A. van den Oord, N. Kalchbrenner, O. Vinyals, L. Espeholt, A. Graves, and K. Kavukcuoglu. Conditional image generation with pixelcnn decoders. CoRR, abs/1606.05328, 2016.   \n[74] A. van den Oord, O. Vinyals, and K. Kavukcuoglu. Neural discrete representation learning. In NIPS, pages 6306–6315, 2017.   \n[75] A. Vaswani, N. Shazeer, N. Parmar, J. Uszkoreit, L. Jones, A. N. Gomez, L. Kaiser, and I. Polosukhin. Attention is all you need. In NIPS, pages 5998–6008, 2017.   \n[76] C. Wang, Y. Tang, X. Ma, A. Wu, D. Okhonko, and J. Pino. fairseq s2t: Fast speech-to-text modeling with fairseq, 2020.   \n[77] T. White. Sampling generative networks: Notes on a few effective techniques. CoRR, abs/1609.04468, 2016.   \n[78] W. Yan, Y. Zhang, P. Abbeel, and A. Srinivas. Videogpt: Video generation using VQ-VAE and transformers. CoRR, abs/2104.10157, 2021.   \n[79] F. Yu, Y. Zhang, S. Song, A. Seff, and J. Xiao. LSUN: construction of a large-scale image dataset using deep learning with humans in the loop. CoRR, abs/1506.03365, 2015.   \n[80] R. Zhang, P. Isola, A. A. Efros, E. Shechtman, and O. Wang. The unreasonable effectiveness of deep features as a perceptual metric. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2018.   \n[81] C. Zheng, T. Cham, and J. Cai. Tfill: Image completion via a transformer-based architecture. CoRR, abs/2104.00845, 2021. ",
+        "bbox": [
+            171,
+            112,
+            830,
+            911
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            95,
+            828,
+            915
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            90,
+            828,
+            921
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            92,
+            826,
+            191
+        ],
+        "page_idx": 14
+    }
+]

parse/train/3WbWmdTd8fN/3WbWmdTd8fN.md

@@ -0,0 +1,389 @@
+# Learning Division with Neural Arithmetic Logic Modules
+
+Anonymous Author(s)   
+Affiliation   
+Address   
+email
+
+# Abstract
+
+1 To achieve systematic generalisation, it first makes sense to master simple tasks   
+2 such as arithmetic. Of the four fundamental arithmetic operations $( + , - , \times , \div )$ ,   
+3 division is considered the most difficult for both humans and computers. In this   
+4 paper we show that robustly learning division in a systematic manner remains a   
+5 challenge even at the simplest level of dividing two numbers. We propose two   
+6 novel approaches for division which we call the Neural Reciprocal Unit (NRU) and   
+7 the Neural Multiplicative Reciprocal Unit (NMRU), and present improvements for   
+8 an existing division module, the Real Neural Power Unit (Real NPU). Experiments   
+9 in learning division with input redundancy on 225 different training sets, find that   
+10 our proposed modifications to the Real NPU obtains an average success of $8 5 . 3 \%$   
+11 improving over the original by $1 5 . 1 \%$ . In light of the suggestion above, our NMRU   
+12 approach can further improve the success to $9 1 . 6 \%$ .
+
+# 13 1 Introduction
+
+14 Imagine you must learn to divide 2 numbers, but are only given 10 numbers and the target value. This   
+15 task requires finding the 2 relevant operands, the order to divide the operands, and learning to divide.   
+16 In machine learning, this is equivalent to a supervised regression task where the aim is to learn the   
+17 underlying function between the inputs and output such that the solution is generalisable to any input.   
+18 The ability to select relevant features is a desirable property of neural networks, useful for improved   
+19 intepretability, reduced pre-processing costs and greater generalisation [Chandrashekar and Sahin,   
+20 2014]. The ability to model division, one of the four fundamental arithmetic operations, is necessary   
+21 for expressing dynamical systems [Sahoo et al., 2018], and physics-based formulas [Udrescu and   
+22 Tegmark, 2020]. However, even recent models still struggle to learn division when there is input   
+23 redundancy [Schlör et al., 2020].   
+24 The main challenge of the above task comes from learning the selection and operation at the same   
+25 time, which can lead to conflicting priorities when learning network weights. Furthermore, the natural   
+26 properties of division of values around zero leads to undesirable gradients. Models which deal with   
+27 this naively (e.g. MLPs) are unable to deal with the fluctuant gradients caused by the asymptotic   
+28 nature and discontinuities in division [Trask et al., 2018].
+
+9 Can we build models which can learn division in the presence of its undesirable, yet valid, properties? We aim to address this question in this paper. Specifically, we contribute the following:0
+
+• Improvements to the Real NPU [Heim et al., 2020] including: clipping, discretisation and constrained initialisation to improve performance in learning division on different training ranges.
+
+33 • Two novel division modules, the NRU and the NMRU. The NRU explores extending the NMU   
+34 weight ranges from [0,1] to [-1,1] to include division, where we find a weakness in learning from   
+35 negative ranges. Learning from the weaknesses of the NRU, the NMRU extends the NMU to learn   
+36 division while keeping weights values between [0,1]. We further boost performance by using a   
+37 Real NPU inspired sign retrieval mechanism, enabling the NMRU to gain the best performance   
+38 when using a mean squared error (MSE) loss.   
+39 • New understanding into the hindrances in learning division including: training on mixed-sign   
+40 inputs, training on negative ranges, and division on extremely small values. We find these difficulties   
+41 can be sufficiently identified using synthetic division tasks.   
+42 The broader impact of our work relates to interpretable Artificial Intelligence where our modules   
+43 can be included in larger networks for applications such as image classification or analogy creation,   
+44 whilst retaining the ability to produce transparent generalisable solutions. However, there are possible   
+45 negative societal impacts. Such modules can be viewed as specialised feature selectors/aggregators   
+46 which do not require integrating domain knowledge. Therefore, if a non-domain-expert tries inter  
+47 preting relations in the input data, they may incorrectly interpret causality, which can be especially   
+48 harmful if such a case occurs on medical or financial data. Mitigating against such downstream issues   
+49 requires to first focus efforts on producing robust modules to different distributions and understand   
+50 their affect on learning other networks architectures (e.g. CNN). Understanding this will enable   
+51 recognising situations where these modules can aid and where they should avoid being used.
+
+# 52 2 Related Work
+
+53 One approach to learn division would be symbolic regression networks [Sahoo et al., 2018]. However,   
+54 a symbolic approach pre-defines the operations, which is not a limitation of using Neural Arithmetic   
+55 Logic Modules (NALMs).   
+56 NALMs are neural networks which learn arithmetic operations and input selection [Mistry et al.,   
+57 2021]. The weights of these networks are intepretable such that a discrete value represents a specific   
+58 operation. For example, ‘-1’ to represent division and $\cdot _ { 0 } \cdot \mathrm { ~ }$ for no selection. From this research field,   
+59 we focus on the Real NPU and the NMU. Until now, the Real NPU only has learned division on   
+60 training ranges of either $\mathcal { U } [ 0 . 1 , 2 ]$ or Sobol(0,0.5) [Heim et al., 2020]. It remains unclear if this   
+61 module is robust to other training ranges even as a stand-alone unit. Robustness to training ranges is   
+62 important as these module’s applicational use comes from being part of larger end-to-end networks,   
+63 where the input range into the module cannot be controlled. The NMU is a multiplication module   
+64 which we extend to also do division. The authors of the NMU believe such an extension incurs too   
+65 many limitations for learning [Madsen and Johansen, 2020]. We use this paper as an opportunity to   
+66 explore this belief.   
+67 Trask et al. [2018] developed the Neural Arithmetic Logic Unit (NALU) which can model all four   
+68 arithmetic operations. However, studies show this module to be unstable in learning division [Schlör   
+69 et al., 2020, Heim et al., 2020]. In particular, their gating method responsible for selecting an operation   
+70 cannot learn consistently [Madsen and Johansen, 2020]. Schlör et al. [2020] developed iNALU   
+71 additionally applying weight and gradient clipping, sign retrieval, regularisation, reinitialisation and   
+72 separating shared parameters to the NALU. Even with these modifications, they still find consistently   
+73 learning division to a high precision to remain unattainable. Furthermore, Heim et al. [2020]’s results   
+74 imply iNALU is outperformed by the Real NPU for division.
+
+# 75 3 Architectures
+
+76 This section introduces the architectures for the (Real) NPU, NRU, and the NMRU. The (Real) NPU   
+77 is an existing module, which we improve in Section 5. The NRU and NMRU are novel contributions.   
+78 Appendix A summarises the important properties of these division modules.
+
+# 3.1 Real Neural Power Unit
+
+80 Heim et al. [2020] develop a module to learn to multiply and divide, using the intuition from Trask   
+81 et al. [2018] that multiplicative operations are additive operations in log space. Their work extends   
+82 this idea into complex space. The NPU can be used with its complex form (Equation 1) requiring both   
+83 a complex and real weight matrix $( W ^ { ( i ) } , W ^ { ( r ) } )$ , or only its real form the Real NPU (Equation 2).   
+84 For improved gradients, a relevance gate $\mathbfit { \Delta } \mathbf { r }$ (Equation 3) is used which converts inputs close to 0 (i.e.   
+85 irrelevant features) to 1 to avoid the resulting output evaluating to 0. A gating vector $\textbf {  { g } }$ , learns to   
+86 select relevant input elements, where gate values are clipped between [0,1] during training.
+
+$$
+\mathrm { N P U } : = \exp ( { W ^ { ( r ) } \log ( r ) - W ^ { ( i ) } k } ) \odot \cos ( { W ^ { ( i ) } \log ( r ) + W ^ { ( r ) } k } ) ,
+$$
+
+87
+
+$$
+\mathrm { R e a l N P U } : = \exp ( W ^ { ( r ) } \log ( r ) ) \odot \cos ( W ^ { ( r ) } k )
+$$
+
+$$
+\mathrm { e r e } \quad r = g \odot ( | { \pmb x } | + \epsilon ) + ( { \bf 1 } - { \pmb g } ) \quad \mathrm { a n d } \quad k _ { i } = \left\{ 0 \qquad x _ { i } \geq 0 \atop \pi { \bf g _ { i } } \quad x _ { i } < 0  \right. .
+$$
+
+89 A weighted L1 penalty is used when training. The weight value $\beta$ grows between predefined values   
+90 $\beta _ { s t a r t }$ to $\beta _ { e n d }$ and is increased every $\beta _ { s t e p } = 1 0 , 0 0 0$ iterations by a growth factor $\beta _ { g r o w t h } = 1 0$ .   
+91 We focus on the Real NPU over the NPU as the solution of the tasks in this paper can be captured   
+92 using only real values meaning that the complex form is not required.
+
+# 93 3.2 Neural Reciprocal Unit
+
+94 We propose the NRU, which can model multiplication and division. We extend the NMU, motivated   
+95 by division being multiplication of reciprocals. The range which weight values can be is extended   
+96 from [0,1] to [-1,1], where $^ { - 1 }$ represents applying the reciprocal on the corresponding input element.   
+97 A NRU output element $z _ { o }$ is defined as
+
+$$
+\mathrm { N R U : ~ } z _ { o } = \prod _ { i = 1 } ^ { I } ( \mathrm { s i g n ( x } _ { i } ) \cdot | \mathbf { x } _ { i } | ^ { W _ { i , o } } \cdot | W _ { i , o } | + 1 - | W _ { i , o } | ) ,
+$$
+
+98 where $I$ is the number of inputs. Assuming weights are either 1 (multiply) or $^ { - 1 }$ (reciprocal), $\left| \mathbf { x } _ { i } \right| ^ { W _ { i , o } }$   
+99 will apply the operation on an input element. The absolute value is used so that the module only   
+100 operates in the space of real numbers, as $x _ { i } ^ { W _ { i , o } }$ for a negative input $( x _ { i } )$ when $- 1 < W _ { i , o } < 1$ results   
+101 in a complex number. The use of absolute means the sign of the input must be reapplied. For the   
+102 no-selection case $W _ { i , o } = 0$ , we want the input element to convert to 1 (the identity value), resulting   
+103 in applying $| W _ { i , o } | + 1 - | W _ { i , o } |$ . The derivative of the absolute function at 0 is undefined meaning the   
+104 gradients of Equation 4 can contain points of discontinuity. To alleviate this issue, we approximate   
+105 the absolute function using a scaled tanh (inspired by Faber and Wattenhofer [2020]). More formally,
+
+$$
+| W _ { i , o } | = \left\{ \begin{array} { l l } { \operatorname { t a n h } ( 1 0 0 0 \cdot W _ { i , o } ) ^ { 2 } } & { \mathrm { i f ~ t r a i n i n g } } \\ { | W _ { i , o } | } & { \mathrm { o t h e r w i s e } } \end{array} . \right.
+$$
+
+106 The scale factor (1000) controls how close to the absolute function the approximation is, where larger   
+107 values give a more accurate approximation. For clipping and regularisation, the same scheme as the   
+108 Neural Addition Unit (NAU) (see Appendix B) is used.
+
+# 109 3.3 Neural Multiplicative Reciprocal Unit
+
+110 An alternate extension of the NMU, also motivated by division being multiplication of reciprocals   
+111 is the NMRU (Equation 5). We concatenate the reciprocal of the input (plus a small $\epsilon$ ) to the input   
+112 resulting in a module which only needs to learn selection. Hence, weights can be in the range [0,1].
+
+$$
+\mathrm { N M R U } : z _ { o } = \prod _ { i = 1 } ^ { 2 I } ( W _ { i , o } \cdot | \mathbf { x } _ { i } | + 1 - W _ { i , o } ) \cdot \sum _ { i = 1 } ^ { 2 I } ( \cos ( W _ { i , o } \cdot k _ { i } ) ) \mathrm { , ~ w h e r e ~ } k _ { i }  \ = \{ { 0 } \quad x _ { i } \geq 0 \atop \pi  \ .
+$$
+
+113 The iteration over $2 I$ represents the going through all inputs and their reciprocals. We calculate the   
+114 magnitude and sign separately, joining the result at the end. The magnitude is calculated passing   
+115 absolute of the concatenated input through an NMU architecture and the sign by using a cosine   
+116 mechanism similar to the Real NPU. However, unlike the Real NPU only the weight matrix is   
+117 required. The norm of the weight’s gradients are clipped to 1 prior to being updated by the optimiser.   
+118 This is done to alleviate the issue of exploding gradients caused by including the reciprocal to the   
+119 inputs. For clipping and regularisation, the same scheme as the NMU (see Appendix B) is used.
+
+Table 1: Interpolation (train/validation) and extrapolation (test) ranges used. Data (as floats) is drawn from a Uniform distribution with the range values as the lower and upper bounds.   
+
+<table><tr><td>Interpolation Extrapolation</td><td>[-20,-10) [-40, -20)</td><td>[-2, -1) [-6,-2)</td><td>[-1.2, -1.1) [-6.1, -1.2)</td><td>[-0.2,-0.1) [-2, -0.2)</td><td>[-2,2) [-6, -2), [2, 6)]</td></tr><tr><td>Interpolation</td><td>[0.1, 0.2)</td><td>[1,2)</td><td>[1.1, 1.2)</td><td>[10,20)</td><td></td></tr><tr><td>Extrapolation</td><td>[0.2,2)</td><td>[2,6)</td><td>[1.2, 6)</td><td>[20,40)</td><td></td></tr></table>
+
+# 120 4 Experiment Setup
+
+We introduce the two main experiments used to evaluate modules, including: default parameters, train and test ranges, and evaluation metrics. The tasks evaluate the ability of a single module to divide two numbers from an input vector in two settings: no redundancy and with redundancy.
+
+124 Default parameters: All experiments use a mean squared error (MSE) loss with an Adam optimiser   
+125 [Kingma and Ba, 2015], with 10,000 samples for the validation and test sets. The best model for   
+126 evaluation is taken using early stopping on the validation set. All runs are over 25 different seeds. All   
+127 inputs are required in the no redundancy setting, i.e., input size of 2. Training takes 50,000 iterations   
+128 where each iteration consists of a different batch of size 128. The Real NPU uses a learning rate of   
+129 5e-3 with sparsity regularisation scaling during iterations 40,000 to 50,000. The NRU and NMRU   
+130 use sparsity regularisation scaling during iterations 20,000 to 35,000 and a learning rate of 1 and 1e-2   
+131 respectively. In contrast, the redundancy setting uses an input size of 10, where 8 input values are not   
+132 required for the final output. The total training iterations are extended to 100,000 with batch sizes   
+133 of 128. The learning rates for the Real NPU, NRU and NMRU are 5e-3, 1e-3 and 1e-2 respectively.   
+134 Sparsity regularisation scaling occurs during iteration 50,000 to 75,000 for all modules. A summary   
+135 of all relevant parameters is found in Appendix C.   
+36 Ranges: The interpolation (train/validation) and extrapolation (test) ranges, are found in Table 1.   
+37 The chosen ranges are influenced by Madsen and Johansen [2020].   
+138 Evaluation metrics: We use the Madsen and Johansen [2019]’s evaluation scheme, consisting of   
+139 three evaluation metrics: the success on the extrapolation dataset against a near optimal solution   
+140 (success rate), the first iteration which the task is considered solved (speed of convergence), and   
+141 the extent of discretisation towards the weights’ inductive biases (sparsity error). Sparsity error   
+142 calculated by $\operatorname* { m a x } _ { i , o } ( \operatorname* { m i n } ( | W _ { i , o } | , 1 - | W _ { i , o } | ) )$ , measures the weight element which is the furthest away   
+143 from the acceptable discrete weights for the module. A success means the MSE of the trained model   
+144 is lower than a threshold value (i.e. the MSE of a near optimal solution). We differ from Madsen   
+145 and Johansen [2019] by using a fixed threshold value 1e-5 rather than a simulated MSE, as there   
+146 are no intermediate layers to accumulate numerical errors. We choose this precision as it can be   
+147 guaranteed when working with 32-bit PyTorch Tensors. $9 5 \%$ confidence intervals (over the 25 seeds)   
+148 are calculated from a specific family of distributions dependant on the metric. The success rate uses   
+149 Binomial distribution because trials (i.e. run on a single seed) are either pass/ fail situations. The   
+150 convergence metric uses a Gamma distribution and sparsity error uses a Beta distribution. Both Beta   
+151 and Gamma can easily approximate the normal distribution and support its corresponding metric.
+
+# 5 Improving the Real NPU’s Robustness
+
+We first improve the robustness of the Real NPU on different training ranges. We use the Single Module Task with no redundancy (see Section 4) to investigate the following questions:
+
+1. Is L1 regularisation required, and if so, do the regularisation parameters require tuning?   
+2. Does clipping the weight matrix aid learning?   
+3. Does enforcing discretisation on parameters improve convergence?   
+4. Can the weight matrix initialisation be improved?   
+159 To address each question in order, we propose applying incremental modifications to the Real NPU.   
+160 These modifications include: ablation study on the L1 regularisation (including a sweep over the   
+161 scaling range hyperparameters), clipping, enforcing discretisation, and a more restrictive initialisation   
+162 scheme. We assume that we are optimising the Real NPU to perform multiplication or division.   
+163 Therefore, we trade-off the flexibility of having non-discretised weights, which enables the success of   
+164 modelling the SIR data in Heim et al. [2020, Section 4.1] , in favour of sparse models with discrete   
+165 weight values. All the modifications suggested can also be generalised for the NPU architecture.   
+166 Is L1 regularisation required? (Yes) L1 encourages sparsity (i.e., zero weights) in solutions.   
+167 Zero-valued weights means not to select an input and return the identity value 1. For the task, the   
+168 optimal weight values require selecting all inputs and therefore non-zero values, suggesting the   
+169 application of L1 could be damaging. Therefore, we compare against a model which does not use   
+170 L1 regularisation, shown in Figure 1a. Removing L1 proves to be detrimental in five of the nine   
+171 cases shown and only shows minor improvements in two of the nine ranges (i.e., $\mathcal { U } [ - 1 . 2 , - 1 . 1 )$ and   
+172 U[1.1,1.2)). Hence, we keep L1 regularisation. The L1 regularisation scaling (see Section 3.1),   
+173 requires setting the hyperparameters for the start $( \beta _ { s t a r t } )$ and end $( \beta _ { e n d } )$ scaling values. We run a   
+174 sweep over six different start and end values, denoted (<start>, <end>), displaying results in Figure 1b.   
+175 We find the configuration (1e-9, 1e-7) is the most successful when considering performance on all   
+176 the ranges, and larger scaling values perform worse.   
+177 Does clipping the learnable parameters help? (Yes) Division and multiplication operations are   
+178 represented by weight values of -1 and 1 respectively. The current architecture does not constrain the   
+179 weights which can result in large weight values. The gate weights do get clipped and saved to another   
+180 variable during the forward pass, meaning after an update step the gate values can also be out of the   
+181 range [-1,1]. Hence, we investigate the effect of applying clipping directly to the weight and gate   
+182 values after every optimisation step. Results, shown in Figure 2a, show clipping is beneficial, with   
+183 clipping on both weight and gate (or just on the weights) to improve over the baseline on all ranges   
+184 (excluding $\mathcal { U } [ 1 , 2 )$ where the baseline has already achieved full success).   
+185 Does enforcing discretisation help? (Yes) Modelling division in a generalisable manner requires   
+186 all learnable parameters to be discrete i.e., a value from {-1, 0, 1}. Using Madsen and Johansen   
+187 [2020]’s regularisation scaling scheme, we penalise weights for not being discrete. We modify the   
+188 scaling factor to be $\hat { \lambda } = 1$ and the regularisation to go from ‘off’ to ‘on’ between iterations 40,000 to   
+189 50,000. Results, shown in Figure 2b, show discretising the gate improves over the baseline but also   
+190 discretising the weights is additionally beneficial (especially for range U [-0.2,-0.1)). U [10,20) is the   
+191 only range where the baseline outperforms using discretisation, succeeding on two additional seeds.   
+192 Does using a more constrained initialisation help? (Yes) $W ^ { ( r ) }$ uses a Xavier-Uniform initial  
+193 isation [Glorot and Bengio, 2010]. This can result in weights initialised out of the range [-1,1].   
+194 Therefore, we use the initialisation for the Neural Addition Unit which is a constrained form of   
+195 the Xavier-Uniform that does not allow the fan values of the uniform distribution to go beyond 0.5,   
+196 meaning that no weight value will be out of the range [-1,1] [Madsen and Johansen, 2020]. Figure 2c   
+197 shows using the constrained initialisation provides improvements over multiple ranges.
+
+![](images/9e3a08fb53f29f2be5884a025a12ec03e754b74b7927a35d1b6c74f0b9c7c485.jpg)  
+Figure 1: Exploring the effect and sensitivity of L1 regularisation on the Real NPU
+
+![](images/b753ab1ab2d4e27b531dd4960cec3c53d9d00633e16aa85713a702f1e095a8dd.jpg)  
+Figure 2: Effect of clipping, discretisation, and the NAU initialisation scheme on the Real NPU.
+
+![](images/27ca24ced743312991fb11ff7653d651fc84a051b3432d67833ad53b05653de8.jpg)  
+Figure 3: Division without redundancy (input size 2).
+
+# 6 Results: Single Module Task
+
+We analyse the results for the: Real NPU without using the modifications of Section 5, Real NPU with modifications, NRU, and NMRU.
+
+# 6.1 No Redundancy
+
+Figure 3 shows the baseline Real NPU without modifications struggles with all ranges except U[1,2), struggling with sparsity on the larger ranges. Applying the modifications deals with the sparsity issue and improves the robustness such that only range $\mathcal { U } [ - 2 , 2 )$ struggles (with a success rate of 0.64). The NRU and NMRU achieve full success over all ranges while solving the problem consistently fast and with low sparsity error. The success of the NRU is correlated with the learning rate (see Appendix E).
+
+# 6.1.1 Mixed-signed Inputs
+
+The remaining failure range of the Real NPU is U [-2,2) where inputs can consist of arbitrary signed values (e.g. all positives, all negatives, or a mixture of positive and negative values). We question if the failure is due to the input samples in a batch having different signs from each other, or if the problem is due to the fact data samples can be close to 0 (leading to singularity issues). To investigate
+
+![](images/b9350e8bef44837579e91416f79f6fdfd40143301410c9eff9832f00ec8d6449.jpg)  
+Figure 4: Extrapolation results on training the Real NPU using mixed-sign datasets that control the sign of the input elements. The ranges are in order of the datasets (i.e. dataset 1 to 5).
+
+![](images/6312b0065a51e06c3c53208f54c12008995bfff4f03be60f13a1ba729eb3b569.jpg)  
+Figure 5: Effect of the singularity issue on the Real NPU, NRU and NMRU over increasing input ranges. Left: Reciprocal for an input size of 1 (no redundancy). Middle: Reciprocal for an input size of 2 (with redundancy). Right: Division for an input size of 2 (no redundancy).
+
+212 this, we create additional mixed-sign datasets, controlling the range for each element in the input. The   
+213 interpolation and extrapolation ranges for the different datasets can be found in Appendix C. Datasets   
+214 1, 2, 4 and 5 sample a positive value for one input element and a negative value for the other element.   
+215 Dataset 3 samples the signs randomly. Datasets 2 and 5 avoid sampling close to 0 values to mitigate   
+216 the singularity issue. As shown by Figure 4, the Real NPU struggles on all these ranges, implying that   
+217 the core issue is not from different input samples having different signs or due to the input samples   
+218 being able to contain small values close to 0. The underlying issue is therefore most likely correlated   
+219 to the each element in an input having different signs. When the denominator of the output is positive   
+220 (dataset 1 or 2), the solution is found faster than when the denominator is a negative value (dataset 4   
+221 or 5). When the signs for an input element are controlled, discretisation/sparsity is no problem, in   
+222 contrast when the signs are arbitrary the sparsity error are slightly (though not significantly) higher.
+
+# 6.2 Division by Small Numbers
+
+Division by zero remains a challenge to model due to the inability to provide an computational value for the output and gradient. Furthermore, the discontinuous nature at zero causes its neighbouring values to have large gradients. To understand the extent of this issue when learning, we explore learning to divide by values close to zero using three tasks with increasing difficulty: 1) learning to take the reciprocal of a single input, 2) taking the reciprocal of the first input given two inputs, and 3) diving the first input by the second given two inputs. Figure 5 plots the test error for different modules assuming the module weights are set to the ‘gold’ solution for the three tasks. As the range values become closer to zero, the test error thresholds become increasingly large. Therefore, even with the correct weights, relying on the test errors alone as an indicator become increasingly deceptive with values close to zero. The Real NPU has larger test errors for all tasks and ranges, caused by adding $\epsilon$ to the input (see Equation 3). Setting $\epsilon = 0$ reduces the test error at the cost of the ability to deal with zero-valued inputs. Appendix F provides the corresponding experimental results for these tasks.
+
+![](images/dfa2cb434d655e5a99b3201cf2cf435ea7eb20cf9286d0ad7432d695f9166a17.jpg)  
+Figure 6: Division with redundancy (input size 10).
+
+# 6.3 With Redundancy
+
+Introducing redundancy (Figure 6) causes failure modes to arise. Failures on range U[-2,2) become more prevalent. The baseline Real NPU produces high sparsity errors relative to the other modules suggesting struggle with discretisation. Using the modified Real NPU improves over all ranges of the baseline (which were not already at full success) in terms of success, speed and sparsity.2 To ensure that complex weights do not fix the issue, we test the NPU module with all the modifications used on the real weight matrix (see Appendix G). Complex weights hinders success and convergence speeds of negative ranges. Assuming the global solution only uses the real weights, we enforce the complex weights to be clipped between [-1,1] and to go to 0 during the regularisation stage using a L1 penalty. This did not result in any significant improvements against the Real NPU results. Input redundancy effects the NRU the most, resulting in full failures on all the negative ranges. The NMRU is the only module with success for the range $\mathcal { U } [ - 2 , 2 )$ , which is a result of using the sign mechanism (see Appendix H). It performs well over all ranges though can be outperformed by the modified Real NPU for negative ranges. Multiple ranges for the NMRU are solved around 50,000 iterations correlating to the sparsity regularisation being turned on.
+
+# 6.3.1 Gradient Difficulties with the NRU
+
+252 The partial derivative for the NRU weights, Equation 6, can give insight to the struggles of the NRU.
+
+$$
+\begin{array} { r l r } & { } & { \displaystyle \frac { \partial \hat { \bf y } } { \partial w _ { i } } = \mathrm { t a n h } ( 1 0 0 0 w _ { i } ) ( \mathrm { s i g n } ( x _ { i } ) | x _ { i } | ( \mathrm { t a n h } ( 1 0 0 0 w _ { i } ) \log ( | x | ) + } \\ & { } & { \displaystyle 2 0 0 0 \mathrm { s e c h } ( 1 0 0 0 w _ { i } ) ^ { 2 } ) - 2 0 0 0 \mathrm { s e c h } ( 1 0 0 0 w _ { i } ) ^ { 2 } ) \times \mathrm { N R U } _ { \tilde { \bf x } \in { \bf x } \backslash \{ { \bf x } _ { i } \} } ( \tilde { \bf x } ) . } \end{array}
+$$
+
+$\_$ applies the NRU to all inputs excluding $x _ { i }$ influencing the gradient values between subsequent update steps. Factoring out this term, the following observations are made. If $x _ { i } \approx 0$ and $w _ { i } \approx 0$ then gradients become increasingly large. If $x _ { i } \approx 0$ and $- 1 \leq w _ { i } < 0$ then as $w _ { i } \to - 1$ all gradients for $x _ { i }$ where $| x _ { i } | > > 1$ become increasingly small. The gradients for $x _ { i } = - 1$ and $x _ { i } = 1$ are 0 regardless the value of $w _ { i }$ . If $w _ { i } = 0$ then the gradient is 0 for all $x _ { i }$ , a result of using the tanh approximation. Even if the sign and magnitude are calculated separately and then combined (see Appendix I) to try to control the gradient better, the problem remains. Therefore, we conclude that extending the NMU to divide using a weight of -1 is a poor choice when there are redundant inputs.
+
+![](images/66ed3f0eee25ac2b1a0c761d4b2eb34b0ef8ac43e9bb7e26723d0bf2229b6cdb.jpg)  
+Figure 7: Root Mean Squared loss curvature for the NAU stacked with either a RealNPU, NRU, or NMRU. "The weight matrices are constrained to $\mathbf { W } _ { 1 } = \left[ \begin{array} { l l l } { w _ { 1 } \ w _ { 1 } } & { 0 } & { 0 } \\ { w _ { 1 } \ w _ { 1 } \ w _ { 1 } \ w _ { 1 } } & { w _ { 1 } } \end{array} \right]$ , $\mathbf { W } _ { 2 } = \left[ w _ { 2 } \ w _ { 2 } \right]$ . The problem is $( x _ { 1 } + x _ { 2 } ) \cdot ( x _ { 1 } + x _ { 2 } + x _ { 3 } + x _ { 4 } )$ for $x = ( 1 , 1 . 2 , 1 . 8 , 2 ) "$ [Madsen and Johansen, 2020]. The ideal solution is $w _ { 1 } = w _ { 2 } = 1$ , though other valid solutions do exist e.g., $w _ { 1 } = - 1 , w _ { 2 } = 1$ . (The NMRU’s weight matrix would be $\bar { \bf W _ { 2 } } = [ w _ { 2 } \ w _ { 2 } \ 0 \ 0 ]$ , and the Real NPU’s $\mathbf { g } = \left[ 1 \mathbf { \Omega } ^ { 1 } \right]$ . )
+
+# 261 6.3.2 The Real NPU’s and NMRU’s Exploitation of Multiplicative Rules
+
+The NMRU solutions exploit the inverse rule of division in that 1 = 1. Since the input also contains the reciprocals, numerous extrapolative solutions exist. However this comes at the cost of finding a ‘simple’ solution which contains ones only for relevant inputs. The Real NPU exploits the rules $a _ { i } \cdot 0 = 0$ and $1 ^ { a _ { i } } = 1$ enabling non-zero weight values if the corresponding gate value is 0. However, we can avoid this by allowing 0 to also not be penalised during sparsity regularisation stage (see Appendix G). We find this alleviates the exploitation issue with no cost to performance.
+
+# 268 7 Discussion
+
+269 In this paper, we demonstrate the limitations of intepretable neural networks in learning to divide.   
+270 Using the no redundancy setting (size 2), we find that the Real NPU is challenged when training data   
+271 consists of mixed-signed inputs even with our applied improvements. Increasing the difficulty to   
+272 have an input redundancy (with 8 redundant and 2 relevant input values) magnifies this issue, but   
+273 also introduces failure modes for the NRU and NMRU for negative ranges. The NRU is unable to   
+274 handle any negative ranges, in which we conclude it is not wise to use with MSE. Alternate losses   
+275 can improve certain failure cases though sometimes at the cost of performance on other ranges. For   
+276 further details see Appendix J which displays results on a correlation and scale-invariant based loss.   
+277 Our NMRU is the only module with reasonable success over all tested ranges, requiring only $2 I \times O$   
+278 learnable parameters. However, this comes at the cost of the simplicity of the solution due to its   
+279 exploitation of the identity rule; an issue the Real NPU does not have.
+
+Once robust modules are attainable in a single layer setting, the next step would be to question performance when learning stacked modules, e.g. learning a stacked additive and multiplicative module. Previously, Madsen and Johansen [2020, Figure 2] illustrates the troubles for multiplicative models with the capacity for division. They show how a stacked summative-multiplicative module can lead to an exploding loss when the output of the summative module is close to 0 and the multiplicative model tries to divide. In Figure 7, we recreate their setup to produce the loss surfaces for the NAUReal $\mathrm { N P U } ^ { 3 }$ , NAU-NRU and NAU-NMRU respectively. 4 We find a similar issue with the Real-NPU and NRU, as both these units use a weight range of [-1,1]. In contrast, the NMRU, whose weight’s range is limited to [0,1] does not have exploding losses.
+
+In conclusion, division remains a challenge to learn using intepretable neural networks, even for the simplest tasks. Nevertheless, by identifying the specific areas causing difficulty (e.g., training ranges), and useful architecture properties (e.g., using a sign retrieval mechanism), we hope the community has better intuition for dealing with division and develop more robust modules to learn division.
+
+# References
+
+Girish Chandrashekar and Ferat Sahin. A survey on feature selection methods. Computers & Electrical Engineering, 40(1):16–28, 2014. ISSN 0045-7906. doi: https://doi.org/10.1016/j.comp eleceng.2013.11.024. URL https://www.sciencedirect.com/science/article/pii/S0 045790613003066. 40th-year commemorative issue.   
+Lukas Faber and Roger Wattenhofer. Neural status registers. CoRR, abs/2004.07085, 2020. URL https://arxiv.org/abs/2004.07085.   
+Xavier Glorot and Yoshua Bengio. Understanding the difficulty of training deep feedforward neural networks. In Proceedings of the thirteenth international conference on artificial intelligence and statistics, pages 249–256. JMLR Workshop and Conference Proceedings, 2010. URL http: //proceedings.mlr.press/v9/glorot10a/glorot10a.pdf.   
+Niklas Heim, Tomáš Pevny, and Václav Šmídl. Neural power units. \` Advances in Neural Information Processing Systems, 33, 2020. URL https://papers.nips.cc/paper/2020/file/48e5900 0d7dfcf6c1d96ce4a603ed738-Paper.pdf.   
+Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. CoRR, abs/1412.6980, 2015. URL https://arxiv.org/pdf/1412.6980.pdf.   
+Andreas Madsen and Alexander Rosenberg Johansen. Measuring arithmetic extrapolation performance. In Science meets Engineering of Deep Learning at 33rd Conference on Neural Information Processing Systems (NeurIPS 2019), volume abs/1910.01888, Vancouver, Canada, October 2019. URL https://arxiv.org/pdf/1910.01888.pdf.   
+Andreas Madsen and Alexander Rosenberg Johansen. Neural arithmetic units. In International Conference on Learning Representations, 2020. URL https://openreview.net/forum?id= H1gNOeHKPS.   
+Bhumika Mistry, Katayoun Farrahi, and Jonathon Hare. A primer for neural arithmetic logic modules, 2021. URL https://arxiv.org/pdf/2101.09530.pdf.   
+Subham Sahoo, Christoph Lampert, and Georg Martius. Learning equations for extrapolation and control. In International Conference on Machine Learning, pages 4442–4450. PMLR, 2018.   
+Daniel Schlör, Markus Ring, and Andreas Hotho. inalu: Improved neural arithmetic logic unit. Frontiers in Artificial Intelligence, 3:71, 2020. ISSN 2624-8212. doi: 10.3389/frai.2020.00071. URL https://www.frontiersin.org/article/10.3389/frai.2020.00071.   
+Andrew Trask, Felix Hill, Scott E Reed, Jack Rae, Chris Dyer, and Phil Blunsom. Neural arithmetic logic units. In Advances in Neural Information Processing Systems, pages 8035–8044, 2018. URL https://openreview.net/pdf?id=H1gNOeHKPS.   
+Silviu-Marian Udrescu and Max Tegmark. Ai feynman: A physics-inspired method for symbolic regression. Science Advances, 6(16), 2020. doi: 10.1126/sciadv.aay2631. URL https: //advances.sciencemag.org/content/6/16/eaay2631.
+
+# Checklist
+
+1. For all authors...
+
+(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes] See contributions in the introduction. For Real NPU improvements see Section 5. For two novel modules see Section 3.2 and 3.3 and results in Section 6. For hindrances in learning division, see Section 6.   
+(b) Did you describe the limitations of your work? [Yes] See Section 7.   
+(c) Did you discuss any potential negative societal impacts of your work? [Yes] This paper focuses on the ML techniques and the foundational research required to learn division in a systematic manner. Once robust modules for the arithmetic operations (i.e. NALMs) are achievable the community will possess trainable modules with significant advantages regarding model transparency and generalisability. That being said, we discuss how this leads to a negative societal impact in the end of Section 1.
+
+(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes] We have read the guidelines and our work does not use human-derived data.
+
+2. If you are including theoretical results...
+
+(a) Did you state the full set of assumptions of all theoretical results? [N/A] (b) Did you include complete proofs of all theoretical results? [N/A]
+
+3. If you ran experiments...
+
+(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [Yes] See link provided to the code base. Data is generated in real time and the code to generate it is available in the linked repository.   
+(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] See Section 4 and Appendix C.   
+(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [Yes] See plots and experiment details in Section 4 for further details.   
+(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [Yes] See Appendix D.
+
+4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets...
+
+(a) If your work uses existing assets, did you cite the creators? [Yes] See footnote link provided to the code base and Section 4.   
+(b) Did you mention the license of the assets? [Yes] We state the MIT licence when giving the link to the codebase.   
+(c) Did you include any new assets either in the supplemental material or as a URL? [Yes] All code for model, data and experiments are available through the link to the codebase.   
+(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A]   
+(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [No] All data is synthetic, containing no such information.
+
+5. If you used crowdsourcing or conducted research with human subjects...
+
+(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   
+(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   
+(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A]

parse/train/3WbWmdTd8fN/3WbWmdTd8fN_content_list.json

@@ -0,0 +1,1103 @@
+[
+    {
+        "type": "text",
+        "text": "Learning Division with Neural Arithmetic Logic Modules ",
+        "text_level": 1,
+        "bbox": [
+            209,
+            122,
+            790,
+            171
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous Author(s)   \nAffiliation   \nAddress   \nemail ",
+        "bbox": [
+            423,
+            222,
+            578,
+            276
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            313,
+            535,
+            329
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 To achieve systematic generalisation, it first makes sense to master simple tasks   \n2 such as arithmetic. Of the four fundamental arithmetic operations $( + , - , \\times , \\div )$ ,   \n3 division is considered the most difficult for both humans and computers. In this   \n4 paper we show that robustly learning division in a systematic manner remains a   \n5 challenge even at the simplest level of dividing two numbers. We propose two   \n6 novel approaches for division which we call the Neural Reciprocal Unit (NRU) and   \n7 the Neural Multiplicative Reciprocal Unit (NMRU), and present improvements for   \n8 an existing division module, the Real Neural Power Unit (Real NPU). Experiments   \n9 in learning division with input redundancy on 225 different training sets, find that   \n10 our proposed modifications to the Real NPU obtains an average success of $8 5 . 3 \\%$   \n11 improving over the original by $1 5 . 1 \\%$ . In light of the suggestion above, our NMRU   \n12 approach can further improve the success to $9 1 . 6 \\%$ . ",
+        "bbox": [
+            148,
+            345,
+            766,
+            512
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "13 1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            539,
+            312,
+            556
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "14 Imagine you must learn to divide 2 numbers, but are only given 10 numbers and the target value. This   \n15 task requires finding the 2 relevant operands, the order to divide the operands, and learning to divide.   \n16 In machine learning, this is equivalent to a supervised regression task where the aim is to learn the   \n17 underlying function between the inputs and output such that the solution is generalisable to any input.   \n18 The ability to select relevant features is a desirable property of neural networks, useful for improved   \n19 intepretability, reduced pre-processing costs and greater generalisation [Chandrashekar and Sahin,   \n20 2014]. The ability to model division, one of the four fundamental arithmetic operations, is necessary   \n21 for expressing dynamical systems [Sahoo et al., 2018], and physics-based formulas [Udrescu and   \n22 Tegmark, 2020]. However, even recent models still struggle to learn division when there is input   \n23 redundancy [Schlör et al., 2020].   \n24 The main challenge of the above task comes from learning the selection and operation at the same   \n25 time, which can lead to conflicting priorities when learning network weights. Furthermore, the natural   \n26 properties of division of values around zero leads to undesirable gradients. Models which deal with   \n27 this naively (e.g. MLPs) are unable to deal with the fluctuant gradients caused by the asymptotic   \n28 nature and discontinuities in division [Trask et al., 2018]. ",
+        "bbox": [
+            147,
+            571,
+            825,
+            710
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            717,
+            825,
+            786
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "9 Can we build models which can learn division in the presence of its undesirable, yet valid, properties? We aim to address this question in this paper. Specifically, we contribute the following:0 ",
+        "bbox": [
+            156,
+            791,
+            825,
+            820
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "• Improvements to the Real NPU [Heim et al., 2020] including: clipping, discretisation and constrained initialisation to improve performance in learning division on different training ranges. ",
+        "bbox": [
+            168,
+            832,
+            823,
+            861
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "33 • Two novel division modules, the NRU and the NMRU. The NRU explores extending the NMU   \n34 weight ranges from [0,1] to [-1,1] to include division, where we find a weakness in learning from   \n35 negative ranges. Learning from the weaknesses of the NRU, the NMRU extends the NMU to learn   \n36 division while keeping weights values between [0,1]. We further boost performance by using a   \n37 Real NPU inspired sign retrieval mechanism, enabling the NMRU to gain the best performance   \n38 when using a mean squared error (MSE) loss.   \n39 • New understanding into the hindrances in learning division including: training on mixed-sign   \n40 inputs, training on negative ranges, and division on extremely small values. We find these difficulties   \n41 can be sufficiently identified using synthetic division tasks.   \n42 The broader impact of our work relates to interpretable Artificial Intelligence where our modules   \n43 can be included in larger networks for applications such as image classification or analogy creation,   \n44 whilst retaining the ability to produce transparent generalisable solutions. However, there are possible   \n45 negative societal impacts. Such modules can be viewed as specialised feature selectors/aggregators   \n46 which do not require integrating domain knowledge. Therefore, if a non-domain-expert tries inter  \n47 preting relations in the input data, they may incorrectly interpret causality, which can be especially   \n48 harmful if such a case occurs on medical or financial data. Mitigating against such downstream issues   \n49 requires to first focus efforts on producing robust modules to different distributions and understand   \n50 their affect on learning other networks architectures (e.g. CNN). Understanding this will enable   \n51 recognising situations where these modules can aid and where they should avoid being used. ",
+        "bbox": [
+            145,
+            90,
+            825,
+            220
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            231,
+            825,
+            369
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "52 2 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            153,
+            387,
+            320,
+            405
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "53 One approach to learn division would be symbolic regression networks [Sahoo et al., 2018]. However,   \n54 a symbolic approach pre-defines the operations, which is not a limitation of using Neural Arithmetic   \n55 Logic Modules (NALMs).   \n56 NALMs are neural networks which learn arithmetic operations and input selection [Mistry et al.,   \n57 2021]. The weights of these networks are intepretable such that a discrete value represents a specific   \n58 operation. For example, ‘-1’ to represent division and $\\cdot _ { 0 } \\cdot \\mathrm { ~ }$ for no selection. From this research field,   \n59 we focus on the Real NPU and the NMU. Until now, the Real NPU only has learned division on   \n60 training ranges of either $\\mathcal { U } [ 0 . 1 , 2 ]$ or Sobol(0,0.5) [Heim et al., 2020]. It remains unclear if this   \n61 module is robust to other training ranges even as a stand-alone unit. Robustness to training ranges is   \n62 important as these module’s applicational use comes from being part of larger end-to-end networks,   \n63 where the input range into the module cannot be controlled. The NMU is a multiplication module   \n64 which we extend to also do division. The authors of the NMU believe such an extension incurs too   \n65 many limitations for learning [Madsen and Johansen, 2020]. We use this paper as an opportunity to   \n66 explore this belief.   \n67 Trask et al. [2018] developed the Neural Arithmetic Logic Unit (NALU) which can model all four   \n68 arithmetic operations. However, studies show this module to be unstable in learning division [Schlör   \n69 et al., 2020, Heim et al., 2020]. In particular, their gating method responsible for selecting an operation   \n70 cannot learn consistently [Madsen and Johansen, 2020]. Schlör et al. [2020] developed iNALU   \n71 additionally applying weight and gradient clipping, sign retrieval, regularisation, reinitialisation and   \n72 separating shared parameters to the NALU. Even with these modifications, they still find consistently   \n73 learning division to a high precision to remain unattainable. Furthermore, Heim et al. [2020]’s results   \n74 imply iNALU is outperformed by the Real NPU for division. ",
+        "bbox": [
+            147,
+            419,
+            825,
+            460
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            467,
+            825,
+            618
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            625,
+            825,
+            736
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "75 3 Architectures ",
+        "text_level": 1,
+        "bbox": [
+            150,
+            756,
+            318,
+            772
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "76 This section introduces the architectures for the (Real) NPU, NRU, and the NMRU. The (Real) NPU   \n77 is an existing module, which we improve in Section 5. The NRU and NMRU are novel contributions.   \n78 Appendix A summarises the important properties of these division modules. ",
+        "bbox": [
+            148,
+            785,
+            825,
+            828
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3.1 Real Neural Power Unit ",
+        "text_level": 1,
+        "bbox": [
+            171,
+            843,
+            379,
+            858
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "80 Heim et al. [2020] develop a module to learn to multiply and divide, using the intuition from Trask   \n81 et al. [2018] that multiplicative operations are additive operations in log space. Their work extends   \n82 this idea into complex space. The NPU can be used with its complex form (Equation 1) requiring both   \n83 a complex and real weight matrix $( W ^ { ( i ) } , W ^ { ( r ) } )$ , or only its real form the Real NPU (Equation 2).   \n84 For improved gradients, a relevance gate $\\mathbfit { \\Delta } \\mathbf { r }$ (Equation 3) is used which converts inputs close to 0 (i.e.   \n85 irrelevant features) to 1 to avoid the resulting output evaluating to 0. A gating vector $\\textbf {  { g } }$ , learns to   \n86 select relevant input elements, where gate values are clipped between [0,1] during training. ",
+        "bbox": [
+            147,
+            869,
+            823,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            89,
+            826,
+            147
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b46fb9198ccda293fa0eb944438a8df746cd789d9fdb4b2ff1102607a9935e3f.jpg",
+        "text": "$$\n\\mathrm { N P U } : = \\exp ( { W ^ { ( r ) } \\log ( r ) - W ^ { ( i ) } k } ) \\odot \\cos ( { W ^ { ( i ) } \\log ( r ) + W ^ { ( r ) } k } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            254,
+            151,
+            723,
+            171
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "87 ",
+        "bbox": [
+            147,
+            179,
+            160,
+            188
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8759b8f27a6f318d9223ffd0c39272f2e3bf67a0a06fb7efaed9a6566f02c9ad.jpg",
+        "text": "$$\n\\mathrm { R e a l N P U } : = \\exp ( W ^ { ( r ) } \\log ( r ) ) \\odot \\cos ( W ^ { ( r ) } k )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            326,
+            185,
+            656,
+            205
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/993643c0f0f694ebc57379cc8eab2bf2637a910b10c1a534efc7707537a10ee7.jpg",
+        "text": "$$\n\\mathrm { e r e } \\quad r = g \\odot ( | { \\pmb x } | + \\epsilon ) + ( { \\bf 1 } - { \\pmb g } ) \\quad \\mathrm { a n d } \\quad k _ { i } = \\left\\{ 0 \\qquad x _ { i } \\geq 0 \\atop \\pi { \\bf g _ { i } } \\quad x _ { i } < 0  \\right. .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            294,
+            214,
+            725,
+            250
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "89 A weighted L1 penalty is used when training. The weight value $\\beta$ grows between predefined values   \n90 $\\beta _ { s t a r t }$ to $\\beta _ { e n d }$ and is increased every $\\beta _ { s t e p } = 1 0 , 0 0 0$ iterations by a growth factor $\\beta _ { g r o w t h } = 1 0$ .   \n91 We focus on the Real NPU over the NPU as the solution of the tasks in this paper can be captured   \n92 using only real values meaning that the complex form is not required. ",
+        "bbox": [
+            145,
+            255,
+            826,
+            311
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "93 3.2 Neural Reciprocal Unit ",
+        "text_level": 1,
+        "bbox": [
+            158,
+            327,
+            375,
+            342
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "94 We propose the NRU, which can model multiplication and division. We extend the NMU, motivated   \n95 by division being multiplication of reciprocals. The range which weight values can be is extended   \n96 from [0,1] to [-1,1], where $^ { - 1 }$ represents applying the reciprocal on the corresponding input element.   \n97 A NRU output element $z _ { o }$ is defined as ",
+        "bbox": [
+            145,
+            352,
+            826,
+            409
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/87e1dfda1d0f2170575a099941f113cf2873ff9645c9989a49592bbc2968da45.jpg",
+        "text": "$$\n\\mathrm { N R U : ~ } z _ { o } = \\prod _ { i = 1 } ^ { I } ( \\mathrm { s i g n ( x } _ { i } ) \\cdot | \\mathbf { x } _ { i } | ^ { W _ { i , o } } \\cdot | W _ { i , o } | + 1 - | W _ { i , o } | ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            302,
+            412,
+            694,
+            457
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "98 where $I$ is the number of inputs. Assuming weights are either 1 (multiply) or $^ { - 1 }$ (reciprocal), $\\left| \\mathbf { x } _ { i } \\right| ^ { W _ { i , o } }$   \n99 will apply the operation on an input element. The absolute value is used so that the module only   \n100 operates in the space of real numbers, as $x _ { i } ^ { W _ { i , o } }$ for a negative input $( x _ { i } )$ when $- 1 < W _ { i , o } < 1$ results   \n101 in a complex number. The use of absolute means the sign of the input must be reapplied. For the   \n102 no-selection case $W _ { i , o } = 0$ , we want the input element to convert to 1 (the identity value), resulting   \n103 in applying $| W _ { i , o } | + 1 - | W _ { i , o } |$ . The derivative of the absolute function at 0 is undefined meaning the   \n104 gradients of Equation 4 can contain points of discontinuity. To alleviate this issue, we approximate   \n105 the absolute function using a scaled tanh (inspired by Faber and Wattenhofer [2020]). More formally, ",
+        "bbox": [
+            142,
+            460,
+            825,
+            577
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9f1f6c07f5db0ecf6bb8b5935d5b5f806308a85f68f85141393d961f0ecfeeb6.jpg",
+        "text": "$$\n| W _ { i , o } | = \\left\\{ \\begin{array} { l l } { \\operatorname { t a n h } ( 1 0 0 0 \\cdot W _ { i , o } ) ^ { 2 } } & { \\mathrm { i f ~ t r a i n i n g } } \\\\ { | W _ { i , o } | } & { \\mathrm { o t h e r w i s e } } \\end{array} . \\right.\n$$",
+        "text_format": "latex",
+        "bbox": [
+            351,
+            582,
+            647,
+            617
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "106 The scale factor (1000) controls how close to the absolute function the approximation is, where larger   \n107 values give a more accurate approximation. For clipping and regularisation, the same scheme as the   \n108 Neural Addition Unit (NAU) (see Appendix B) is used. ",
+        "bbox": [
+            142,
+            621,
+            825,
+            665
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "109 3.3 Neural Multiplicative Reciprocal Unit ",
+        "text_level": 1,
+        "bbox": [
+            143,
+            679,
+            477,
+            695
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "110 An alternate extension of the NMU, also motivated by division being multiplication of reciprocals   \n111 is the NMRU (Equation 5). We concatenate the reciprocal of the input (plus a small $\\epsilon$ ) to the input   \n112 resulting in a module which only needs to learn selection. Hence, weights can be in the range [0,1]. ",
+        "bbox": [
+            140,
+            704,
+            825,
+            747
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/45d160439d799aa4d21a18c6a3a310865a4c66e1d762b8cb74f88f9f9c5446fc.jpg",
+        "text": "$$\n\\mathrm { N M R U } : z _ { o } = \\prod _ { i = 1 } ^ { 2 I } ( W _ { i , o } \\cdot | \\mathbf { x } _ { i } | + 1 - W _ { i , o } ) \\cdot \\sum _ { i = 1 } ^ { 2 I } ( \\cos ( W _ { i , o } \\cdot k _ { i } ) ) \\mathrm { , ~ w h e r e ~ } k _ { i }  \\ = \\{ { 0 } \\quad x _ { i } \\geq 0 \\atop \\pi  \\ .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            183,
+            752,
+            812,
+            795
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "113 The iteration over $2 I$ represents the going through all inputs and their reciprocals. We calculate the   \n114 magnitude and sign separately, joining the result at the end. The magnitude is calculated passing   \n115 absolute of the concatenated input through an NMU architecture and the sign by using a cosine   \n116 mechanism similar to the Real NPU. However, unlike the Real NPU only the weight matrix is   \n117 required. The norm of the weight’s gradients are clipped to 1 prior to being updated by the optimiser.   \n118 This is done to alleviate the issue of exploding gradients caused by including the reciprocal to the   \n119 inputs. For clipping and regularisation, the same scheme as the NMU (see Appendix B) is used. ",
+        "bbox": [
+            140,
+            814,
+            825,
+            912
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "table",
+        "img_path": "images/7ce71f48ba5b1b7ea7dce5a9d28199db99d369f3e8a691c5382d73543e3ee65a.jpg",
+        "table_caption": [
+            "Table 1: Interpolation (train/validation) and extrapolation (test) ranges used. Data (as floats) is drawn from a Uniform distribution with the range values as the lower and upper bounds. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Interpolation Extrapolation</td><td>[-20,-10) [-40, -20)</td><td>[-2, -1) [-6,-2)</td><td>[-1.2, -1.1) [-6.1, -1.2)</td><td>[-0.2,-0.1) [-2, -0.2)</td><td>[-2,2) [-6, -2), [2, 6)]</td></tr><tr><td>Interpolation</td><td>[0.1, 0.2)</td><td>[1,2)</td><td>[1.1, 1.2)</td><td>[10,20)</td><td></td></tr><tr><td>Extrapolation</td><td>[0.2,2)</td><td>[2,6)</td><td>[1.2, 6)</td><td>[20,40)</td><td></td></tr></table>",
+        "bbox": [
+            214,
+            137,
+            782,
+            209
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "120 4 Experiment Setup ",
+        "text_level": 1,
+        "bbox": [
+            142,
+            233,
+            357,
+            251
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We introduce the two main experiments used to evaluate modules, including: default parameters, train and test ranges, and evaluation metrics. The tasks evaluate the ability of a single module to divide two numbers from an input vector in two settings: no redundancy and with redundancy. ",
+        "bbox": [
+            160,
+            265,
+            823,
+            308
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "124 Default parameters: All experiments use a mean squared error (MSE) loss with an Adam optimiser   \n125 [Kingma and Ba, 2015], with 10,000 samples for the validation and test sets. The best model for   \n126 evaluation is taken using early stopping on the validation set. All runs are over 25 different seeds. All   \n127 inputs are required in the no redundancy setting, i.e., input size of 2. Training takes 50,000 iterations   \n128 where each iteration consists of a different batch of size 128. The Real NPU uses a learning rate of   \n129 5e-3 with sparsity regularisation scaling during iterations 40,000 to 50,000. The NRU and NMRU   \n130 use sparsity regularisation scaling during iterations 20,000 to 35,000 and a learning rate of 1 and 1e-2   \n131 respectively. In contrast, the redundancy setting uses an input size of 10, where 8 input values are not   \n132 required for the final output. The total training iterations are extended to 100,000 with batch sizes   \n133 of 128. The learning rates for the Real NPU, NRU and NMRU are 5e-3, 1e-3 and 1e-2 respectively.   \n134 Sparsity regularisation scaling occurs during iteration 50,000 to 75,000 for all modules. A summary   \n135 of all relevant parameters is found in Appendix C.   \n36 Ranges: The interpolation (train/validation) and extrapolation (test) ranges, are found in Table 1.   \n37 The chosen ranges are influenced by Madsen and Johansen [2020].   \n138 Evaluation metrics: We use the Madsen and Johansen [2019]’s evaluation scheme, consisting of   \n139 three evaluation metrics: the success on the extrapolation dataset against a near optimal solution   \n140 (success rate), the first iteration which the task is considered solved (speed of convergence), and   \n141 the extent of discretisation towards the weights’ inductive biases (sparsity error). Sparsity error   \n142 calculated by $\\operatorname* { m a x } _ { i , o } ( \\operatorname* { m i n } ( | W _ { i , o } | , 1 - | W _ { i , o } | ) )$ , measures the weight element which is the furthest away   \n143 from the acceptable discrete weights for the module. A success means the MSE of the trained model   \n144 is lower than a threshold value (i.e. the MSE of a near optimal solution). We differ from Madsen   \n145 and Johansen [2019] by using a fixed threshold value 1e-5 rather than a simulated MSE, as there   \n146 are no intermediate layers to accumulate numerical errors. We choose this precision as it can be   \n147 guaranteed when working with 32-bit PyTorch Tensors. $9 5 \\%$ confidence intervals (over the 25 seeds)   \n148 are calculated from a specific family of distributions dependant on the metric. The success rate uses   \n149 Binomial distribution because trials (i.e. run on a single seed) are either pass/ fail situations. The   \n150 convergence metric uses a Gamma distribution and sparsity error uses a Beta distribution. Both Beta   \n151 and Gamma can easily approximate the normal distribution and support its corresponding metric. ",
+        "bbox": [
+            140,
+            321,
+            825,
+            488
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            153,
+            503,
+            823,
+            531
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            546,
+            826,
+            748
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "5 Improving the Real NPU’s Robustness ",
+        "text_level": 1,
+        "bbox": [
+            165,
+            767,
+            524,
+            785
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We first improve the robustness of the Real NPU on different training ranges. We use the Single Module Task with no redundancy (see Section 4) to investigate the following questions: ",
+        "bbox": [
+            168,
+            799,
+            821,
+            828
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "1. Is L1 regularisation required, and if so, do the regularisation parameters require tuning?   \n2. Does clipping the weight matrix aid learning?   \n3. Does enforcing discretisation on parameters improve convergence?   \n4. Can the weight matrix initialisation be improved?   \n159 To address each question in order, we propose applying incremental modifications to the Real NPU.   \n160 These modifications include: ablation study on the L1 regularisation (including a sweep over the   \n161 scaling range hyperparameters), clipping, enforcing discretisation, and a more restrictive initialisation   \n162 scheme. We assume that we are optimising the Real NPU to perform multiplication or division.   \n163 Therefore, we trade-off the flexibility of having non-discretised weights, which enables the success of   \n164 modelling the SIR data in Heim et al. [2020, Section 4.1] , in favour of sparse models with discrete   \n165 weight values. All the modifications suggested can also be generalised for the NPU architecture.   \n166 Is L1 regularisation required? (Yes) L1 encourages sparsity (i.e., zero weights) in solutions.   \n167 Zero-valued weights means not to select an input and return the identity value 1. For the task, the   \n168 optimal weight values require selecting all inputs and therefore non-zero values, suggesting the   \n169 application of L1 could be damaging. Therefore, we compare against a model which does not use   \n170 L1 regularisation, shown in Figure 1a. Removing L1 proves to be detrimental in five of the nine   \n171 cases shown and only shows minor improvements in two of the nine ranges (i.e., $\\mathcal { U } [ - 1 . 2 , - 1 . 1 )$ and   \n172 U[1.1,1.2)). Hence, we keep L1 regularisation. The L1 regularisation scaling (see Section 3.1),   \n173 requires setting the hyperparameters for the start $( \\beta _ { s t a r t } )$ and end $( \\beta _ { e n d } )$ scaling values. We run a   \n174 sweep over six different start and end values, denoted (<start>, <end>), displaying results in Figure 1b.   \n175 We find the configuration (1e-9, 1e-7) is the most successful when considering performance on all   \n176 the ranges, and larger scaling values perform worse.   \n177 Does clipping the learnable parameters help? (Yes) Division and multiplication operations are   \n178 represented by weight values of -1 and 1 respectively. The current architecture does not constrain the   \n179 weights which can result in large weight values. The gate weights do get clipped and saved to another   \n180 variable during the forward pass, meaning after an update step the gate values can also be out of the   \n181 range [-1,1]. Hence, we investigate the effect of applying clipping directly to the weight and gate   \n182 values after every optimisation step. Results, shown in Figure 2a, show clipping is beneficial, with   \n183 clipping on both weight and gate (or just on the weights) to improve over the baseline on all ranges   \n184 (excluding $\\mathcal { U } [ 1 , 2 )$ where the baseline has already achieved full success).   \n185 Does enforcing discretisation help? (Yes) Modelling division in a generalisable manner requires   \n186 all learnable parameters to be discrete i.e., a value from {-1, 0, 1}. Using Madsen and Johansen   \n187 [2020]’s regularisation scaling scheme, we penalise weights for not being discrete. We modify the   \n188 scaling factor to be $\\hat { \\lambda } = 1$ and the regularisation to go from ‘off’ to ‘on’ between iterations 40,000 to   \n189 50,000. Results, shown in Figure 2b, show discretising the gate improves over the baseline but also   \n190 discretising the weights is additionally beneficial (especially for range U [-0.2,-0.1)). U [10,20) is the   \n191 only range where the baseline outperforms using discretisation, succeeding on two additional seeds.   \n192 Does using a more constrained initialisation help? (Yes) $W ^ { ( r ) }$ uses a Xavier-Uniform initial  \n193 isation [Glorot and Bengio, 2010]. This can result in weights initialised out of the range [-1,1].   \n194 Therefore, we use the initialisation for the Neural Addition Unit which is a constrained form of   \n195 the Xavier-Uniform that does not allow the fan values of the uniform distribution to go beyond 0.5,   \n196 meaning that no weight value will be out of the range [-1,1] [Madsen and Johansen, 2020]. Figure 2c   \n197 shows using the constrained initialisation provides improvements over multiple ranges. ",
+        "bbox": [
+            210,
+            838,
+            807,
+            912
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/9e3a08fb53f29f2be5884a025a12ec03e754b74b7927a35d1b6c74f0b9c7c485.jpg",
+        "image_caption": [
+            "Figure 1: Exploring the effect and sensitivity of L1 regularisation on the Real NPU "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            253,
+            92,
+            750,
+            286
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/b753ab1ab2d4e27b531dd4960cec3c53d9d00633e16aa85713a702f1e095a8dd.jpg",
+        "image_caption": [
+            "Figure 2: Effect of clipping, discretisation, and the NAU initialisation scheme on the Real NPU. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            329,
+            812,
+            532
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            584,
+            826,
+            683
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            699,
+            826,
+            852
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/27ca24ced743312991fb11ff7653d651fc84a051b3432d67833ad53b05653de8.jpg",
+        "image_caption": [
+            "Figure 3: Division without redundancy (input size 2). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            92,
+            813,
+            286
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            343,
+            825,
+            412
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            428,
+            825,
+            527
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            542,
+            826,
+            627
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "6 Results: Single Module Task ",
+        "text_level": 1,
+        "bbox": [
+            166,
+            646,
+            444,
+            662
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We analyse the results for the: Real NPU without using the modifications of Section 5, Real NPU with modifications, NRU, and NMRU. ",
+        "bbox": [
+            176,
+            678,
+            825,
+            705
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "6.1 No Redundancy ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            722,
+            325,
+            737
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Figure 3 shows the baseline Real NPU without modifications struggles with all ranges except U[1,2), struggling with sparsity on the larger ranges. Applying the modifications deals with the sparsity issue and improves the robustness such that only range $\\mathcal { U } [ - 2 , 2 )$ struggles (with a success rate of 0.64). The NRU and NMRU achieve full success over all ranges while solving the problem consistently fast and with low sparsity error. The success of the NRU is correlated with the learning rate (see Appendix E). ",
+        "bbox": [
+            174,
+            747,
+            825,
+            818
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "6.1.1 Mixed-signed Inputs ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            832,
+            369,
+            847
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The remaining failure range of the Real NPU is U [-2,2) where inputs can consist of arbitrary signed values (e.g. all positives, all negatives, or a mixture of positive and negative values). We question if the failure is due to the input samples in a batch having different signs from each other, or if the problem is due to the fact data samples can be close to 0 (leading to singularity issues). To investigate ",
+        "bbox": [
+            174,
+            856,
+            823,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/b9350e8bef44837579e91416f79f6fdfd40143301410c9eff9832f00ec8d6449.jpg",
+        "image_caption": [
+            "Figure 4: Extrapolation results on training the Real NPU using mixed-sign datasets that control the sign of the input elements. The ranges are in order of the datasets (i.e. dataset 1 to 5). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            92,
+            813,
+            285
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/6312b0065a51e06c3c53208f54c12008995bfff4f03be60f13a1ba729eb3b569.jpg",
+        "image_caption": [
+            "Figure 5: Effect of the singularity issue on the Real NPU, NRU and NMRU over increasing input ranges. Left: Reciprocal for an input size of 1 (no redundancy). Middle: Reciprocal for an input size of 2 (with redundancy). Right: Division for an input size of 2 (no redundancy). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            348,
+            820,
+            544
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "212 this, we create additional mixed-sign datasets, controlling the range for each element in the input. The   \n213 interpolation and extrapolation ranges for the different datasets can be found in Appendix C. Datasets   \n214 1, 2, 4 and 5 sample a positive value for one input element and a negative value for the other element.   \n215 Dataset 3 samples the signs randomly. Datasets 2 and 5 avoid sampling close to 0 values to mitigate   \n216 the singularity issue. As shown by Figure 4, the Real NPU struggles on all these ranges, implying that   \n217 the core issue is not from different input samples having different signs or due to the input samples   \n218 being able to contain small values close to 0. The underlying issue is therefore most likely correlated   \n219 to the each element in an input having different signs. When the denominator of the output is positive   \n220 (dataset 1 or 2), the solution is found faster than when the denominator is a negative value (dataset 4   \n221 or 5). When the signs for an input element are controlled, discretisation/sparsity is no problem, in   \n222 contrast when the signs are arbitrary the sparsity error are slightly (though not significantly) higher. ",
+        "bbox": [
+            138,
+            630,
+            825,
+            784
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "6.2 Division by Small Numbers ",
+        "text_level": 1,
+        "bbox": [
+            169,
+            801,
+            401,
+            816
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Division by zero remains a challenge to model due to the inability to provide an computational value for the output and gradient. Furthermore, the discontinuous nature at zero causes its neighbouring values to have large gradients. To understand the extent of this issue when learning, we explore learning to divide by values close to zero using three tasks with increasing difficulty: 1) learning to take the reciprocal of a single input, 2) taking the reciprocal of the first input given two inputs, and 3) diving the first input by the second given two inputs. Figure 5 plots the test error for different modules assuming the module weights are set to the ‘gold’ solution for the three tasks. As the range values become closer to zero, the test error thresholds become increasingly large. Therefore, even with the correct weights, relying on the test errors alone as an indicator become increasingly deceptive with values close to zero. The Real NPU has larger test errors for all tasks and ranges, caused by adding $\\epsilon$ to the input (see Equation 3). Setting $\\epsilon = 0$ reduces the test error at the cost of the ability to deal with zero-valued inputs. Appendix F provides the corresponding experimental results for these tasks. ",
+        "bbox": [
+            173,
+            828,
+            823,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/dfa2cb434d655e5a99b3201cf2cf435ea7eb20cf9286d0ad7432d695f9166a17.jpg",
+        "image_caption": [
+            "Figure 6: Division with redundancy (input size 10). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            92,
+            813,
+            286
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            158,
+            340,
+            825,
+            424
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6.3 With Redundancy ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            439,
+            338,
+            454
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Introducing redundancy (Figure 6) causes failure modes to arise. Failures on range U[-2,2) become more prevalent. The baseline Real NPU produces high sparsity errors relative to the other modules suggesting struggle with discretisation. Using the modified Real NPU improves over all ranges of the baseline (which were not already at full success) in terms of success, speed and sparsity.2 To ensure that complex weights do not fix the issue, we test the NPU module with all the modifications used on the real weight matrix (see Appendix G). Complex weights hinders success and convergence speeds of negative ranges. Assuming the global solution only uses the real weights, we enforce the complex weights to be clipped between [-1,1] and to go to 0 during the regularisation stage using a L1 penalty. This did not result in any significant improvements against the Real NPU results. Input redundancy effects the NRU the most, resulting in full failures on all the negative ranges. The NMRU is the only module with success for the range $\\mathcal { U } [ - 2 , 2 )$ , which is a result of using the sign mechanism (see Appendix H). It performs well over all ranges though can be outperformed by the modified Real NPU for negative ranges. Multiple ranges for the NMRU are solved around 50,000 iterations correlating to the sparsity regularisation being turned on. ",
+        "bbox": [
+            173,
+            465,
+            825,
+            659
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6.3.1 Gradient Difficulties with the NRU ",
+        "text_level": 1,
+        "bbox": [
+            161,
+            672,
+            465,
+            688
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "252 The partial derivative for the NRU weights, Equation 6, can give insight to the struggles of the NRU. ",
+        "bbox": [
+            147,
+            696,
+            820,
+            712
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a6c8d7930ac31081d400a44c9b43e504f9accfb521226da2b3fb2d76b7382b9e.jpg",
+        "text": "$$\n\\begin{array} { r l r } & { } & { \\displaystyle \\frac { \\partial \\hat { \\bf y } } { \\partial w _ { i } } = \\mathrm { t a n h } ( 1 0 0 0 w _ { i } ) ( \\mathrm { s i g n } ( x _ { i } ) | x _ { i } | ( \\mathrm { t a n h } ( 1 0 0 0 w _ { i } ) \\log ( | x | ) + } \\\\ & { } & { \\displaystyle 2 0 0 0 \\mathrm { s e c h } ( 1 0 0 0 w _ { i } ) ^ { 2 } ) - 2 0 0 0 \\mathrm { s e c h } ( 1 0 0 0 w _ { i } ) ^ { 2 } ) \\times \\mathrm { N R U } _ { \\tilde { \\bf x } \\in { \\bf x } \\backslash \\{ { \\bf x } _ { i } \\} } ( \\tilde { \\bf x } ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            276,
+            714,
+            722,
+            768
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "$\\_$ applies the NRU to all inputs excluding $x _ { i }$ influencing the gradient values between subsequent update steps. Factoring out this term, the following observations are made. If $x _ { i } \\approx 0$ and $w _ { i } \\approx 0$ then gradients become increasingly large. If $x _ { i } \\approx 0$ and $- 1 \\leq w _ { i } < 0$ then as $w _ { i } \\to - 1$ all gradients for $x _ { i }$ where $| x _ { i } | > > 1$ become increasingly small. The gradients for $x _ { i } = - 1$ and $x _ { i } = 1$ are 0 regardless the value of $w _ { i }$ . If $w _ { i } = 0$ then the gradient is 0 for all $x _ { i }$ , a result of using the tanh approximation. Even if the sign and magnitude are calculated separately and then combined (see Appendix I) to try to control the gradient better, the problem remains. Therefore, we conclude that extending the NMU to divide using a weight of -1 is a poor choice when there are redundant inputs. ",
+        "bbox": [
+            173,
+            776,
+            825,
+            888
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/66ed3f0eee25ac2b1a0c761d4b2eb34b0ef8ac43e9bb7e26723d0bf2229b6cdb.jpg",
+        "image_caption": [
+            "Figure 7: Root Mean Squared loss curvature for the NAU stacked with either a RealNPU, NRU, or NMRU. \"The weight matrices are constrained to $\\mathbf { W } _ { 1 } = \\left[ \\begin{array} { l l l } { w _ { 1 } \\ w _ { 1 } } & { 0 } & { 0 } \\\\ { w _ { 1 } \\ w _ { 1 } \\ w _ { 1 } \\ w _ { 1 } } & { w _ { 1 } } \\end{array} \\right]$ , $\\mathbf { W } _ { 2 } = \\left[ w _ { 2 } \\ w _ { 2 } \\right]$ . The problem is $( x _ { 1 } + x _ { 2 } ) \\cdot ( x _ { 1 } + x _ { 2 } + x _ { 3 } + x _ { 4 } )$ for $x = ( 1 , 1 . 2 , 1 . 8 , 2 ) \"$ [Madsen and Johansen, 2020]. The ideal solution is $w _ { 1 } = w _ { 2 } = 1$ , though other valid solutions do exist e.g., $w _ { 1 } = - 1 , w _ { 2 } = 1$ . (The NMRU’s weight matrix would be $\\bar { \\bf W _ { 2 } } = [ w _ { 2 } \\ w _ { 2 } \\ 0 \\ 0 ]$ , and the Real NPU’s $\\mathbf { g } = \\left[ 1 \\mathbf { \\Omega } ^ { 1 } \\right]$ . ) "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            202,
+            103,
+            812,
+            243
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "261 6.3.2 The Real NPU’s and NMRU’s Exploitation of Multiplicative Rules ",
+        "text_level": 1,
+        "bbox": [
+            151,
+            352,
+            684,
+            367
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The NMRU solutions exploit the inverse rule of division in that 1 = 1. Since the input also contains the reciprocals, numerous extrapolative solutions exist. However this comes at the cost of finding a ‘simple’ solution which contains ones only for relevant inputs. The Real NPU exploits the rules $a _ { i } \\cdot 0 = 0$ and $1 ^ { a _ { i } } = 1$ enabling non-zero weight values if the corresponding gate value is 0. However, we can avoid this by allowing 0 to also not be penalised during sparsity regularisation stage (see Appendix G). We find this alleviates the exploitation issue with no cost to performance. ",
+        "bbox": [
+            171,
+            376,
+            825,
+            462
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "268 7 Discussion ",
+        "text_level": 1,
+        "bbox": [
+            142,
+            483,
+            294,
+            501
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "269 In this paper, we demonstrate the limitations of intepretable neural networks in learning to divide.   \n270 Using the no redundancy setting (size 2), we find that the Real NPU is challenged when training data   \n271 consists of mixed-signed inputs even with our applied improvements. Increasing the difficulty to   \n272 have an input redundancy (with 8 redundant and 2 relevant input values) magnifies this issue, but   \n273 also introduces failure modes for the NRU and NMRU for negative ranges. The NRU is unable to   \n274 handle any negative ranges, in which we conclude it is not wise to use with MSE. Alternate losses   \n275 can improve certain failure cases though sometimes at the cost of performance on other ranges. For   \n276 further details see Appendix J which displays results on a correlation and scale-invariant based loss.   \n277 Our NMRU is the only module with reasonable success over all tested ranges, requiring only $2 I \\times O$   \n278 learnable parameters. However, this comes at the cost of the simplicity of the solution due to its   \n279 exploitation of the identity rule; an issue the Real NPU does not have. ",
+        "bbox": [
+            143,
+            517,
+            825,
+            628
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            633,
+            825,
+            676
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Once robust modules are attainable in a single layer setting, the next step would be to question performance when learning stacked modules, e.g. learning a stacked additive and multiplicative module. Previously, Madsen and Johansen [2020, Figure 2] illustrates the troubles for multiplicative models with the capacity for division. They show how a stacked summative-multiplicative module can lead to an exploding loss when the output of the summative module is close to 0 and the multiplicative model tries to divide. In Figure 7, we recreate their setup to produce the loss surfaces for the NAUReal $\\mathrm { N P U } ^ { 3 }$ , NAU-NRU and NAU-NMRU respectively. 4 We find a similar issue with the Real-NPU and NRU, as both these units use a weight range of [-1,1]. In contrast, the NMRU, whose weight’s range is limited to [0,1] does not have exploding losses. ",
+        "bbox": [
+            173,
+            683,
+            825,
+            808
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In conclusion, division remains a challenge to learn using intepretable neural networks, even for the simplest tasks. Nevertheless, by identifying the specific areas causing difficulty (e.g., training ranges), and useful architecture properties (e.g., using a sign retrieval mechanism), we hope the community has better intuition for dealing with division and develop more robust modules to learn division. ",
+        "bbox": [
+            174,
+            813,
+            825,
+            868
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            169,
+            90,
+            266,
+            106
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Girish Chandrashekar and Ferat Sahin. A survey on feature selection methods. Computers & Electrical Engineering, 40(1):16–28, 2014. ISSN 0045-7906. doi: https://doi.org/10.1016/j.comp eleceng.2013.11.024. URL https://www.sciencedirect.com/science/article/pii/S0 045790613003066. 40th-year commemorative issue.   \nLukas Faber and Roger Wattenhofer. Neural status registers. CoRR, abs/2004.07085, 2020. URL https://arxiv.org/abs/2004.07085.   \nXavier Glorot and Yoshua Bengio. Understanding the difficulty of training deep feedforward neural networks. In Proceedings of the thirteenth international conference on artificial intelligence and statistics, pages 249–256. JMLR Workshop and Conference Proceedings, 2010. URL http: //proceedings.mlr.press/v9/glorot10a/glorot10a.pdf.   \nNiklas Heim, Tomáš Pevny, and Václav Šmídl. Neural power units. \\` Advances in Neural Information Processing Systems, 33, 2020. URL https://papers.nips.cc/paper/2020/file/48e5900 0d7dfcf6c1d96ce4a603ed738-Paper.pdf.   \nDiederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. CoRR, abs/1412.6980, 2015. URL https://arxiv.org/pdf/1412.6980.pdf.   \nAndreas Madsen and Alexander Rosenberg Johansen. Measuring arithmetic extrapolation performance. In Science meets Engineering of Deep Learning at 33rd Conference on Neural Information Processing Systems (NeurIPS 2019), volume abs/1910.01888, Vancouver, Canada, October 2019. URL https://arxiv.org/pdf/1910.01888.pdf.   \nAndreas Madsen and Alexander Rosenberg Johansen. Neural arithmetic units. In International Conference on Learning Representations, 2020. URL https://openreview.net/forum?id= H1gNOeHKPS.   \nBhumika Mistry, Katayoun Farrahi, and Jonathon Hare. A primer for neural arithmetic logic modules, 2021. URL https://arxiv.org/pdf/2101.09530.pdf.   \nSubham Sahoo, Christoph Lampert, and Georg Martius. Learning equations for extrapolation and control. In International Conference on Machine Learning, pages 4442–4450. PMLR, 2018.   \nDaniel Schlör, Markus Ring, and Andreas Hotho. inalu: Improved neural arithmetic logic unit. Frontiers in Artificial Intelligence, 3:71, 2020. ISSN 2624-8212. doi: 10.3389/frai.2020.00071. URL https://www.frontiersin.org/article/10.3389/frai.2020.00071.   \nAndrew Trask, Felix Hill, Scott E Reed, Jack Rae, Chris Dyer, and Phil Blunsom. Neural arithmetic logic units. In Advances in Neural Information Processing Systems, pages 8035–8044, 2018. URL https://openreview.net/pdf?id=H1gNOeHKPS.   \nSilviu-Marian Udrescu and Max Tegmark. Ai feynman: A physics-inspired method for symbolic regression. Science Advances, 6(16), 2020. doi: 10.1126/sciadv.aay2631. URL https: //advances.sciencemag.org/content/6/16/eaay2631. ",
+        "bbox": [
+            158,
+            111,
+            826,
+            695
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Checklist ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            713,
+            254,
+            728
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "1. For all authors... ",
+        "bbox": [
+            214,
+            738,
+            339,
+            752
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes] See contributions in the introduction. For Real NPU improvements see Section 5. For two novel modules see Section 3.2 and 3.3 and results in Section 6. For hindrances in learning division, see Section 6.   \n(b) Did you describe the limitations of your work? [Yes] See Section 7.   \n(c) Did you discuss any potential negative societal impacts of your work? [Yes] This paper focuses on the ML techniques and the foundational research required to learn division in a systematic manner. Once robust modules for the arithmetic operations (i.e. NALMs) are achievable the community will possess trainable modules with significant advantages regarding model transparency and generalisability. That being said, we discuss how this leads to a negative societal impact in the end of Section 1. ",
+        "bbox": [
+            236,
+            756,
+            825,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes] We have read the guidelines and our work does not use human-derived data. ",
+        "bbox": [
+            236,
+            90,
+            825,
+            132
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "2. If you are including theoretical results... ",
+        "bbox": [
+            215,
+            138,
+            493,
+            152
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you state the full set of assumptions of all theoretical results? [N/A] (b) Did you include complete proofs of all theoretical results? [N/A] ",
+        "bbox": [
+            236,
+            156,
+            738,
+            188
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "3. If you ran experiments... ",
+        "bbox": [
+            214,
+            193,
+            393,
+            207
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [Yes] See link provided to the code base. Data is generated in real time and the code to generate it is available in the linked repository.   \n(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] See Section 4 and Appendix C.   \n(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [Yes] See plots and experiment details in Section 4 for further details.   \n(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [Yes] See Appendix D. ",
+        "bbox": [
+            238,
+            210,
+            825,
+            369
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... ",
+        "bbox": [
+            215,
+            375,
+            823,
+            390
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "(a) If your work uses existing assets, did you cite the creators? [Yes] See footnote link provided to the code base and Section 4.   \n(b) Did you mention the license of the assets? [Yes] We state the MIT licence when giving the link to the codebase.   \n(c) Did you include any new assets either in the supplemental material or as a URL? [Yes] All code for model, data and experiments are available through the link to the codebase.   \n(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A]   \n(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [No] All data is synthetic, containing no such information. ",
+        "bbox": [
+            238,
+            393,
+            825,
+            555
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "5. If you used crowdsourcing or conducted research with human subjects... ",
+        "bbox": [
+            215,
+            560,
+            705,
+            575
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   \n(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   \n(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A] ",
+        "bbox": [
+            238,
+            579,
+            825,
+            667
+        ],
+        "page_idx": 10
+    }
+]

parse/train/B14TlG-RW/B14TlG-RW.md

@@ -0,0 +1,314 @@
+# QANET: COMBINING LOCAL CONVOLUTION WITH GLOBAL SELF-ATTENTION FOR READING COMPREHENSION
+
+Adams Wei $\mathbf { Y u } ^ { 1 }$ ∗, David Dohan2†, Minh-Thang Luong2† {weiyu}@cs.cmu.edu, {ddohan,thangluong}@google.com 1Carnegie Mellon University, 2Google Brain
+
+Rui Zhao, Kai Chen, Mohammad Norouzi, Quoc V. Le Google Brain
+
+# ABSTRACT
+
+Current end-to-end machine reading and question answering (Q&A) models are primarily based on recurrent neural networks (RNNs) with attention. Despite their success, these models are often slow for both training and inference due to the sequential nature of RNNs. We propose a new Q&A architecture called QANet, which does not require recurrent networks: Its encoder consists exclusively of convolution and self-attention, where convolution models local interactions and self-attention models global interactions. On the SQuAD dataset, our model is 3x to $1 3 \mathrm { x }$ faster in training and $4 \mathbf { x }$ to $9 \mathbf { x }$ faster in inference, while achieving equivalent accuracy to recurrent models. The speed-up gain allows us to train the model with much more data. We hence combine our model with data generated by backtranslation from a neural machine translation model. On the SQuAD dataset, our single model, trained with augmented data, achieves 84.6 F1 score1 on the test set, which is significantly better than the best published F1 score of 81.8.
+
+# 1 INTRODUCTION
+
+There is growing interest in the tasks of machine reading comprehension and automated question answering. Over the past few years, significant progress has been made with end-to-end models showing promising results on many challenging datasets. The most successful models generally employ two key ingredients: (1) a recurrent model to process sequential inputs, and (2) an attention component to cope with long term interactions. A successful combination of these two ingredients is the Bidirectional Attention Flow (BiDAF) model by Seo et al. (2016), which achieve strong results on the SQuAD dataset (Rajpurkar et al., 2016). A weakness of these models is that they are often slow for both training and inference due to their recurrent nature, especially for long texts. The expensive training not only leads to high turnaround time for experimentation and limits researchers from rapid iteration but also prevents the models from being used for larger dataset. Meanwhile the slow inference prevents the machine comprehension systems from being deployed in real-time applications.
+
+In this paper, aiming to make the machine comprehension fast, we propose to remove the recurrent nature of these models. We instead exclusively use convolutions and self-attentions as the building blocks of encoders that separately encodes the query and context. Then we learn the interactions between context and question by standard attentions (Xiong et al., 2016; Seo et al., 2016; Bahdanau et al., 2015). The resulting representation is encoded again with our recurrency-free encoder before finally decoding to the probability of each position being the start or end of the answer span. We call this architecture QANet, which is shown in Figure 1.
+
+The key motivation behind the design of our model is the following: convolution captures the local structure of the text, while the self-attention learns the global interaction between each pair of words. The additional context-query attention is a standard module to construct the query-aware context vector for each position in the context paragraph, which is used in the subsequent modeling layers. The feed-forward nature of our architecture speeds up the model significantly. In our experiments on the SQuAD dataset, our model is $3 \mathbf { x }$ to $1 3 \mathrm { x }$ faster in training and 4x to $9 \mathbf { x }$ faster in inference. As a simple comparison, our model can achieve the same accuracy (77.0 F1 score) as BiDAF model (Seo et al., 2016) within 3 hours training that otherwise should have taken 15 hours. The speed-up gain also allows us to train the model with more iterations to achieve better results than competitive models. For instance, if we allow our model to train for 18 hours, it achieves an F1 score of 82.7 on the dev set, which is much better than (Seo et al., 2016), and is on par with best published results.
+
+As our model is fast, we can train it with much more data than other models. To further improve the model, we propose a complementary data augmentation technique to enhance the training data. This technique paraphrases the examples by translating the original sentences from English to another language and then back to English, which not only enhances the number of training instances but also diversifies the phrasing.
+
+On the SQuAD dataset, QANet trained with the augmented data achieves 84.6 F1 score on the test set, which is significantly better than the best published result of 81.8 by Hu et al. (2017).2 We also conduct ablation test to justify the usefulness of each component of our model. In summary, the contribution of this paper are as follows:
+
+• We propose an efficient reading comprehension model that exclusively built upon convolutions and self-attentions. To the best of our knowledge, we are the first to do so. This combination maintains good accuracy, while achieving up to $1 3 \mathrm { x }$ speedup in training and $9 \mathbf { x }$ per training iteration, compared to the RNN counterparts. The speedup gain makes our model the most promising candidate for scaling up to larger datasets. • To improve our result on SQuAD, we propose a novel data augmentation technique to enrich the training data by paraphrasing. It allows the model to achieve higher accuracy that is better than the state-of-the-art.
+
+# 2 THE MODEL
+
+In this section, we first formulate the reading comprehension problem and then describe the proposed model QANet: it is a feedforward model that consists of only convolutions and self-attention, a combination that is empirically effective, and is also a novel contribution of our work.
+
+# 2.1 PROBLEM FORMULATION
+
+The reading comprehension task considered in this paper, is defined as follows. Given a context paragraph with $n$ words $C = \{ c _ { 1 } , c _ { 2 } , . . . , c _ { n } \}$ and the query sentence with $m$ words $Q = \{ q _ { 1 } , q _ { 2 } , . . . , \bar { q } _ { m } \}$ , output a span $S = \{ c _ { i } , c _ { i + 1 } , . . . , c _ { i + j } \}$ from the original paragraph $C$ . In the following, we will use $x$ to denote both the original word and its embedded vector, for any $x \in C , Q$ .
+
+# 2.2 MODEL OVERVIEW
+
+The high level structure of our model is similar to most existing models that contain five major components: an embedding layer, an embedding encoder layer, a context-query attention layer, a model encoder layer and an output layer, as shown in Figure 1. These are the standard building blocks for most, if not all, existing reading comprehension models. However, the major differences between our approach and other methods are as follow: For both the embedding and modeling encoders, we only use convolutional and self-attention mechanism, discarding RNNs, which are used by most of the existing reading comprehension models. As a result, our model is much faster, as it can process the input tokens in parallel. Note that even though self-attention has already been used extensively in Vaswani et al. (2017a), the combination of convolutions and self-attention is novel, and is significantly better than self-attention alone and gives 2.7 F1 gain in our experiments. The use of convolutions also allows us to take advantage of common regularization methods in ConvNets such as stochastic depth (layer dropout) (Huang et al., 2016), which gives an additional gain of $0 . 2 \mathrm { F } 1$ in our experiments.
+
+![](images/9f4efb3d6b6401bb890a7c0b5541dd68786a9cf6fd26b697fd8e7e069e03eefa.jpg)  
+Figure 1: An overview of the QANet architecture (left) which has several Encoder Blocks. We use the same Encoder Block (right) throughout the model, only varying the number of convolutional layers for each block. We use layernorm and residual connection between every layer in the Encoder Block. We also share weights of the context and question encoder, and of the three output encoders. A positional encoding is added to the input at the beginning of each encoder layer consisting of sin and cos functions at varying wavelengths, as defined in (Vaswani et al., 2017a). Each sub-layer after the positional encoding (one of convolution, self-attention, or feed-forward-net) inside the encoder structure is wrapped inside a residual block.
+
+In detail, our model consists of the following five layers:
+
+1. Input Embedding Layer. We adopt the standard techniques to obtain the embedding of each word $w$ by concatenating its word embedding and character embedding. The word embedding is fixed during training and initialized from the $p _ { 1 } = 3 0 0$ dimensional pre-trained GloVe (Pennington et al., 2014) word vectors, which are fixed during training. All the out-of-vocabulary words are mapped to an ${ \mathrm { < U N K > } }$ token, whose embedding is trainable with random initialization. The character embedding is obtained as follows: Each character is represented as a trainable vector of dimension $p _ { 2 } = 2 0 0$ , meaning each word can be viewed as the concatenation of the embedding vectors for each of its characters. The length of each word is either truncated or padded to 16. We take maximum value of each row of this matrix to get a fixed-size vector representation of each word. Finally, the output of a given word $x$ from this layer is the concatenation $[ x _ { w } ; x _ { c } ] \in \mathbf { R } ^ { p _ { 1 } + p _ { 2 } }$ , where $x _ { w }$ and $x _ { c }$ are the word embedding and the convolution output of character embedding of $x$ respectively. Following Seo et al. (2016), we also adopt a two-layer highway network (Srivastava et al., 2015) on top of this representation. For simplicity, we also use $x$ to denote the output of this layer.
+
+2. Embedding Encoder Layer. The encoder layer is a stack of the following basic building block: [convolution-layer $\times \# +$ self-attention-layer $^ +$ feed-forward-layer], as illustrated in the upper right of Figure 1. We use depthwise separable convolutions (Chollet, 2016) (Kaiser et al., 2017) rather than traditional ones, as we observe that it is memory efficient and has better generalization. The kernel size is 7, the number of filters is $d = 1 2 8$ and the number of conv layers within a block is
+
+4. For the self-attention-layer, we adopt the multi-head attention mechanism defined in (Vaswani et al., 2017a) which, for each position in the input, called the query, computes a weighted sum of all positions, or keys, in the input based on the similarity between the query and key as measured by the dot product. The number of heads is 8 throughout all the layers. Each of these basic operations (conv/self-attention/ffn) is placed inside a residual block, shown lower-right in Figure 1. For an input $x$ and a given operation $f$ , the output is $f ( l a y e r n o r m ( x ) ) + x$ , meaning there is a full identity path from the input to output of each block, where layernorm indicates layer-normalization proposed in (Ba et al., 2016). The total number of encoder blocks is 1. Note that the input of this layer is a vector of dimension $p _ { 1 } + p _ { 2 } = 5 0 0$ for each individual word, which is immediately mapped to $d = 1 2 8$ by a one-dimensional convolution. The output of this layer is a also of dimension $d = 1 2 8$ .
+
+3. Context-Query Attention Layer. This module is standard in almost every previous reading comprehension models such as Weissenborn et al. (2017) and Chen et al. (2017). We use $C$ and $Q$ to denote the encoded context and query. The context-to-query attention is constructed as follows: We first computer the similarities between each pair of context and query words, rendering a similarity matrix $S \in \mathbf { R } ^ { n \times m }$ . We then normalize each row of $S$ by applying the softmax function, getting a matrix $\overline { S }$ . Then the context-to-query attention is computed as $\bar { A } = \mathbf { \bar { \boldsymbol { S } } } \cdot \boldsymbol { Q } ^ { T } \in \mathbf { R } ^ { n \times d }$ . The similarity function used here is the trilinear function (Seo et al., 2016):
+
+$$
+\begin{array} { r } { f ( q , c ) = W _ { 0 } [ q , c , q \odot c ] , } \end{array}
+$$
+
+where $\odot$ is the element-wise multiplication and $W _ { 0 }$ is a trainable variable.
+
+Most high performing models additionally use some form of query-to-context attention, such as BiDaF (Seo et al., 2016) and DCN (Xiong et al., 2016). Empirically, we find that, the DCN attention can provide a little benefit over simply applying context-to-query attention, so we adopt this strategy. More concretely, we compute the column normalized matrix $\overline { { \overline { { S } } } }$ of $S$ by softmax function, and the query-to-context attention is B = S · S  · C T .
+
+4. Model Encoder Layer. Similar to Seo et al. (2016), the input of this layer at each position is $\left[ c , a , c \odot a , c \odot b \right]$ , where $a$ and $b$ are respectively a row of attention matrix $A$ and $B$ . The layer parameters are the same as the Embedding Encoder Layer except that convolution layer number is 2 within a block and the total number of blocks are 7. We share weights between each of the 3 repetitions of the model encoder.
+
+5. Output layer. This layer is task-specific. Each example in SQuAD is labeled with a span in the context containing the answer. We adopt the strategy of Seo et al. (2016) to predict the probability of each position in the context being the start or end of an answer span. More specifically, the probabilities of the starting and ending position are modeled as
+
+$$
+p ^ { 1 } = s o f t m a x ( W _ { 1 } [ M _ { 0 } ; M _ { 1 } ] ) , ~ p ^ { 2 } = s o f t m a x ( W _ { 2 } [ M _ { 0 } ; M _ { 2 } ] ) ,
+$$
+
+where $W _ { 1 }$ and $W _ { 2 }$ are two trainable variables and $M _ { 0 } , M _ { 1 } , M _ { 2 }$ are respectively the outputs of the three model encoders, from bottom to top. The score of a span is the product of its start position and end position probabilities. Finally, the objective function is defined as the negative sum of the log probabilities of the predicted distributions indexed by true start and end indices, averaged over all the training examples:
+
+$$
+L ( \theta ) = - \frac { 1 } { N } \sum _ { i } ^ { N } \left[ \log ( p _ { y _ { i } ^ { 1 } } ^ { 1 } ) + \log ( p _ { y _ { i } ^ { 2 } } ^ { 2 } ) \right] ,
+$$
+
+where $y _ { i } ^ { 1 }$ and $y _ { i } ^ { 2 }$ are respectively the groundtruth starting and ending position of example $i$ , and $\theta$ contains all the trainable variables. The proposed model can be customized to other comprehension tasks, e.g. selecting from the candidate answers, by changing the output layers accordingly.
+
+Inference. At inference time, the predicted span $( s , e )$ is chosen such that $p _ { s } ^ { 1 } p _ { e } ^ { 2 }$ is maximized and $s \leq e$ . Standard dynamic programming can obtain the result with linear time.
+
+# 3 DATA AUGMENTATION BY BACKTRANSLATION
+
+Since our model is fast, we can train it with much more data. We therefore combine our model with a simple data augmentation technique to enrich the training data. The idea is to use two translation models, one translation model from English to French (or any other language) and another translation model from French to English, to obtain paraphrases of texts. This approach helps automatically increase the amount of training data for broadly any language-based tasks including the reading comprehension task that we are interested in. With more data, we expect to better regularize our models. The augmentation process is illustrated in Figure 2 with French as a pivotal language.
+
+In this work, we consider attention-based neural machine translation (NMT) models Bahdanau et al. (2015); Luong et al. (2015), which have demonstrated excellent translation quality Wu et al. (2016), as the core models of our data augmentation pipeline. Specifically, we utilize the publicly available codebase3 provided by Luong et al. (2017), which replicates the Google’s NMT (GNMT) systems Wu et al. (2016). We train 4-layer GNMT models on the public WMT data for both English-French4 (36M sentence pairs) and English-German5 (4.5M sentence pairs). All data have been tokenized and split into subword units as described in Luong et al. (2017). All models share the same hyperparameters6 and are trained with different numbers of steps, 2M for English-French and 340K for English-German. Our English-French systems achieve 36.7 BLEU on newstest2014 for translating into French and 35.9 BLEU for the reverse direction. For English-German and on newstest2014, we obtain 27.6 BLEU for translating into German and 29.9 BLEU for the reverse direction.
+
+![](images/28706f1cf855b1712c3db553cd3b78da8b285291fe96d2dc7bd8d8823aade21c.jpg)  
+Figure 2: An illustration of the data augmentation process with French as a pivotal language. $\mathbf { k }$ is the beam width, which is the number of translations generated by the NMT system.
+
+Our paraphrase process works as follows, supposedly with French as a pivotal language. First, we feed an input sequence into the beam decoder of an English-to-French model to obtain $k$ French translations. Each of the French translation is then passed through the beam decoder of a reversed translation model to obtain a total of $k ^ { 2 }$ paraphrases of the input sequence.
+
+Relation to existing Works. While the concept of backtranslation has been introduced before, it is often used to improve either the same translation task Sennrich et al. (2016) or instrinsic paraphrase evaluations Wieting et al. (2017); Mallinson et al. (2017). Our approach is a novel application of backtranslation to enrich training data for down-stream tasks, in this case, the question answering (QA) task. It is worth to note that (Dong et al., 2017) use paraphrasing techniques to improve QA; however, they only paraphrase questions and did not focus on the data augmentation aspect as we do in this paper.
+
+Handling SQuAD Documents and Answers. We now discuss our specific procedure for the SQuAD dataset, which is essential for best performance gains. Remember that, each training example of SQuAD is a triple of $( d , q , a )$ in which document $d$ is a multi-sentence paragraph that has the answer $a$ . When paraphrasing, we keep the question $q$ unchanged (to avoid accidentally changing its meaning) and generate new triples of $\bar { ( d ^ { \prime } , q , a ^ { \prime } ) }$ such that the new document $d ^ { \prime }$ has the new answer $a ^ { \prime }$ in it. The procedure happens in two steps: (i) document paraphrasing – paraphrase $d$ into $d ^ { \prime }$ and (b) answer extraction – extract $a ^ { \prime }$ from $d ^ { \prime }$ that closely matches $a$ .
+
+For the document paraphrasing step, we first split paragraphs into sentences and paraphrase them independently. We use $k = 5$ , so each sentence has 25 paraphrase choices. A new document $d ^ { \prime }$ is formed by simply replacing each sentence in $d$ with a randomly-selected paraphrase. An obvious issue with this na¨ıve approach is that the original answer $a$ might no longer be present in $d ^ { \prime }$ .
+
+The answer extraction addresses the aforementioned issue. Let $s$ be the original sentence that contains the original answer $a$ and $s ^ { \prime }$ be its paraphrase. We identify the newly-paraphrased answer with simple heuristics as follows. Character-level 2-gram scores are computed between each word in $s ^ { \prime }$ and the start / end words of $a$ to find start and end positions of possible answers in $s ^ { \prime }$ . Among all candidate paraphrased answer, the one with the highest character 2-gram score with respect to $a$ is selected as the new answer $a ^ { \prime }$ . Table 1 shows an example of the new answer found by this process.7
+
+Table 1: Comparison between answers in original sentence and paraphrased sentence.   
+
+<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>Sentence that contains an answer</td><td rowspan=1 colspan=1>Answer</td></tr><tr><td rowspan=1 colspan=1>Original</td><td rowspan=1 colspan=1>All of the departments in the College of Science offer PhDprograms,except for the Department of Pre-ProfessionalStudies.</td><td rowspan=1 colspan=1>Department   of   Pre-Professional Studies</td></tr><tr><td rowspan=1 colspan=1>Paraphrase</td><td rowspan=1 colspan=1>All departments in the College of Science offer PHD pro- grams with the exception of the Department of PreparatoryStudies.</td><td rowspan=1 colspan=1>Department of PreparatoryStudies</td></tr></table>
+
+The quality and diversity of paraphrases are essential to the data augmentation method. It is still possible to improve the quality and diversity of this method. The quality can be improved by using better translation models. For example, we find paraphrases significantly longer than our models’ maximum training sequence length tend to be cut off in the middle. The diversity can be improved by both sampling during the beam search decoding and paraphrasing questions and answers in the dataset as well. In addition, we can combine this method with other data augmentation methods, such as, the type swap method (Raiman & Miller, 2017), to acquire more diversity in paraphrases.
+
+In our experiments, we observe that the proposed data augmentation can bring non-trivial improvement in terms of accuracy. We believe this technique is also applicable to other supervised natural language processing tasks, especially when the training data is insufficient.
+
+# 4 EXPERIMENTS
+
+In this section, we conduct experiments to study the performance of our model and the data augmentation technique. We will primarily benchmark our model on the SQuAD dataset (Rajpurkar et al., 2016), considered to be one of the most competitive datasets in Q&A. We also conduct similar studies on TriviaQA (Joshi et al., 2017), another Q&A dataset, to show that the effectiveness and efficiency of our model are general.
+
+# 4.1 EXPERIMENTS ON SQUAD
+
+# 4.1.1 DATASET AND EXPERIMENTAL SETTINGS
+
+Dataset. We consider the Stanford Question Answering Dataset (SQuAD) (Rajpurkar et al., 2016) for machine reading comprehension.8 SQuAD contains 107.7K query-answer pairs, with $8 7 . 5 \mathrm { K }$ for training, 10.1K for validation, and another 10.1K for testing. The typical length of the paragraphs is around 250 while the question is of 10 tokens although there are exceptionally long cases. Only the training and validation data are publicly available, while the test data is hidden that one has to submit the code to a Codalab and work with the authors of (Rajpurkar et al., 2016) to retrieve the final test score. In our experiments, we report the test set result of our best single model.9 For further analysis, we only report the performance on the validation set, as we do not want to probe the unseen test set by frequent submissions. According to the observations from our experiments and previous works, such as (Seo et al., 2016; Xiong et al., 2016; Wang et al., 2017; Chen et al., 2017), the validation score is well correlated with the test score.
+
+Data Preprocessing. We use the NLTK tokenizer to preprocess the data.10 The maximum context length is set to 400 and any paragraph longer than that would be discarded. During training, we batch the examples by length and dynamically pad the short sentences with special symbol ${ \mathrm { < P A D > } }$ . The maximum answer length is set to 30. We use the pretrained 300-D word vectors GLoVe (Pennington et al., 2014), and all the out-of-vocabulary words are replace with ${ \mathrm { < U N K > } }$ , whose embedding is updated during training. Each character embedding is randomly initialized as a 200-D vector, which is updated in training as well. We generate two additional augmented datasets obtained from Section 3, which contain 140K and $2 4 0 \mathrm { K }$ examples and are denoted as “data augmentation $\times 2 ^ { , , }$ and “data augmentation $\times 3 ^ { \mathfrak { r } }$ respectively, including the original data.
+
+Training details. We employ two types of standard regularizations. First, we use L2 weight decay on all the trainable variables, with parameter $\lambda = 3 \times \bar { 1 0 } ^ { - 7 }$ . We additionally use dropout on word, character embeddings and between layers, where the word and character dropout rates are 0.1 and 0.05 respectively, and the dropout rate between every two layers is 0.1. We also adopt the stochastic depth method (layer dropout) (Huang et al., 2016) within each embedding or model encoder layer, where sublayer l has survival probability $\begin{array} { r } { p _ { l } = 1 - \frac { l } { L } ( 1 - p _ { L } ) } \end{array}$ where $L$ is the last layer and $p _ { L } = 0 . 9$ .
+
+The hidden size and the convolution filter number are all 128, the batch size is 32, training steps are 150K for original data, 250K for “data augmentation $\times 2 ^ { , , }$ , and 340K for “data augmentation $\times 3 ^ { \mathfrak { s } }$ . The numbers of convolution layers in the embedding and modeling encoder are 4 and 2, kernel sizes are 7 and 5, and the block numbers for the encoders are 1 and 7, respectively.
+
+We use the ADAM optimizer (Kingma & Ba, 2014) with $\beta _ { 1 } = 0 . 8 , \beta _ { 2 } = 0 . 9 9 9 , { \epsilon } = 1 0 ^ { - 7 }$ . We use a learning rate warm-up scheme with an inverse exponential increase from 0.0 to 0.001 in the first 1000 steps, and then maintain a constant learning rate for the remainder of training. Exponential moving average is applied on all trainable variables with a decay rate 0.9999.
+
+Finally, we implement our model in Python using Tensorflow (Abadi et al., 2016) and carry out our experiments on an NVIDIA p100 GPU.11
+
+# 4.1.2 RESULTS
+
+Accuracy. The F1 and Exact Match (EM) are two evaluation metrics of accuracy for the model performance. F1 measures the portion of overlap tokens between the predicted answer and groundtruth, while exact match score is 1 if the prediction is exactly the same as groundtruth or 0 otherwise. We show the results in comparison with other methods in Table 2. To make a fair and thorough comparison, we both report both the published results in their latest papers/preprints and the updated but not documented results on the leaderboard. We deem the latter as the unpublished results. As can be seen from the table, the accuracy (EM/F1) performance of our model is on par with the state-of-the-art models. In particular, our model trained on the original dataset outperforms all the documented results in the literature, in terms of both EM and F1 scores (see second column of Table 2). When trained with the augmented data with proper sampling scheme, our model can get significant gain 1.5/1.1 on EM/F1. Finally, our result on the official test set is 76.2/84.6, which significantly outperforms the best documented result 73.2/81.8.
+
+Speedup over RNNs. To measure the speedup of our model against the RNN models, we also test the corresponding model architecture with each encoder block replaced with a stack of bidirectional
+
+Table 2: The performances of different models on SQuAD dataset.   
+
+<table><tr><td></td><td>Published12</td><td>LeaderBoard13</td></tr><tr><td>Single Model</td><td>EM/F1</td><td>EM/F1</td></tr><tr><td>LR Baseline (Rajpurkar et al., 2016)</td><td>40.4/51.0</td><td>40.4/51.0</td></tr><tr><td>Dynamic Chunk Reader (Yu et al., 2016)</td><td>62.5 /71.0</td><td>62.5 /71.0</td></tr><tr><td>Match-LSTM with Ans-Ptr(Wang &amp; Jiang,2016)</td><td>64.7 /73.7</td><td>64.7 /73.7</td></tr><tr><td>Multi-Perspective Matching (Wang et al., 2016)</td><td>65.5 /75.1</td><td>70.4/78.8</td></tr><tr><td>Dynamic Coattention Networks (Xiong et al., 2016)</td><td>66.2 /75.9</td><td>66.2/75.9</td></tr><tr><td>FastQA(Weissenborn et al.,2017)</td><td>68.4/ 77.1</td><td>68.4/ 77.1</td></tr><tr><td>BiDAF (Seo et al., 2016)</td><td>68.0 /77.3</td><td>68.0 /77.3</td></tr><tr><td>SEDT (Liu et al.,2017a)</td><td>68.1 / 77.5</td><td>68.5/78.0</td></tr><tr><td>RaSoR (Lee et al.,2016)</td><td>70.8/78.7</td><td>69.6/77.7</td></tr><tr><td>FastQAExt (Weissenborn et al.,2017)</td><td>70.8 / 78.9</td><td>70.8/78.9</td></tr><tr><td>ReasoNet (Shen et al.,2017b)</td><td>69.1/78.9</td><td>70.6/79.4</td></tr><tr><td>Document Reader (Chen et al., 2017)</td><td>70.0 /79.0</td><td>70.7 /79.4</td></tr><tr><td>Ruminating Reader (Gong &amp; Bowman, 2017)</td><td>70.6 / 79.5</td><td>70.6 / 79.5</td></tr><tr><td>jNet (Zhang et al., 2017)</td><td>70.6 /79.8</td><td>70.6 /79.8</td></tr><tr><td>Conductor-net</td><td>N/A</td><td>72.6 /81.4</td></tr><tr><td>Interactive AoA Reader (Cui etal.,2017)</td><td>N/A</td><td>73.6 /81.9</td></tr><tr><td>Reg-RaSoR</td><td>N/A</td><td>75.8 /83.3</td></tr><tr><td>DCN+</td><td>N/A</td><td>74.9 /82.8</td></tr><tr><td>AIR-FusionNet</td><td>N/A</td><td>76.0 /83.9</td></tr><tr><td>R-Net (Wang et al., 2017)</td><td>72.3 / 80.7</td><td>76.5 /84.3</td></tr><tr><td>BiDAF+ Self Attention+ELMo</td><td>N/A</td><td>77.9/85.3</td></tr><tr><td>Reinforced Mnemonic Reader (Hu et al., 2017)</td><td>73.2 /81.8</td><td>73.2 /81.8</td></tr><tr><td>Dev set: QANet</td><td>73.6/82.7</td><td>N/A</td></tr><tr><td>Dev set: QANet + data augmentation ×2</td><td>74.5 /83.2</td><td>N/A</td></tr><tr><td>Dev set: QANet + data augmentation ×3</td><td>75.1/ 83.8</td><td>N/A</td></tr><tr><td>Test set: QANet + data augmentation ×3</td><td>76.2 / 84.6</td><td>76.2/84.6</td></tr></table>
+
+LSTMs as is used in most existing models. Specifically, each (embedding and model) encoder block is replaced with a 1, 2, or 3 layer Bidirectional LSTMs respectively, as such layer numbers fall into the usual range of the reading comprehension models (Chen et al., 2017). All of these LSTMs have hidden size 128. The results of the speedup comparison are shown in Table 3. We can easily see that our model is significantly faster than all the RNN based models and the speedups range from 3 to 13 times in training and 4 to 9 times in inference.
+
+Table 3: Speed comparison between our model and RNN-based models on SQuAD dataset, all with batch size 32. RNN- $x$ - $y$ indicates an RNN with $x$ layers each containing $y$ hidden units. Here, we use bidirectional LSTM as the RNN. The speed is measured by batches/second, so higher is faster.   
+
+<table><tr><td></td><td>QANet</td><td>RNN-1-128</td><td>Speedup</td><td>RNN-2-128</td><td>Speedup</td><td>RNN-3-128 Speedup</td></tr><tr><td>Training</td><td>3.2</td><td>1.1</td><td>2.9x</td><td>0.34</td><td>9.4x</td><td>0.24 13.3x</td></tr><tr><td>Inference</td><td>8.1</td><td>2.2</td><td>3.7x</td><td>1.3</td><td>6.2x</td><td>0.92 8.8x</td></tr></table>
+
+Speedup over BiDAF model. In addition, we also use the same hardware (a NVIDIA p100 GPU) and compare the training time of getting the same performance between our model and the BiDAF model14(Seo et al., 2016), a classic RNN-based model on SQuAD. We mostly adopt the default settings in the original code to get its best performance, where the batch sizes for training and inference are both 60. The only part we changed is the optimizer, where Adam with learning 0.001 is used here, as with Adadelta we got a bit worse performance. The result is shown in Table 4 which shows that our model is 4.3 and 7.0 times faster than BiDAF in training and inference speed. Besides, we only need one fifth of the training time to achieve BiDAF’s best F1 score (77.0) on dev set.
+
+Table 4: Speed comparison between our model and BiDAF (Seo et al., 2016) on SQuAD dataset.   
+
+<table><tr><td></td><td>Train time to get 77.0 F1onDev set</td><td>Train speed</td><td>Inference speed</td></tr><tr><td>QANet</td><td>3hours</td><td>102 samples/s</td><td>259 samples/s</td></tr><tr><td>BiDAF</td><td>15 hours</td><td>24 samples/s</td><td>37samples/s</td></tr><tr><td>Speedup</td><td>5.0x</td><td>4.3x</td><td>7.0x</td></tr></table>
+
+# 4.1.3 ABALATION STUDY AND ANALYSIS
+
+We conduct ablation studies on components of the proposed model, and investigate the effect of augmented data. The validation scores on the development set are shown in Table 5. As can be seen from the table, the use of convolutions in the encoders is crucial: both F1 and EM drop drastically by almost 3 percent if it is removed. Self-attention in the encoders is also a necessary component that contributes 1.4/1.3 gain of EM/F1 to the ultimate performance. We interpret these phenomena as follows: the convolutions capture the local structure of the context while the self-attention is able to model the global interactions between text. Hence they are complimentary to but cannot replace each other. The use of separable convolutions in lieu of tradition convolutions also has a prominent contribution to the performance, which can be seen by the slightly worse accuracy caused by replacing separable convolution with normal convolution.
+
+The Effect of Data Augmentation. We additionally perform experiments to understand the values of augmented data as their amount increases. As the last block of rows in the table shows, data augmentation proves to be helpful in further boosting performance. Making the training data twice as large by adding the En-Fr-En data only (ratio 1:1 between original training data and augmented data, as indicated by row “data augmentation $\times 2$ (1:1:0)”) yields an increase in the F1 by 0.5 percent. While adding more augmented data with French as a pivot does not provide performance gain, injecting additional augmented data En-De-En of the same amount brings another 0.2 improvement in F1, as indicated in entry “data augmentation $\times \ 3$ (1:1:1)”. We may attribute this gain to the diversity of the new data, which is produced by the translator of the new language.
+
+The Effect of Sampling Scheme. Although injecting more data beyond $\times \ 3$ does not benefit the model, we observe that a good sampling ratio between the original and augmented data during training can further boost the model performance. In particular, when we increase the sampling weight of augmented data from (1:1:1) to (1:2:1), the EM/F1 performance drops by $0 . 5 / 0 . 3$ . We conjecture that it is due to the fact that augmented data is noisy because of the back-translation, so it should not be the dominant data of training. We confirm this point by increasing the ratio of the original data from (1:2:1) to (2:2:1), where $0 . 6 / 0 . 5$ performance gain on EM/F1 is obtained. Then we fix the portion of the augmented data, and search the sample weight of the original data. Empirically, the ratio (3:1:1) yields the best performance, with 1.5/1.1 gain over the base model on EM/F1. This is also the model we submitted for test set evaluation.
+
+# 4.1.4 ROBUSTNESS STUDY
+
+In the following, we conduct experiments on the adversarial SQuAD dataset (Jia & Liang, 2017) to study the robustness of the proposed model. In this dataset, one or more sentences are appended to the original SQuAD context of test set, to intentionally mislead the trained models to produce wrong answers. However, the model is agnostic to those adversarial examples during training. We focus on two types of misleading sentences, namely, AddSent and AddOneSent. AddSent generates sentences that are similar to the question, but not contradictory to the correct answer, while AddOneSent adds a random human-approved sentence that is not necessarily related to the context.
+
+The model in use is exactly the one trained with the original SQuAD data (the one getting 84.6 F1 on test set), but now it is submitted to the adversarial server for evaluation. The results are shown in Table 6, where the F1 scores of other models are all extracted from Jia & Liang (2017).15 Again, we only compare the performance of single models. From Table 6, we can see that our model is on par with the state-of-the-art model Mnemonic, while significantly better than other models by a large margin. The robustness of our model is probably because it is trained with augmented data.
+
+Table 5: An ablation study of data augmentation and other aspects of our model. The reported results are obtained on the development set. For rows containing entry “data augmentation”, $^ { 6 6 } \times N ^ { \prime }$ means the data is enhanced to $N$ times as large as the original size, while the ratio in the bracket indicates the sampling ratio among the original, English-French-English and English-German-English data during training.   
+
+<table><tr><td colspan="2"></td><td>EM/F1</td><td>Differenceto Base Model EM/F1</td></tr><tr><td colspan="2">Base QANet</td><td>73.6/82.7</td><td></td></tr><tr><td rowspan="3"></td><td>- convolution in encoders</td><td>70.8/ 80.0</td><td>-2.8/-2.7</td></tr><tr><td>- self-attention in encoders</td><td>72.2 /81.4</td><td>-1.4 / -1.3</td></tr><tr><td>replace sep convolution with normal convolution</td><td>72.9 / 82.0</td><td>- 0.7/-0.7</td></tr><tr><td></td><td>+ data augmentation ×2 (1:1:0)</td><td>74.5/83.2</td><td>+0.9/+0.5</td></tr><tr><td></td><td>+ data augmentation ×3 (1:1:1)</td><td>74.8 /83.4</td><td>+1.2/+0.7</td></tr><tr><td></td><td>+ data augmentation ×3 (1:2:1)</td><td>74.3/83.1</td><td>+0.7 /+0.4</td></tr><tr><td></td><td>+ data augmentation ×3 (2:2:1)</td><td>74.9 / 83.6</td><td>+1.3/+0.9</td></tr><tr><td></td><td>+ data augmentation ×3 (2:1:1)</td><td>75.0 / 83.6</td><td>+1.4 /+0.9</td></tr><tr><td></td><td>+ data augmentation ×3 (3:1:1)</td><td>75.1/83.8</td><td>+1.5 / +1.1</td></tr><tr><td></td><td>+ data augmentation ×3 (4:1:1)</td><td>75.0 / 83.6</td><td>+1.4/ +0.9</td></tr><tr><td>+ data augmentation ×3 (5:1:1)</td><td></td><td>74.9 / 83.5</td><td>+1.3 /+0.8</td></tr></table>
+
+The injected noise in the training data might not only improve the generalization of the model but also make it robust to the adversarial sentences.   
+Table 6: The F1 scores on the adversarial SQuAD test set.   
+
+<table><tr><td>Single Model</td><td>AddSent</td><td>AddOneSent</td></tr><tr><td>Logistic (Rajpurkar et al.,2016)</td><td>23.2</td><td>30.4</td></tr><tr><td>Match (Wang &amp; Jiang,2016)</td><td>27.3</td><td>39.0</td></tr><tr><td>SEDT (Liu et al., 2017a)</td><td>33.9</td><td>44.8</td></tr><tr><td>DCR (Yu et al., 2016)</td><td>37.8</td><td>45.1</td></tr><tr><td>BiDAF (Seo et al., 2016)</td><td>34.3</td><td>45.7</td></tr><tr><td>jNet (Zhang et al.,2017)</td><td>37.9</td><td>47.0</td></tr><tr><td>Ruminating (Gong &amp; Bowman, 2017)</td><td>37.4</td><td>47.7</td></tr><tr><td>RaSOR (Lee et al., 2016)</td><td>39.5</td><td>49.5</td></tr><tr><td>MPCM (Wang et al.,2016)</td><td>40.3</td><td>50.0</td></tr><tr><td>ReasoNet (Shen et al.,2017b)</td><td>39.4</td><td>50.3</td></tr><tr><td>Mnemonic (Hu et al.,2017)</td><td>46.6</td><td>56.0</td></tr><tr><td>QANet</td><td>45.2</td><td>55.7</td></tr></table>
+
+# 4.2 EXPERIMENTS ON TRIVIAQA
+
+In this section, we test our model on another dataset TriviaQA (Joshi et al., 2017), which consists of 650K context-query-answer triples. There are 95K distinct question-answer pairs, which are authored by Trivia enthusiasts, with 6 evidence documents (context) per question on average, which are either crawled from Wikipedia or Web search. Compared to SQuAD, TriviaQA is more challenging in that: 1) its examples have much longer context (2895 tokens per context on average) and may contain several paragraphs, 2) it is much noisier than SQuAD due to the lack of human labeling, 3) it is possible that the context is not related to the answer at all, as it is crawled by key words.
+
+In this paper, we focus on testing our model on the subset consisting of answers from Wikipedia. According to the previous work (Joshi et al., 2017; Hu et al., 2017; Pan et al., 2017), the same model would have similar performance on both Wikipedia and Web, but the latter is five time larger. To keep the training time manageable, we omit the experiment on Web data.
+
+Due to the multi-paragraph nature of the context, researchers also find that simple hierarchical or multi-step reading tricks, such as first predicting which paragraph to read and then apply models like BiDAF to pinpoint the answer within that paragraph (Clark & Gardner, 2017), can significantly boost the performance on TriviaQA. However, in this paper, we focus on comparing with the single-paragraph reading baselines only. We believe that our model can be plugged into other multi-paragraph reading methods to achieve the similar or better performance, but it is out of the scope of this paper.
+
+The Wikipedia sub-dataset contains around 92K training and 11K development examples. The average context and question lengths are 495 and 15 respectively. In addition to the full development set, the authors of Joshi et al. (2017) also pick a verified subset that all the contexts inside can answer the associated questions. As the text could be long, we adopt the data processing similar to Hu et al. (2017); Joshi et al. (2017). In particular, for training and validation, we randomly select a window of length 256 and 400 encapsulating the answer respectively. All the remaining setting are the same as SQuAD experiment, except that the training steps are set to 120K.
+
+Accuracy. The accuracy performance on the development set is shown in Table 7. Again, we can see that our model outperforms the baselines in terms of F1 and EM on Full development set, and is on par with the state-of-the-art on the Verified dev set.
+
+Table 7: The development set performances of different single-paragraph reading models on the Wikipedia domain of TriviaQA dataset. Note that ∗ indicates the result on test set.   
+
+<table><tr><td></td><td>Full</td><td>Verified</td></tr><tr><td>Single Model</td><td>EM/F1</td><td>EM/F1</td></tr><tr><td>Random (Joshi et al.,2017)</td><td>12.7 /22.5</td><td>13.8/23.4</td></tr><tr><td>Classifier (Joshi et al., 2017)</td><td>23.4 / 27.7</td><td>23.6 /27.9</td></tr><tr><td>BiDAF (Seo et al., 2016)</td><td>40.3/45.7</td><td>46.5 /52.8</td></tr><tr><td>MEMEN (Pan et al.,2017)</td><td>43.2/46.9</td><td>49.3 / 55.8</td></tr><tr><td>M-Reader (Hu et al., 2017)*</td><td>46.9/ 52.9*</td><td>54.5/ 59.5*</td></tr><tr><td>QANet</td><td>51.1/ 56.6</td><td>53.3/59.2</td></tr></table>
+
+Speedup over RNNs. In addition to accuracy, we also benchmark the speed of our model against the RNN counterparts. As Table 8 shows, not surprisingly, our model has 3 to 11 times speedup in training and 3 to 9 times acceleration in inference, similar to the finding in SQuAD dataset.   
+
+<table><tr><td></td><td>QANet</td><td>RNN-1-128</td><td>Speedup</td><td>RNN-2-128</td><td>Speedup</td><td>RNN-3-128</td><td>Speedup</td></tr><tr><td>Training</td><td>1.8</td><td>0.41</td><td>4.4x</td><td>0.20</td><td>9.0x</td><td>0.11</td><td>16.4x</td></tr><tr><td>Inference</td><td>3.2</td><td>0.89</td><td>3.6x</td><td>0.47</td><td>6.8x</td><td>0.26</td><td>12.3x</td></tr></table>
+
+Table 8: Speed comparison between the proposed model and RNN-based models on TriviaQA Wikipedia dataset, all with batch size 32. RNN- $x$ - $y$ indicates an RNN with $x$ layers each containing $y$ hidden units. The RNNs used here are bidirectional LSTM. The processing speed is measured by batches/second, so higher is faster.
+
+# 5 RELATED WORK
+
+Machine reading comprehension and automated question answering has become an important topic in the NLP domain. Their popularity can be attributed to an increase in publicly available annotated datasets, such as SQuAD (Rajpurkar et al., 2016), TriviaQA (Joshi et al., 2017), CNN/Daily News (Hermann et al., 2015), WikiReading (Hewlett et al., 2016), Children Book Test (Hill et al., 2015), etc. A great number of end-to-end neural network models have been proposed to tackle these challenges, including BiDAF (Seo et al., 2016), r-net (Wang et al., 2017), DCN (Xiong et al., 2016), ReasoNet (Shen et al., 2017b), Document Reader (Chen et al., 2017), Interactive AoA Reader (Cui et al., 2017) and Reinforced Mnemonic Reader (Hu et al., 2017).
+
+Recurrent Neural Networks (RNNs) have featured predominatnly in Natural Language Processing in the past few years. The sequential nature of the text coincides with the design philosophy of RNNs, and hence their popularity. In fact, all the reading comprehension models mentioned above are based on RNNs. Despite being common, the sequential nature of RNN prevent parallel computation, as tokens must be fed into the RNN in order. Another drawback of RNNs is difficulty modeling long dependencies, although this is somewhat alleviated by the use of Gated Recurrent Unit (Chung et al.,
+
+2014) or Long Short Term Memory architectures (Hochreiter & Schmidhuber, 1997). For simple tasks such as text classification, with reinforcement learning techniques, models (Yu et al., 2017) have been proposed to skip irrelevant tokens to both further address the long dependencies issue and speed up the procedure. However, it is not clear if such methods can handle complicated tasks such as Q&A. The reading comprehension task considered in this paper always needs to deal with long text, as the context paragraphs may be hundreds of words long. Recently, attempts have been made to replace the recurrent networks by full convolution or full attention architectures (Kim, 2014; Gehring et al., 2017; Vaswani et al., 2017b; Shen et al., 2017a). Those models have been shown to be not only faster than the RNN architectures, but also effective in other tasks, such as text classification, machine translation or sentiment analysis.
+
+To the best of our knowledge, our paper is the first work to achieve both fast and accurate reading comprehension model, by discarding the recurrent networks in favor of feed forward architectures. Our paper is also the first to mix self-attention and convolutions, which proves to be empirically effective and achieves a significant gain of 2.7 F1. Note that Raiman & Miller (2017) recently proposed to accelerate reading comprehension by avoiding bi-directional attention and making computation conditional on the search beams. Nevertheless, their model is still based on the RNNs and the accuracy is not competitive, with an $\mathrm { E M } 6 8 . 4$ and F1 76.2. Weissenborn et al. (2017) also tried to build a fast Q&A model by deleting the context-query attention module. However, it again relied on RNN and is thus intrinsically slower than ours. The elimination of attention further has sacrificed the performance (with EM 68.4 and F1 77.1).
+
+Data augmentation has also been explored in natural language processing. For example, Zhang et al. (2015) proposed to enhance the dataset by replacing the words with their synonyms and showed its effectiveness in text classification. Raiman & Miller (2017) suggested using type swap to augment the $\mathrm { S Q u A D }$ dataset, which essentially replaces the words in the original paragraph with others with the same type. While it was shown to improve the accuracy, the augmented data has the same syntactic structure as the original data, so they are not sufficiently diverse. Zhou et al. (2017) improved the diversity of the SQuAD data by generating more questions. However, as reported by Wang et al. (2017), their method did not help improve the performance. The data augmentation technique proposed in this paper is based on paraphrasing the sentences by translating the original text back and forth. The major benefit is that it can bring more syntactical diversity to the enhanced data.
+
+# 6 CONCLUSION
+
+In this paper, we propose a fast and accurate end-to-end model, QANet, for machine reading comprehension. Our core innovation is to completely remove the recurrent networks in the encoder. The resulting model is fully feedforward, composed entirely of separable convolutions, attention, linear layers, and layer normalization, which is suitable for parallel computation. The resulting model is both fast and accurate: It surpasses the best published results on SQuAD dataset while up to 13/9 times faster than a competitive recurrent models for a training/inference iteration. Additionally, we find that we are able to achieve significant gains by utilizing data augmentation consisting of translating context and passage pairs to and from another language as a way of paraphrasing the questions and contexts.
+
+# ACKNOWLEDGEMENT
+
+Adams Wei Yu is supported by NVIDIA PhD Fellowship and CMU Presidential Fellowship. We would like to thank Samy Bengio, Lei Huang, Minjoon Seo, Noam Shazeer, Ashish Vaswani, Barret Zoph and the Google Brain Team for helpful discussions.
+
+# REFERENCES
+
+Mart´ın Abadi, Ashish Agarwal, Paul Barham, Eugene Brevdo, Zhifeng Chen, Craig Citro, Gregory S. Corrado, Andy Davis, Jeffrey Dean, Matthieu Devin, Sanjay Ghemawat, Ian J. Goodfellow, Andrew Harp, Geoffrey Irving, Michael Isard, Yangqing Jia, Rafal Jozefowicz, Lukasz ´ Kaiser, Manjunath Kudlur, Josh Levenberg, Dan Mane, Rajat Monga, Sherry Moore, Derek Gor- ´ don Murray, Chris Olah, Mike Schuster, Jonathon Shlens, Benoit Steiner, Ilya Sutskever, Kunal
+
+Talwar, Paul A. Tucker, Vincent Vanhoucke, Vijay Vasudevan, Fernanda B. Viegas, Oriol Vinyals, ´ Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, and Xiaoqiang Zheng. Tensorflow: Large-scale machine learning on heterogeneous distributed systems. CoRR, abs/1603.04467, 2016. URL http://arxiv.org/abs/1603.04467.
+
+Lei Jimmy Ba, Ryan Kiros, and Geoffrey E. Hinton. Layer normalization. CoRR, abs/1607.06450, 2016. URL http://arxiv.org/abs/1607.06450.
+
+Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. In International Conference on Learning Representations, 2015.
+
+Danqi Chen, Adam Fisch, Jason Weston, and Antoine Bordes. Reading wikipedia to answer opendomain questions. In Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics, ACL 2017, Vancouver, Canada, July 30 - August 4, Volume 1: Long Papers, pp. 1870–1879, 2017.
+
+Franc¸ois Chollet. Xception: Deep learning with depthwise separable convolutions. CoRR, abs/1610.02357, 2016. URL http://arxiv.org/abs/1610.02357.
+
+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.
+
+Christopher Clark and Matt Gardner. Simple and effective multi-paragraph reading comprehension. CoRR, abs/1710.10723, 2017. URL http://arxiv.org/abs/1710.10723.
+
+Yiming Cui, Zhipeng Chen, Si Wei, Shijin Wang, Ting Liu, and Guoping Hu. Attention-overattention neural networks for reading comprehension. In Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics, ACL 2017, Vancouver, Canada, July 30 - August 4, Volume 1: Long Papers, pp. 593–602, 2017.
+
+Li Dong, Jonathan Mallinson, Siva Reddy, and Mirella Lapata. Learning to paraphrase for question answering. In Proceedings of the 2017 Conference on Empirical Methods in Natural Language Processing, pp. 875–886. Association for Computational Linguistics, 2017. URL http://aclweb.org/anthology/D17-1091.
+
+Jonas Gehring, Michael Auli, David Grangier, Denis Yarats, and Yann N Dauphin. Convolutional sequence to sequence learning. In International Conference on Machine Learning, 2017.
+
+Yichen Gong and Samuel R. Bowman. Ruminating reader: Reasoning with gated multi-hop attention. CoRR, abs/1704.07415, 2017. URL http://arxiv.org/abs/1704.07415.
+
+Karl Moritz Hermann, Tomas Kocisk ´ y, Edward Grefenstette, Lasse Espeholt, Will Kay, Mustafa ´ Suleyman, and Phil Blunsom. Teaching machines to read and comprehend. In Advances in Neural Information Processing Systems 28: Annual Conference on Neural Information Processing Systems 2015, December 7-12, 2015, Montreal, Quebec, Canada, pp. 1693–1701, 2015.
+
+Daniel Hewlett, Alexandre Lacoste, Llion Jones, Illia Polosukhin, Andrew Fandrianto, Jay Han, Matthew Kelcey, and David Berthelot. Wikireading: A novel large-scale language understanding task over wikipedia. In Proceedings of the 54th Annual Meeting of the Association for Computational Linguistics, ACL 2016, August 7-12, 2016, Berlin, Germany, Volume 1: Long Papers, 2016.
+
+Felix Hill, Antoine Bordes, Sumit Chopra, and Jason Weston. The goldilocks principle: Reading children’s books with explicit memory representations. CoRR, abs/1511.02301, 2015.
+
+Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural computation, 9(8): 1735–1780, 1997.
+
+Minghao Hu, Yuxing Peng, and Xipeng Qiu. Reinforced mnemonic reader for machine comprehension. CoRR, abs/1705.02798, 2017. URL http://arxiv.org/abs/1705.02798.
+
+Gao Huang, Yu Sun, Zhuang Liu, Daniel Sedra, and Kilian Q. Weinberger. Deep networks with stochastic depth. In Computer Vision - ECCV 2016 - 14th European Conference, Amsterdam, The Netherlands, October 11-14, 2016, Proceedings, Part IV, pp. 646–661, 2016.
+
+Robin Jia and Percy Liang. Adversarial examples for evaluating reading comprehension systems. In Proceedings of the 2017 Conference on Empirical Methods in Natural Language Processing, EMNLP 2017, Copenhagen, Denmark, September 9-11, 2017, pp. 2021–2031, 2017.
+
+Mandar Joshi, Eunsol Choi, Daniel S. Weld, and Luke Zettlemoyer. Triviaqa: A large scale distantly supervised challenge dataset for reading comprehension. In Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics, ACL 2017, Vancouver, Canada, July 30 - August 4, Volume 1: Long Papers, pp. 1601–1611, 2017.
+
+Lukasz Kaiser, Aidan N Gomez, and Francois Chollet. Depthwise separable convolutions for neural machine translation. arXiv preprint arXiv:1706.03059, 2017.
+
+Yoon Kim. Convolutional neural networks for sentence classification. In Proceedings of the 2014 Conference on Empirical Methods in Natural Language Processing, EMNLP 2014, October 25- 29, 2014, Doha, Qatar, A meeting of SIGDAT, a Special Interest Group of the ACL, pp. 1746– 1751, 2014.
+
+Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. CoRR, abs/1412.6980, 2014. URL http://arxiv.org/abs/1412.6980.
+
+Kenton Lee, Tom Kwiatkowski, Ankur P. Parikh, and Dipanjan Das. Learning recurrent span representations for extractive question answering. CoRR, abs/1611.01436, 2016.
+
+Rui Liu, Junjie Hu, Wei Wei, Zi Yang, and Eric Nyberg. Structural embedding of syntactic trees for machine comprehension. In Proceedings of the 2017 Conference on Empirical Methods in Natural Language Processing, EMNLP 2017, Copenhagen, Denmark, September 9-11, 2017, pp. 826–835, 2017a.
+
+Xiaodong Liu, Yelong Shen, Kevin Duh, and Jianfeng Gao. Stochastic answer networks for machine reading comprehension. CoRR, abs/1712.03556, 2017b. URL http://arxiv.org/abs/ 1712.03556.
+
+Minh-Thang Luong, Hieu Pham, and Christopher D. Manning. Effective approaches to attentionbased neural machine translation. In EMNLP, 2015.
+
+Minh-Thang Luong, Eugene Brevdo, and Rui Zhao. Neural machine translation (seq2seq) tutorial. https://github.com/tensorflow/nmt, 2017.
+
+Jonathan Mallinson, Rico Sennrich, and Mirella Lapata. Paraphrasing revisited with neural machine translation. In Proceedings of the 15th Conference of the European Chapter of the Association for Computational Linguistics: Volume 1, Long Papers, pp. 881–893. Association for Computational Linguistics, 2017. URL http://aclweb.org/anthology/E17-1083.
+
+Boyuan Pan, Hao Li, Zhou Zhao, Bin Cao, Deng Cai, and Xiaofei He. MEMEN: multi-layer embedding with memory networks for machine comprehension. CoRR, abs/1707.09098, 2017.
+
+Jeffrey Pennington, Richard Socher, and Christopher D. Manning. Glove: Global vectors for word//w representation. In Empirical Methods in Natural Language Processing (EMNLP), pp. 1532–1543, 2014. URL http://www.aclweb.org/anthology/D14-1162.
+
+Jonathan Raiman and John Miller. Globally normalized reader. In Proceedings of the 2017 Conference on Empirical Methods in Natural Language Processing, EMNLP 2017, Copenhagen, Denmark, September 9-11, 2017, pp. 1070–1080, 2017.
+
+Pranav Rajpurkar, Jian Zhang, Konstantin Lopyrev, and Percy Liang. Squad: 100, $0 0 0 +$ questions for machine comprehension of text. In Proceedings of the 2016 Conference on Empirical Methods in Natural Language Processing, EMNLP 2016, Austin, Texas, USA, November 1-4, 2016, pp. 2383–2392, 2016.
+
+Rico Sennrich, Barry Haddow, and Alexandra Birch. Improving neural machine translation models with monolingual data. In ACL (1). The Association for Computer Linguistics, 2016.
+
+Min Joon Seo, Aniruddha Kembhavi, Ali Farhadi, and Hannaneh Hajishirzi. Bidirectional attention flow for machine comprehension. CoRR, abs/1611.01603, 2016. URL http://arxiv.org/ abs/1611.01603.
+
+Tao Shen, Tianyi Zhou, Guodong Long, Jing Jiang, Shirui Pan, and Chengqi Zhang. Disan: Directional self-attention network for rnn/cnn-free language understanding. CoRR, abs/1709.04696, 2017a. URL http://arxiv.org/abs/1709.04696.
+
+Yelong Shen, Po-Sen Huang, Jianfeng Gao, and Weizhu Chen. Reasonet: Learning to stop reading in machine comprehension. In Proceedings of the 23rd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, Halifax, NS, Canada, August 13 - 17, 2017, pp. 1047–1055, 2017b.
+
+Rupesh Kumar Srivastava, Klaus Greff, and Jurgen Schmidhuber. Highway networks. ¨ CoRR, abs/1505.00387, 2015. URL http://arxiv.org/abs/1505.00387.
+
+Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Lukasz Kaiser, and Illia Polosukhin. Attention is all you need. CoRR, abs/1706.03762, 2017a. URL http://arxiv.org/abs/1706.03762.
+
+Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Lukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Neural Information Processing Systems, 2017b.
+
+Shuohang Wang and Jing Jiang. Machine comprehension using match-lstm and answer pointer. CoRR, abs/1608.07905, 2016. URL http://arxiv.org/abs/1608.07905.
+
+Wenhui Wang, Nan Yang, Furu Wei, Baobao Chang, and Ming Zhou. Gated self-matching networks for reading comprehension and question answering. In Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics, ACL 2017, Vancouver, Canada, July 30 - August 4, Volume 1: Long Papers, pp. 189–198, 2017.
+
+Zhiguo Wang, Haitao Mi, Wael Hamza, and Radu Florian. Multi-perspective context matching for machine comprehension. CoRR, abs/1612.04211, 2016. URL http://arxiv.org/abs/ 1612.04211.
+
+Dirk Weissenborn, Georg Wiese, and Laura Seiffe. Making neural QA as simple as possible but not simpler. In Proceedings of the 21st Conference on Computational Natural Language Learning (CoNLL 2017), Vancouver, Canada, August 3-4, 2017, pp. 271–280, 2017.
+
+John Wieting, Jonathan Mallinson, and Kevin Gimpel. Learning paraphrastic sentence embeddings from back-translated bitext. In EMNLP, pp. 274–285. Association for Computational Linguistics, 2017.
+
+Yonghui Wu, Mike Schuster, Zhifeng Chen, Quoc V. Le, Mohammad Norouzi, Wolfgang Macherey, Maxim Krikun, Yuan Cao, Qin Gao, Klaus Macherey, Jeff Klingner, Apurva Shah, Melvin Johnson, Xiaobing Liu, Lukasz Kaiser, Stephan Gouws, Yoshikiyo Kato, Taku Kudo, Hideto Kazawa, Keith Stevens, George Kurian, Nishant Patil, Wei Wang, Cliff Young, Jason Smith, Jason Riesa, Alex Rudnick, Oriol Vinyals, Greg Corrado, Macduff Hughes, and Jeffrey Dean. Google’s neural machine translation system: Bridging the gap between human and machine translation. arXiv preprint arXiv:1609.08144, 2016.
+
+Caiming Xiong, Victor Zhong, and Richard Socher. Dynamic coattention networks for question answering. CoRR, abs/1611.01604, 2016. URL http://arxiv.org/abs/1611.01604.
+
+Adams Wei Yu, Hongrae Lee, and Quoc V. Le. Learning to skim text. In Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics, ACL 2017, Vancouver, Canada, July 30 - August 4, Volume 1: Long Papers, pp. 1880–1890, 2017.
+
+Yang Yu, Wei Zhang, Kazi Saidul Hasan, Mo Yu, Bing Xiang, and Bowen Zhou. End-to-end reading comprehension with dynamic answer chunk ranking. CoRR, abs/1610.09996, 2016. URL http: //arxiv.org/abs/1610.09996.
+
+Junbei Zhang, Xiao-Dan Zhu, Qian Chen, Li-Rong Dai, Si Wei, and Hui Jiang. Exploring question understanding and adaptation in neural-network-based question answering. CoRR, abs/1703.04617, 2017.
+
+Xiang Zhang, Junbo Jake Zhao, and Yann LeCun. Character-level convolutional networks for text classification. In Advances in Neural Information Processing Systems 28: Annual Conference on Neural Information Processing Systems 2015, December 7-12, 2015, Montreal, Quebec, Canada, pp. 649–657, 2015.
+
+Qingyu Zhou, Nan Yang, Furu Wei, Chuanqi Tan, Hangbo Bao, and Ming Zhou. Neural question generation from text: A preliminary study. CoRR, abs/1704.01792, 2017. URL http: //arxiv.org/abs/1704.01792.

parse/train/B14TlG-RW/B14TlG-RW_content_list.json

@@ -0,0 +1,1725 @@
+[
+    {
+        "type": "text",
+        "text": "QANET: COMBINING LOCAL CONVOLUTION WITH GLOBAL SELF-ATTENTION FOR READING COMPREHENSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            821,
+            171
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Adams Wei $\\mathbf { Y u } ^ { 1 }$ ∗, David Dohan2†, Minh-Thang Luong2† {weiyu}@cs.cmu.edu, {ddohan,thangluong}@google.com 1Carnegie Mellon University, 2Google Brain ",
+        "bbox": [
+            184,
+            194,
+            656,
+            238
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Rui Zhao, Kai Chen, Mohammad Norouzi, Quoc V. Le Google Brain ",
+        "bbox": [
+            184,
+            251,
+            563,
+            279
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            316,
+            544,
+            332
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Current end-to-end machine reading and question answering (Q&A) models are primarily based on recurrent neural networks (RNNs) with attention. Despite their success, these models are often slow for both training and inference due to the sequential nature of RNNs. We propose a new Q&A architecture called QANet, which does not require recurrent networks: Its encoder consists exclusively of convolution and self-attention, where convolution models local interactions and self-attention models global interactions. On the SQuAD dataset, our model is 3x to $1 3 \\mathrm { x }$ faster in training and $4 \\mathbf { x }$ to $9 \\mathbf { x }$ faster in inference, while achieving equivalent accuracy to recurrent models. The speed-up gain allows us to train the model with much more data. We hence combine our model with data generated by backtranslation from a neural machine translation model. On the SQuAD dataset, our single model, trained with augmented data, achieves 84.6 F1 score1 on the test set, which is significantly better than the best published F1 score of 81.8. ",
+        "bbox": [
+            233,
+            344,
+            764,
+            525
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            549,
+            334,
+            564
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "There is growing interest in the tasks of machine reading comprehension and automated question answering. Over the past few years, significant progress has been made with end-to-end models showing promising results on many challenging datasets. The most successful models generally employ two key ingredients: (1) a recurrent model to process sequential inputs, and (2) an attention component to cope with long term interactions. A successful combination of these two ingredients is the Bidirectional Attention Flow (BiDAF) model by Seo et al. (2016), which achieve strong results on the SQuAD dataset (Rajpurkar et al., 2016). A weakness of these models is that they are often slow for both training and inference due to their recurrent nature, especially for long texts. The expensive training not only leads to high turnaround time for experimentation and limits researchers from rapid iteration but also prevents the models from being used for larger dataset. Meanwhile the slow inference prevents the machine comprehension systems from being deployed in real-time applications. ",
+        "bbox": [
+            174,
+            579,
+            825,
+            744
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper, aiming to make the machine comprehension fast, we propose to remove the recurrent nature of these models. We instead exclusively use convolutions and self-attentions as the building blocks of encoders that separately encodes the query and context. Then we learn the interactions between context and question by standard attentions (Xiong et al., 2016; Seo et al., 2016; Bahdanau et al., 2015). The resulting representation is encoded again with our recurrency-free encoder before finally decoding to the probability of each position being the start or end of the answer span. We call this architecture QANet, which is shown in Figure 1. ",
+        "bbox": [
+            173,
+            753,
+            825,
+            851
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The key motivation behind the design of our model is the following: convolution captures the local structure of the text, while the self-attention learns the global interaction between each pair of words. The additional context-query attention is a standard module to construct the query-aware context vector for each position in the context paragraph, which is used in the subsequent modeling layers. The feed-forward nature of our architecture speeds up the model significantly. In our experiments on the SQuAD dataset, our model is $3 \\mathbf { x }$ to $1 3 \\mathrm { x }$ faster in training and 4x to $9 \\mathbf { x }$ faster in inference. As a simple comparison, our model can achieve the same accuracy (77.0 F1 score) as BiDAF model (Seo et al., 2016) within 3 hours training that otherwise should have taken 15 hours. The speed-up gain also allows us to train the model with more iterations to achieve better results than competitive models. For instance, if we allow our model to train for 18 hours, it achieves an F1 score of 82.7 on the dev set, which is much better than (Seo et al., 2016), and is on par with best published results. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            256
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "As our model is fast, we can train it with much more data than other models. To further improve the model, we propose a complementary data augmentation technique to enhance the training data. This technique paraphrases the examples by translating the original sentences from English to another language and then back to English, which not only enhances the number of training instances but also diversifies the phrasing. ",
+        "bbox": [
+            174,
+            263,
+            823,
+            333
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "On the SQuAD dataset, QANet trained with the augmented data achieves 84.6 F1 score on the test set, which is significantly better than the best published result of 81.8 by Hu et al. (2017).2 We also conduct ablation test to justify the usefulness of each component of our model. In summary, the contribution of this paper are as follows: ",
+        "bbox": [
+            176,
+            340,
+            825,
+            396
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• We propose an efficient reading comprehension model that exclusively built upon convolutions and self-attentions. To the best of our knowledge, we are the first to do so. This combination maintains good accuracy, while achieving up to $1 3 \\mathrm { x }$ speedup in training and $9 \\mathbf { x }$ per training iteration, compared to the RNN counterparts. The speedup gain makes our model the most promising candidate for scaling up to larger datasets. • To improve our result on SQuAD, we propose a novel data augmentation technique to enrich the training data by paraphrasing. It allows the model to achieve higher accuracy that is better than the state-of-the-art. ",
+        "bbox": [
+            215,
+            409,
+            823,
+            525
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 THE MODEL ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            545,
+            310,
+            561
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this section, we first formulate the reading comprehension problem and then describe the proposed model QANet: it is a feedforward model that consists of only convolutions and self-attention, a combination that is empirically effective, and is also a novel contribution of our work. ",
+        "bbox": [
+            176,
+            577,
+            823,
+            619
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 PROBLEM FORMULATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            637,
+            392,
+            651
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The reading comprehension task considered in this paper, is defined as follows. Given a context paragraph with $n$ words $C = \\{ c _ { 1 } , c _ { 2 } , . . . , c _ { n } \\}$ and the query sentence with $m$ words $Q = \\{ q _ { 1 } , q _ { 2 } , . . . , \\bar { q } _ { m } \\}$ , output a span $S = \\{ c _ { i } , c _ { i + 1 } , . . . , c _ { i + j } \\}$ from the original paragraph $C$ . In the following, we will use $x$ to denote both the original word and its embedded vector, for any $x \\in C , Q$ . ",
+        "bbox": [
+            174,
+            662,
+            825,
+            719
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.2 MODEL OVERVIEW ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            736,
+            348,
+            751
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The high level structure of our model is similar to most existing models that contain five major components: an embedding layer, an embedding encoder layer, a context-query attention layer, a model encoder layer and an output layer, as shown in Figure 1. These are the standard building blocks for most, if not all, existing reading comprehension models. However, the major differences between our approach and other methods are as follow: For both the embedding and modeling encoders, we only use convolutional and self-attention mechanism, discarding RNNs, which are used by most of the existing reading comprehension models. As a result, our model is much faster, as it can process the input tokens in parallel. Note that even though self-attention has already been used extensively in Vaswani et al. (2017a), the combination of convolutions and self-attention is novel, and is significantly better than self-attention alone and gives 2.7 F1 gain in our experiments. The use of convolutions also allows us to take advantage of common regularization methods in ConvNets such as stochastic depth (layer dropout) (Huang et al., 2016), which gives an additional gain of $0 . 2 \\mathrm { F } 1$ in our experiments. ",
+        "bbox": [
+            173,
+            762,
+            825,
+            875
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/9f4efb3d6b6401bb890a7c0b5541dd68786a9cf6fd26b697fd8e7e069e03eefa.jpg",
+        "image_caption": [
+            "Figure 1: An overview of the QANet architecture (left) which has several Encoder Blocks. We use the same Encoder Block (right) throughout the model, only varying the number of convolutional layers for each block. We use layernorm and residual connection between every layer in the Encoder Block. We also share weights of the context and question encoder, and of the three output encoders. A positional encoding is added to the input at the beginning of each encoder layer consisting of sin and cos functions at varying wavelengths, as defined in (Vaswani et al., 2017a). Each sub-layer after the positional encoding (one of convolution, self-attention, or feed-forward-net) inside the encoder structure is wrapped inside a residual block. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            267,
+            107,
+            727,
+            391
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            546,
+            825,
+            616
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In detail, our model consists of the following five layers: ",
+        "bbox": [
+            174,
+            623,
+            544,
+            637
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "1. Input Embedding Layer. We adopt the standard techniques to obtain the embedding of each word $w$ by concatenating its word embedding and character embedding. The word embedding is fixed during training and initialized from the $p _ { 1 } = 3 0 0$ dimensional pre-trained GloVe (Pennington et al., 2014) word vectors, which are fixed during training. All the out-of-vocabulary words are mapped to an ${ \\mathrm { < U N K > } }$ token, whose embedding is trainable with random initialization. The character embedding is obtained as follows: Each character is represented as a trainable vector of dimension $p _ { 2 } = 2 0 0$ , meaning each word can be viewed as the concatenation of the embedding vectors for each of its characters. The length of each word is either truncated or padded to 16. We take maximum value of each row of this matrix to get a fixed-size vector representation of each word. Finally, the output of a given word $x$ from this layer is the concatenation $[ x _ { w } ; x _ { c } ] \\in \\mathbf { R } ^ { p _ { 1 } + p _ { 2 } }$ , where $x _ { w }$ and $x _ { c }$ are the word embedding and the convolution output of character embedding of $x$ respectively. Following Seo et al. (2016), we also adopt a two-layer highway network (Srivastava et al., 2015) on top of this representation. For simplicity, we also use $x$ to denote the output of this layer. ",
+        "bbox": [
+            173,
+            656,
+            825,
+            837
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2. Embedding Encoder Layer. The encoder layer is a stack of the following basic building block: [convolution-layer $\\times \\# +$ self-attention-layer $^ +$ feed-forward-layer], as illustrated in the upper right of Figure 1. We use depthwise separable convolutions (Chollet, 2016) (Kaiser et al., 2017) rather than traditional ones, as we observe that it is memory efficient and has better generalization. The kernel size is 7, the number of filters is $d = 1 2 8$ and the number of conv layers within a block is ",
+        "bbox": [
+            174,
+            854,
+            823,
+            922
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "4. For the self-attention-layer, we adopt the multi-head attention mechanism defined in (Vaswani et al., 2017a) which, for each position in the input, called the query, computes a weighted sum of all positions, or keys, in the input based on the similarity between the query and key as measured by the dot product. The number of heads is 8 throughout all the layers. Each of these basic operations (conv/self-attention/ffn) is placed inside a residual block, shown lower-right in Figure 1. For an input $x$ and a given operation $f$ , the output is $f ( l a y e r n o r m ( x ) ) + x$ , meaning there is a full identity path from the input to output of each block, where layernorm indicates layer-normalization proposed in (Ba et al., 2016). The total number of encoder blocks is 1. Note that the input of this layer is a vector of dimension $p _ { 1 } + p _ { 2 } = 5 0 0$ for each individual word, which is immediately mapped to $d = 1 2 8$ by a one-dimensional convolution. The output of this layer is a also of dimension $d = 1 2 8$ . ",
+        "bbox": [
+            173,
+            103,
+            825,
+            243
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3. Context-Query Attention Layer. This module is standard in almost every previous reading comprehension models such as Weissenborn et al. (2017) and Chen et al. (2017). We use $C$ and $Q$ to denote the encoded context and query. The context-to-query attention is constructed as follows: We first computer the similarities between each pair of context and query words, rendering a similarity matrix $S \\in \\mathbf { R } ^ { n \\times m }$ . We then normalize each row of $S$ by applying the softmax function, getting a matrix $\\overline { S }$ . Then the context-to-query attention is computed as $\\bar { A } = \\mathbf { \\bar { \\boldsymbol { S } } } \\cdot \\boldsymbol { Q } ^ { T } \\in \\mathbf { R } ^ { n \\times d }$ . The similarity function used here is the trilinear function (Seo et al., 2016): ",
+        "bbox": [
+            173,
+            256,
+            825,
+            354
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6f95650220c2646b0d930e1cb52c4f690f88d3b1bba390b34ab2f2f00c206a7a.jpg",
+        "text": "$$\n\\begin{array} { r } { f ( q , c ) = W _ { 0 } [ q , c , q \\odot c ] , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            413,
+            357,
+            583,
+            375
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\odot$ is the element-wise multiplication and $W _ { 0 }$ is a trainable variable. ",
+        "bbox": [
+            174,
+            376,
+            660,
+            392
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Most high performing models additionally use some form of query-to-context attention, such as BiDaF (Seo et al., 2016) and DCN (Xiong et al., 2016). Empirically, we find that, the DCN attention can provide a little benefit over simply applying context-to-query attention, so we adopt this strategy. More concretely, we compute the column normalized matrix $\\overline { { \\overline { { S } } } }$ of $S$ by softmax function, and the query-to-context attention is B = S · S  · C T . ",
+        "bbox": [
+            173,
+            397,
+            825,
+            479
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4. Model Encoder Layer. Similar to Seo et al. (2016), the input of this layer at each position is $\\left[ c , a , c \\odot a , c \\odot b \\right]$ , where $a$ and $b$ are respectively a row of attention matrix $A$ and $B$ . The layer parameters are the same as the Embedding Encoder Layer except that convolution layer number is 2 within a block and the total number of blocks are 7. We share weights between each of the 3 repetitions of the model encoder. ",
+        "bbox": [
+            173,
+            492,
+            825,
+            563
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "5. Output layer. This layer is task-specific. Each example in SQuAD is labeled with a span in the context containing the answer. We adopt the strategy of Seo et al. (2016) to predict the probability of each position in the context being the start or end of an answer span. More specifically, the probabilities of the starting and ending position are modeled as ",
+        "bbox": [
+            173,
+            577,
+            825,
+            633
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/702eee08d803d5bff6f20319c424b0fac9a5482b8b7a7c963066d95dabbf855f.jpg",
+        "text": "$$\np ^ { 1 } = s o f t m a x ( W _ { 1 } [ M _ { 0 } ; M _ { 1 } ] ) , ~ p ^ { 2 } = s o f t m a x ( W _ { 2 } [ M _ { 0 } ; M _ { 2 } ] ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            287,
+            635,
+            707,
+            654
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $W _ { 1 }$ and $W _ { 2 }$ are two trainable variables and $M _ { 0 } , M _ { 1 } , M _ { 2 }$ are respectively the outputs of the three model encoders, from bottom to top. The score of a span is the product of its start position and end position probabilities. Finally, the objective function is defined as the negative sum of the log probabilities of the predicted distributions indexed by true start and end indices, averaged over all the training examples: ",
+        "bbox": [
+            173,
+            655,
+            825,
+            724
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/61517a40ff86c875cb53582487d29d4e7a5dd307abc99b7a7604432f34661c76.jpg",
+        "text": "$$\nL ( \\theta ) = - \\frac { 1 } { N } \\sum _ { i } ^ { N } \\left[ \\log ( p _ { y _ { i } ^ { 1 } } ^ { 1 } ) + \\log ( p _ { y _ { i } ^ { 2 } } ^ { 2 } ) \\right] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            362,
+            723,
+            633,
+            766
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $y _ { i } ^ { 1 }$ and $y _ { i } ^ { 2 }$ are respectively the groundtruth starting and ending position of example $i$ , and $\\theta$ contains all the trainable variables. The proposed model can be customized to other comprehension tasks, e.g. selecting from the candidate answers, by changing the output layers accordingly. ",
+        "bbox": [
+            174,
+            767,
+            825,
+            810
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Inference. At inference time, the predicted span $( s , e )$ is chosen such that $p _ { s } ^ { 1 } p _ { e } ^ { 2 }$ is maximized and $s \\leq e$ . Standard dynamic programming can obtain the result with linear time. ",
+        "bbox": [
+            169,
+            815,
+            823,
+            845
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 DATA AUGMENTATION BY BACKTRANSLATION ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            864,
+            596,
+            881
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Since our model is fast, we can train it with much more data. We therefore combine our model with a simple data augmentation technique to enrich the training data. The idea is to use two translation models, one translation model from English to French (or any other language) and another translation model from French to English, to obtain paraphrases of texts. This approach helps automatically increase the amount of training data for broadly any language-based tasks including the reading comprehension task that we are interested in. With more data, we expect to better regularize our models. The augmentation process is illustrated in Figure 2 with French as a pivotal language. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            174
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this work, we consider attention-based neural machine translation (NMT) models Bahdanau et al. (2015); Luong et al. (2015), which have demonstrated excellent translation quality Wu et al. (2016), as the core models of our data augmentation pipeline. Specifically, we utilize the publicly available codebase3 provided by Luong et al. (2017), which replicates the Google’s NMT (GNMT) systems Wu et al. (2016). We train 4-layer GNMT models on the public WMT data for both English-French4 (36M sentence pairs) and English-German5 (4.5M sentence pairs). All data have been tokenized and split into subword units as described in Luong et al. (2017). All models share the same hyperparameters6 and are trained with different numbers of steps, 2M for English-French and 340K for English-German. Our English-French systems achieve 36.7 BLEU on newstest2014 for translating into French and 35.9 BLEU for the reverse direction. For English-German and on newstest2014, we obtain 27.6 BLEU for translating into German and 29.9 BLEU for the reverse direction. ",
+        "bbox": [
+            173,
+            180,
+            825,
+            333
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/28706f1cf855b1712c3db553cd3b78da8b285291fe96d2dc7bd8d8823aade21c.jpg",
+        "image_caption": [
+            "Figure 2: An illustration of the data augmentation process with French as a pivotal language. $\\mathbf { k }$ is the beam width, which is the number of translations generated by the NMT system. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            269,
+            348,
+            728,
+            517
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Our paraphrase process works as follows, supposedly with French as a pivotal language. First, we feed an input sequence into the beam decoder of an English-to-French model to obtain $k$ French translations. Each of the French translation is then passed through the beam decoder of a reversed translation model to obtain a total of $k ^ { 2 }$ paraphrases of the input sequence. ",
+        "bbox": [
+            174,
+            580,
+            825,
+            636
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Relation to existing Works. While the concept of backtranslation has been introduced before, it is often used to improve either the same translation task Sennrich et al. (2016) or instrinsic paraphrase evaluations Wieting et al. (2017); Mallinson et al. (2017). Our approach is a novel application of backtranslation to enrich training data for down-stream tasks, in this case, the question answering (QA) task. It is worth to note that (Dong et al., 2017) use paraphrasing techniques to improve QA; however, they only paraphrase questions and did not focus on the data augmentation aspect as we do in this paper. ",
+        "bbox": [
+            173,
+            654,
+            825,
+            752
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Handling SQuAD Documents and Answers. We now discuss our specific procedure for the SQuAD dataset, which is essential for best performance gains. Remember that, each training example of SQuAD is a triple of $( d , q , a )$ in which document $d$ is a multi-sentence paragraph that has the answer $a$ . When paraphrasing, we keep the question $q$ unchanged (to avoid accidentally changing its meaning) and generate new triples of $\\bar { ( d ^ { \\prime } , q , a ^ { \\prime } ) }$ such that the new document $d ^ { \\prime }$ has the new answer $a ^ { \\prime }$ in it. The procedure happens in two steps: (i) document paraphrasing – paraphrase $d$ into $d ^ { \\prime }$ and (b) answer extraction – extract $a ^ { \\prime }$ from $d ^ { \\prime }$ that closely matches $a$ . ",
+        "bbox": [
+            174,
+            770,
+            825,
+            840
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For the document paraphrasing step, we first split paragraphs into sentences and paraphrase them independently. We use $k = 5$ , so each sentence has 25 paraphrase choices. A new document $d ^ { \\prime }$ is formed by simply replacing each sentence in $d$ with a randomly-selected paraphrase. An obvious issue with this na¨ıve approach is that the original answer $a$ might no longer be present in $d ^ { \\prime }$ . ",
+        "bbox": [
+            174,
+            138,
+            823,
+            195
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The answer extraction addresses the aforementioned issue. Let $s$ be the original sentence that contains the original answer $a$ and $s ^ { \\prime }$ be its paraphrase. We identify the newly-paraphrased answer with simple heuristics as follows. Character-level 2-gram scores are computed between each word in $s ^ { \\prime }$ and the start / end words of $a$ to find start and end positions of possible answers in $s ^ { \\prime }$ . Among all candidate paraphrased answer, the one with the highest character 2-gram score with respect to $a$ is selected as the new answer $a ^ { \\prime }$ . Table 1 shows an example of the new answer found by this process.7 ",
+        "bbox": [
+            174,
+            202,
+            823,
+            285
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/72e990ec33439a3c6d27a4c1ffc9bfa743b74c375e1b98063bd5a107aa76bbf7.jpg",
+        "table_caption": [
+            "Table 1: Comparison between answers in original sentence and paraphrased sentence. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>Sentence that contains an answer</td><td rowspan=1 colspan=1>Answer</td></tr><tr><td rowspan=1 colspan=1>Original</td><td rowspan=1 colspan=1>All of the departments in the College of Science offer PhDprograms,except for the Department of Pre-ProfessionalStudies.</td><td rowspan=1 colspan=1>Department   of   Pre-Professional Studies</td></tr><tr><td rowspan=1 colspan=1>Paraphrase</td><td rowspan=1 colspan=1>All departments in the College of Science offer PHD pro- grams with the exception of the Department of PreparatoryStudies.</td><td rowspan=1 colspan=1>Department of PreparatoryStudies</td></tr></table>",
+        "bbox": [
+            181,
+            299,
+            818,
+            392
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The quality and diversity of paraphrases are essential to the data augmentation method. It is still possible to improve the quality and diversity of this method. The quality can be improved by using better translation models. For example, we find paraphrases significantly longer than our models’ maximum training sequence length tend to be cut off in the middle. The diversity can be improved by both sampling during the beam search decoding and paraphrasing questions and answers in the dataset as well. In addition, we can combine this method with other data augmentation methods, such as, the type swap method (Raiman & Miller, 2017), to acquire more diversity in paraphrases. ",
+        "bbox": [
+            174,
+            438,
+            825,
+            536
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In our experiments, we observe that the proposed data augmentation can bring non-trivial improvement in terms of accuracy. We believe this technique is also applicable to other supervised natural language processing tasks, especially when the training data is insufficient. ",
+        "bbox": [
+            176,
+            542,
+            823,
+            584
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            606,
+            326,
+            621
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In this section, we conduct experiments to study the performance of our model and the data augmentation technique. We will primarily benchmark our model on the SQuAD dataset (Rajpurkar et al., 2016), considered to be one of the most competitive datasets in Q&A. We also conduct similar studies on TriviaQA (Joshi et al., 2017), another Q&A dataset, to show that the effectiveness and efficiency of our model are general. ",
+        "bbox": [
+            174,
+            637,
+            825,
+            707
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 EXPERIMENTS ON SQUAD ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            724,
+            400,
+            739
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1.1 DATASET AND EXPERIMENTAL SETTINGS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            751,
+            516,
+            766
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Dataset. We consider the Stanford Question Answering Dataset (SQuAD) (Rajpurkar et al., 2016) for machine reading comprehension.8 SQuAD contains 107.7K query-answer pairs, with $8 7 . 5 \\mathrm { K }$ for training, 10.1K for validation, and another 10.1K for testing. The typical length of the paragraphs is around 250 while the question is of 10 tokens although there are exceptionally long cases. Only the training and validation data are publicly available, while the test data is hidden that one has to submit the code to a Codalab and work with the authors of (Rajpurkar et al., 2016) to retrieve the final test score. In our experiments, we report the test set result of our best single model.9 For further analysis, we only report the performance on the validation set, as we do not want to probe the unseen test set by frequent submissions. According to the observations from our experiments and previous works, such as (Seo et al., 2016; Xiong et al., 2016; Wang et al., 2017; Chen et al., 2017), the validation score is well correlated with the test score. ",
+        "bbox": [
+            173,
+            775,
+            825,
+            859
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            172
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Data Preprocessing. We use the NLTK tokenizer to preprocess the data.10 The maximum context length is set to 400 and any paragraph longer than that would be discarded. During training, we batch the examples by length and dynamically pad the short sentences with special symbol ${ \\mathrm { < P A D > } }$ . The maximum answer length is set to 30. We use the pretrained 300-D word vectors GLoVe (Pennington et al., 2014), and all the out-of-vocabulary words are replace with ${ \\mathrm { < U N K > } }$ , whose embedding is updated during training. Each character embedding is randomly initialized as a 200-D vector, which is updated in training as well. We generate two additional augmented datasets obtained from Section 3, which contain 140K and $2 4 0 \\mathrm { K }$ examples and are denoted as “data augmentation $\\times 2 ^ { , , }$ and “data augmentation $\\times 3 ^ { \\mathfrak { r } }$ respectively, including the original data. ",
+        "bbox": [
+            174,
+            188,
+            825,
+            314
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Training details. We employ two types of standard regularizations. First, we use L2 weight decay on all the trainable variables, with parameter $\\lambda = 3 \\times \\bar { 1 0 } ^ { - 7 }$ . We additionally use dropout on word, character embeddings and between layers, where the word and character dropout rates are 0.1 and 0.05 respectively, and the dropout rate between every two layers is 0.1. We also adopt the stochastic depth method (layer dropout) (Huang et al., 2016) within each embedding or model encoder layer, where sublayer l has survival probability $\\begin{array} { r } { p _ { l } = 1 - \\frac { l } { L } ( 1 - p _ { L } ) } \\end{array}$ where $L$ is the last layer and $p _ { L } = 0 . 9$ . ",
+        "bbox": [
+            174,
+            328,
+            823,
+            412
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The hidden size and the convolution filter number are all 128, the batch size is 32, training steps are 150K for original data, 250K for “data augmentation $\\times 2 ^ { , , }$ , and 340K for “data augmentation $\\times 3 ^ { \\mathfrak { s } }$ . The numbers of convolution layers in the embedding and modeling encoder are 4 and 2, kernel sizes are 7 and 5, and the block numbers for the encoders are 1 and 7, respectively. ",
+        "bbox": [
+            174,
+            419,
+            825,
+            474
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We use the ADAM optimizer (Kingma & Ba, 2014) with $\\beta _ { 1 } = 0 . 8 , \\beta _ { 2 } = 0 . 9 9 9 , { \\epsilon } = 1 0 ^ { - 7 }$ . We use a learning rate warm-up scheme with an inverse exponential increase from 0.0 to 0.001 in the first 1000 steps, and then maintain a constant learning rate for the remainder of training. Exponential moving average is applied on all trainable variables with a decay rate 0.9999. ",
+        "bbox": [
+            176,
+            481,
+            823,
+            537
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Finally, we implement our model in Python using Tensorflow (Abadi et al., 2016) and carry out our experiments on an NVIDIA p100 GPU.11 ",
+        "bbox": [
+            174,
+            544,
+            823,
+            571
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.1.2 RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            587,
+            292,
+            602
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Accuracy. The F1 and Exact Match (EM) are two evaluation metrics of accuracy for the model performance. F1 measures the portion of overlap tokens between the predicted answer and groundtruth, while exact match score is 1 if the prediction is exactly the same as groundtruth or 0 otherwise. We show the results in comparison with other methods in Table 2. To make a fair and thorough comparison, we both report both the published results in their latest papers/preprints and the updated but not documented results on the leaderboard. We deem the latter as the unpublished results. As can be seen from the table, the accuracy (EM/F1) performance of our model is on par with the state-of-the-art models. In particular, our model trained on the original dataset outperforms all the documented results in the literature, in terms of both EM and F1 scores (see second column of Table 2). When trained with the augmented data with proper sampling scheme, our model can get significant gain 1.5/1.1 on EM/F1. Finally, our result on the official test set is 76.2/84.6, which significantly outperforms the best documented result 73.2/81.8. ",
+        "bbox": [
+            174,
+            611,
+            825,
+            777
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Speedup over RNNs. To measure the speedup of our model against the RNN models, we also test the corresponding model architecture with each encoder block replaced with a stack of bidirectional ",
+        "bbox": [
+            174,
+            792,
+            823,
+            820
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/cc9594e3b62f210894b68efbc063aa158c129ccf1657dbbc962796f4f433a62d.jpg",
+        "table_caption": [
+            "Table 2: The performances of different models on SQuAD dataset. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>Published12</td><td>LeaderBoard13</td></tr><tr><td>Single Model</td><td>EM/F1</td><td>EM/F1</td></tr><tr><td>LR Baseline (Rajpurkar et al., 2016)</td><td>40.4/51.0</td><td>40.4/51.0</td></tr><tr><td>Dynamic Chunk Reader (Yu et al., 2016)</td><td>62.5 /71.0</td><td>62.5 /71.0</td></tr><tr><td>Match-LSTM with Ans-Ptr(Wang &amp; Jiang,2016)</td><td>64.7 /73.7</td><td>64.7 /73.7</td></tr><tr><td>Multi-Perspective Matching (Wang et al., 2016)</td><td>65.5 /75.1</td><td>70.4/78.8</td></tr><tr><td>Dynamic Coattention Networks (Xiong et al., 2016)</td><td>66.2 /75.9</td><td>66.2/75.9</td></tr><tr><td>FastQA(Weissenborn et al.,2017)</td><td>68.4/ 77.1</td><td>68.4/ 77.1</td></tr><tr><td>BiDAF (Seo et al., 2016)</td><td>68.0 /77.3</td><td>68.0 /77.3</td></tr><tr><td>SEDT (Liu et al.,2017a)</td><td>68.1 / 77.5</td><td>68.5/78.0</td></tr><tr><td>RaSoR (Lee et al.,2016)</td><td>70.8/78.7</td><td>69.6/77.7</td></tr><tr><td>FastQAExt (Weissenborn et al.,2017)</td><td>70.8 / 78.9</td><td>70.8/78.9</td></tr><tr><td>ReasoNet (Shen et al.,2017b)</td><td>69.1/78.9</td><td>70.6/79.4</td></tr><tr><td>Document Reader (Chen et al., 2017)</td><td>70.0 /79.0</td><td>70.7 /79.4</td></tr><tr><td>Ruminating Reader (Gong &amp; Bowman, 2017)</td><td>70.6 / 79.5</td><td>70.6 / 79.5</td></tr><tr><td>jNet (Zhang et al., 2017)</td><td>70.6 /79.8</td><td>70.6 /79.8</td></tr><tr><td>Conductor-net</td><td>N/A</td><td>72.6 /81.4</td></tr><tr><td>Interactive AoA Reader (Cui etal.,2017)</td><td>N/A</td><td>73.6 /81.9</td></tr><tr><td>Reg-RaSoR</td><td>N/A</td><td>75.8 /83.3</td></tr><tr><td>DCN+</td><td>N/A</td><td>74.9 /82.8</td></tr><tr><td>AIR-FusionNet</td><td>N/A</td><td>76.0 /83.9</td></tr><tr><td>R-Net (Wang et al., 2017)</td><td>72.3 / 80.7</td><td>76.5 /84.3</td></tr><tr><td>BiDAF+ Self Attention+ELMo</td><td>N/A</td><td>77.9/85.3</td></tr><tr><td>Reinforced Mnemonic Reader (Hu et al., 2017)</td><td>73.2 /81.8</td><td>73.2 /81.8</td></tr><tr><td>Dev set: QANet</td><td>73.6/82.7</td><td>N/A</td></tr><tr><td>Dev set: QANet + data augmentation ×2</td><td>74.5 /83.2</td><td>N/A</td></tr><tr><td>Dev set: QANet + data augmentation ×3</td><td>75.1/ 83.8</td><td>N/A</td></tr><tr><td>Test set: QANet + data augmentation ×3</td><td>76.2 / 84.6</td><td>76.2/84.6</td></tr></table>",
+        "bbox": [
+            232,
+            102,
+            763,
+            459
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "LSTMs as is used in most existing models. Specifically, each (embedding and model) encoder block is replaced with a 1, 2, or 3 layer Bidirectional LSTMs respectively, as such layer numbers fall into the usual range of the reading comprehension models (Chen et al., 2017). All of these LSTMs have hidden size 128. The results of the speedup comparison are shown in Table 3. We can easily see that our model is significantly faster than all the RNN based models and the speedups range from 3 to 13 times in training and 4 to 9 times in inference. ",
+        "bbox": [
+            173,
+            522,
+            825,
+            607
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/25a07ce3aeb5cbce6630a8537c101c1a7b787cfdbabdb73a6bc54ceb49788693.jpg",
+        "table_caption": [
+            "Table 3: Speed comparison between our model and RNN-based models on SQuAD dataset, all with batch size 32. RNN- $x$ - $y$ indicates an RNN with $x$ layers each containing $y$ hidden units. Here, we use bidirectional LSTM as the RNN. The speed is measured by batches/second, so higher is faster. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>QANet</td><td>RNN-1-128</td><td>Speedup</td><td>RNN-2-128</td><td>Speedup</td><td>RNN-3-128 Speedup</td></tr><tr><td>Training</td><td>3.2</td><td>1.1</td><td>2.9x</td><td>0.34</td><td>9.4x</td><td>0.24 13.3x</td></tr><tr><td>Inference</td><td>8.1</td><td>2.2</td><td>3.7x</td><td>1.3</td><td>6.2x</td><td>0.92 8.8x</td></tr></table>",
+        "bbox": [
+            186,
+            626,
+            807,
+            667
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Speedup over BiDAF model. In addition, we also use the same hardware (a NVIDIA p100 GPU) and compare the training time of getting the same performance between our model and the BiDAF model14(Seo et al., 2016), a classic RNN-based model on SQuAD. We mostly adopt the default settings in the original code to get its best performance, where the batch sizes for training and inference are both 60. The only part we changed is the optimizer, where Adam with learning 0.001 is used here, as with Adadelta we got a bit worse performance. The result is shown in Table 4 which shows that our model is 4.3 and 7.0 times faster than BiDAF in training and inference speed. Besides, we only need one fifth of the training time to achieve BiDAF’s best F1 score (77.0) on dev set. ",
+        "bbox": [
+            174,
+            763,
+            825,
+            888
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/d29df3e7e13017656f5dd05e35c01ac857d6f633cfa713fe38cdc4fd88039907.jpg",
+        "table_caption": [
+            "Table 4: Speed comparison between our model and BiDAF (Seo et al., 2016) on SQuAD dataset. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>Train time to get 77.0 F1onDev set</td><td>Train speed</td><td>Inference speed</td></tr><tr><td>QANet</td><td>3hours</td><td>102 samples/s</td><td>259 samples/s</td></tr><tr><td>BiDAF</td><td>15 hours</td><td>24 samples/s</td><td>37samples/s</td></tr><tr><td>Speedup</td><td>5.0x</td><td>4.3x</td><td>7.0x</td></tr></table>",
+        "bbox": [
+            238,
+            101,
+            758,
+            156
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.1.3 ABALATION STUDY AND ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            213,
+            475,
+            227
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We conduct ablation studies on components of the proposed model, and investigate the effect of augmented data. The validation scores on the development set are shown in Table 5. As can be seen from the table, the use of convolutions in the encoders is crucial: both F1 and EM drop drastically by almost 3 percent if it is removed. Self-attention in the encoders is also a necessary component that contributes 1.4/1.3 gain of EM/F1 to the ultimate performance. We interpret these phenomena as follows: the convolutions capture the local structure of the context while the self-attention is able to model the global interactions between text. Hence they are complimentary to but cannot replace each other. The use of separable convolutions in lieu of tradition convolutions also has a prominent contribution to the performance, which can be seen by the slightly worse accuracy caused by replacing separable convolution with normal convolution. ",
+        "bbox": [
+            174,
+            237,
+            825,
+            376
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The Effect of Data Augmentation. We additionally perform experiments to understand the values of augmented data as their amount increases. As the last block of rows in the table shows, data augmentation proves to be helpful in further boosting performance. Making the training data twice as large by adding the En-Fr-En data only (ratio 1:1 between original training data and augmented data, as indicated by row “data augmentation $\\times 2$ (1:1:0)”) yields an increase in the F1 by 0.5 percent. While adding more augmented data with French as a pivot does not provide performance gain, injecting additional augmented data En-De-En of the same amount brings another 0.2 improvement in F1, as indicated in entry “data augmentation $\\times \\ 3$ (1:1:1)”. We may attribute this gain to the diversity of the new data, which is produced by the translator of the new language. ",
+        "bbox": [
+            173,
+            391,
+            825,
+            517
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The Effect of Sampling Scheme. Although injecting more data beyond $\\times \\ 3$ does not benefit the model, we observe that a good sampling ratio between the original and augmented data during training can further boost the model performance. In particular, when we increase the sampling weight of augmented data from (1:1:1) to (1:2:1), the EM/F1 performance drops by $0 . 5 / 0 . 3$ . We conjecture that it is due to the fact that augmented data is noisy because of the back-translation, so it should not be the dominant data of training. We confirm this point by increasing the ratio of the original data from (1:2:1) to (2:2:1), where $0 . 6 / 0 . 5$ performance gain on EM/F1 is obtained. Then we fix the portion of the augmented data, and search the sample weight of the original data. Empirically, the ratio (3:1:1) yields the best performance, with 1.5/1.1 gain over the base model on EM/F1. This is also the model we submitted for test set evaluation. ",
+        "bbox": [
+            174,
+            532,
+            825,
+            671
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.1.4 ROBUSTNESS STUDY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            686,
+            372,
+            700
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In the following, we conduct experiments on the adversarial SQuAD dataset (Jia & Liang, 2017) to study the robustness of the proposed model. In this dataset, one or more sentences are appended to the original SQuAD context of test set, to intentionally mislead the trained models to produce wrong answers. However, the model is agnostic to those adversarial examples during training. We focus on two types of misleading sentences, namely, AddSent and AddOneSent. AddSent generates sentences that are similar to the question, but not contradictory to the correct answer, while AddOneSent adds a random human-approved sentence that is not necessarily related to the context. ",
+        "bbox": [
+            174,
+            712,
+            825,
+            809
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The model in use is exactly the one trained with the original SQuAD data (the one getting 84.6 F1 on test set), but now it is submitted to the adversarial server for evaluation. The results are shown in Table 6, where the F1 scores of other models are all extracted from Jia & Liang (2017).15 Again, we only compare the performance of single models. From Table 6, we can see that our model is on par with the state-of-the-art model Mnemonic, while significantly better than other models by a large margin. The robustness of our model is probably because it is trained with augmented data. ",
+        "bbox": [
+            174,
+            815,
+            825,
+            900
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/bc927b735cba47d5ee3de224a26980dc3ddab48f3da46f97c723935bc37ba321.jpg",
+        "table_caption": [
+            "Table 5: An ablation study of data augmentation and other aspects of our model. The reported results are obtained on the development set. For rows containing entry “data augmentation”, $^ { 6 6 } \\times N ^ { \\prime }$ means the data is enhanced to $N$ times as large as the original size, while the ratio in the bracket indicates the sampling ratio among the original, English-French-English and English-German-English data during training. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"2\"></td><td>EM/F1</td><td>Differenceto Base Model EM/F1</td></tr><tr><td colspan=\"2\">Base QANet</td><td>73.6/82.7</td><td></td></tr><tr><td rowspan=\"3\"></td><td>- convolution in encoders</td><td>70.8/ 80.0</td><td>-2.8/-2.7</td></tr><tr><td>- self-attention in encoders</td><td>72.2 /81.4</td><td>-1.4 / -1.3</td></tr><tr><td>replace sep convolution with normal convolution</td><td>72.9 / 82.0</td><td>- 0.7/-0.7</td></tr><tr><td></td><td>+ data augmentation ×2 (1:1:0)</td><td>74.5/83.2</td><td>+0.9/+0.5</td></tr><tr><td></td><td>+ data augmentation ×3 (1:1:1)</td><td>74.8 /83.4</td><td>+1.2/+0.7</td></tr><tr><td></td><td>+ data augmentation ×3 (1:2:1)</td><td>74.3/83.1</td><td>+0.7 /+0.4</td></tr><tr><td></td><td>+ data augmentation ×3 (2:2:1)</td><td>74.9 / 83.6</td><td>+1.3/+0.9</td></tr><tr><td></td><td>+ data augmentation ×3 (2:1:1)</td><td>75.0 / 83.6</td><td>+1.4 /+0.9</td></tr><tr><td></td><td>+ data augmentation ×3 (3:1:1)</td><td>75.1/83.8</td><td>+1.5 / +1.1</td></tr><tr><td></td><td>+ data augmentation ×3 (4:1:1)</td><td>75.0 / 83.6</td><td>+1.4/ +0.9</td></tr><tr><td>+ data augmentation ×3 (5:1:1)</td><td></td><td>74.9 / 83.5</td><td>+1.3 /+0.8</td></tr></table>",
+        "bbox": [
+            178,
+            99,
+            818,
+            282
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "table",
+        "img_path": "images/1a768742b8680b8297a08caa97202881c15308d56b48441086d4b47dad653923.jpg",
+        "table_caption": [
+            "The injected noise in the training data might not only improve the generalization of the model but also make it robust to the adversarial sentences. ",
+            "Table 6: The F1 scores on the adversarial SQuAD test set. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Single Model</td><td>AddSent</td><td>AddOneSent</td></tr><tr><td>Logistic (Rajpurkar et al.,2016)</td><td>23.2</td><td>30.4</td></tr><tr><td>Match (Wang &amp; Jiang,2016)</td><td>27.3</td><td>39.0</td></tr><tr><td>SEDT (Liu et al., 2017a)</td><td>33.9</td><td>44.8</td></tr><tr><td>DCR (Yu et al., 2016)</td><td>37.8</td><td>45.1</td></tr><tr><td>BiDAF (Seo et al., 2016)</td><td>34.3</td><td>45.7</td></tr><tr><td>jNet (Zhang et al.,2017)</td><td>37.9</td><td>47.0</td></tr><tr><td>Ruminating (Gong &amp; Bowman, 2017)</td><td>37.4</td><td>47.7</td></tr><tr><td>RaSOR (Lee et al., 2016)</td><td>39.5</td><td>49.5</td></tr><tr><td>MPCM (Wang et al.,2016)</td><td>40.3</td><td>50.0</td></tr><tr><td>ReasoNet (Shen et al.,2017b)</td><td>39.4</td><td>50.3</td></tr><tr><td>Mnemonic (Hu et al.,2017)</td><td>46.6</td><td>56.0</td></tr><tr><td>QANet</td><td>45.2</td><td>55.7</td></tr></table>",
+        "bbox": [
+            290,
+            433,
+            705,
+            602
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "4.2 EXPERIMENTS ON TRIVIAQA ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            660,
+            418,
+            675
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this section, we test our model on another dataset TriviaQA (Joshi et al., 2017), which consists of 650K context-query-answer triples. There are 95K distinct question-answer pairs, which are authored by Trivia enthusiasts, with 6 evidence documents (context) per question on average, which are either crawled from Wikipedia or Web search. Compared to SQuAD, TriviaQA is more challenging in that: 1) its examples have much longer context (2895 tokens per context on average) and may contain several paragraphs, 2) it is much noisier than SQuAD due to the lack of human labeling, 3) it is possible that the context is not related to the answer at all, as it is crawled by key words. ",
+        "bbox": [
+            174,
+            686,
+            825,
+            784
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we focus on testing our model on the subset consisting of answers from Wikipedia. According to the previous work (Joshi et al., 2017; Hu et al., 2017; Pan et al., 2017), the same model would have similar performance on both Wikipedia and Web, but the latter is five time larger. To keep the training time manageable, we omit the experiment on Web data. ",
+        "bbox": [
+            174,
+            791,
+            825,
+            847
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Due to the multi-paragraph nature of the context, researchers also find that simple hierarchical or multi-step reading tricks, such as first predicting which paragraph to read and then apply models like BiDAF to pinpoint the answer within that paragraph (Clark & Gardner, 2017), can significantly boost the performance on TriviaQA. However, in this paper, we focus on comparing with the single-paragraph reading baselines only. We believe that our model can be plugged into other multi-paragraph reading methods to achieve the similar or better performance, but it is out of the scope of this paper. ",
+        "bbox": [
+            174,
+            854,
+            823,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "The Wikipedia sub-dataset contains around 92K training and 11K development examples. The average context and question lengths are 495 and 15 respectively. In addition to the full development set, the authors of Joshi et al. (2017) also pick a verified subset that all the contexts inside can answer the associated questions. As the text could be long, we adopt the data processing similar to Hu et al. (2017); Joshi et al. (2017). In particular, for training and validation, we randomly select a window of length 256 and 400 encapsulating the answer respectively. All the remaining setting are the same as SQuAD experiment, except that the training steps are set to 120K. ",
+        "bbox": [
+            174,
+            138,
+            825,
+            236
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Accuracy. The accuracy performance on the development set is shown in Table 7. Again, we can see that our model outperforms the baselines in terms of F1 and EM on Full development set, and is on par with the state-of-the-art on the Verified dev set. ",
+        "bbox": [
+            174,
+            252,
+            821,
+            295
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "table",
+        "img_path": "images/f7d10a8a64ad85797a53ad44f4b8aa0073331e222021e5c5e9224515469e648c.jpg",
+        "table_caption": [
+            "Table 7: The development set performances of different single-paragraph reading models on the Wikipedia domain of TriviaQA dataset. Note that ∗ indicates the result on test set. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>Full</td><td>Verified</td></tr><tr><td>Single Model</td><td>EM/F1</td><td>EM/F1</td></tr><tr><td>Random (Joshi et al.,2017)</td><td>12.7 /22.5</td><td>13.8/23.4</td></tr><tr><td>Classifier (Joshi et al., 2017)</td><td>23.4 / 27.7</td><td>23.6 /27.9</td></tr><tr><td>BiDAF (Seo et al., 2016)</td><td>40.3/45.7</td><td>46.5 /52.8</td></tr><tr><td>MEMEN (Pan et al.,2017)</td><td>43.2/46.9</td><td>49.3 / 55.8</td></tr><tr><td>M-Reader (Hu et al., 2017)*</td><td>46.9/ 52.9*</td><td>54.5/ 59.5*</td></tr><tr><td>QANet</td><td>51.1/ 56.6</td><td>53.3/59.2</td></tr></table>",
+        "bbox": [
+            316,
+            308,
+            679,
+            414
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "table",
+        "img_path": "images/8ce95fcc9e4a5663a753ef2f3dd783933ac2ddce830d17f0930a389c364e10dd.jpg",
+        "table_caption": [
+            "Speedup over RNNs. In addition to accuracy, we also benchmark the speed of our model against the RNN counterparts. As Table 8 shows, not surprisingly, our model has 3 to 11 times speedup in training and 3 to 9 times acceleration in inference, similar to the finding in SQuAD dataset. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>QANet</td><td>RNN-1-128</td><td>Speedup</td><td>RNN-2-128</td><td>Speedup</td><td>RNN-3-128</td><td>Speedup</td></tr><tr><td>Training</td><td>1.8</td><td>0.41</td><td>4.4x</td><td>0.20</td><td>9.0x</td><td>0.11</td><td>16.4x</td></tr><tr><td>Inference</td><td>3.2</td><td>0.89</td><td>3.6x</td><td>0.47</td><td>6.8x</td><td>0.26</td><td>12.3x</td></tr></table>",
+        "bbox": [
+            186,
+            539,
+            808,
+            580
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Table 8: Speed comparison between the proposed model and RNN-based models on TriviaQA Wikipedia dataset, all with batch size 32. RNN- $x$ - $y$ indicates an RNN with $x$ layers each containing $y$ hidden units. The RNNs used here are bidirectional LSTM. The processing speed is measured by batches/second, so higher is faster. ",
+        "bbox": [
+            173,
+            597,
+            825,
+            654
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "5 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            689,
+            344,
+            705
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Machine reading comprehension and automated question answering has become an important topic in the NLP domain. Their popularity can be attributed to an increase in publicly available annotated datasets, such as SQuAD (Rajpurkar et al., 2016), TriviaQA (Joshi et al., 2017), CNN/Daily News (Hermann et al., 2015), WikiReading (Hewlett et al., 2016), Children Book Test (Hill et al., 2015), etc. A great number of end-to-end neural network models have been proposed to tackle these challenges, including BiDAF (Seo et al., 2016), r-net (Wang et al., 2017), DCN (Xiong et al., 2016), ReasoNet (Shen et al., 2017b), Document Reader (Chen et al., 2017), Interactive AoA Reader (Cui et al., 2017) and Reinforced Mnemonic Reader (Hu et al., 2017). ",
+        "bbox": [
+            173,
+            722,
+            825,
+            833
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Recurrent Neural Networks (RNNs) have featured predominatnly in Natural Language Processing in the past few years. The sequential nature of the text coincides with the design philosophy of RNNs, and hence their popularity. In fact, all the reading comprehension models mentioned above are based on RNNs. Despite being common, the sequential nature of RNN prevent parallel computation, as tokens must be fed into the RNN in order. Another drawback of RNNs is difficulty modeling long dependencies, although this is somewhat alleviated by the use of Gated Recurrent Unit (Chung et al., ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "2014) or Long Short Term Memory architectures (Hochreiter & Schmidhuber, 1997). For simple tasks such as text classification, with reinforcement learning techniques, models (Yu et al., 2017) have been proposed to skip irrelevant tokens to both further address the long dependencies issue and speed up the procedure. However, it is not clear if such methods can handle complicated tasks such as Q&A. The reading comprehension task considered in this paper always needs to deal with long text, as the context paragraphs may be hundreds of words long. Recently, attempts have been made to replace the recurrent networks by full convolution or full attention architectures (Kim, 2014; Gehring et al., 2017; Vaswani et al., 2017b; Shen et al., 2017a). Those models have been shown to be not only faster than the RNN architectures, but also effective in other tasks, such as text classification, machine translation or sentiment analysis. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            242
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "To the best of our knowledge, our paper is the first work to achieve both fast and accurate reading comprehension model, by discarding the recurrent networks in favor of feed forward architectures. Our paper is also the first to mix self-attention and convolutions, which proves to be empirically effective and achieves a significant gain of 2.7 F1. Note that Raiman & Miller (2017) recently proposed to accelerate reading comprehension by avoiding bi-directional attention and making computation conditional on the search beams. Nevertheless, their model is still based on the RNNs and the accuracy is not competitive, with an $\\mathrm { E M } 6 8 . 4$ and F1 76.2. Weissenborn et al. (2017) also tried to build a fast Q&A model by deleting the context-query attention module. However, it again relied on RNN and is thus intrinsically slower than ours. The elimination of attention further has sacrificed the performance (with EM 68.4 and F1 77.1). ",
+        "bbox": [
+            174,
+            250,
+            823,
+            388
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Data augmentation has also been explored in natural language processing. For example, Zhang et al. (2015) proposed to enhance the dataset by replacing the words with their synonyms and showed its effectiveness in text classification. Raiman & Miller (2017) suggested using type swap to augment the $\\mathrm { S Q u A D }$ dataset, which essentially replaces the words in the original paragraph with others with the same type. While it was shown to improve the accuracy, the augmented data has the same syntactic structure as the original data, so they are not sufficiently diverse. Zhou et al. (2017) improved the diversity of the SQuAD data by generating more questions. However, as reported by Wang et al. (2017), their method did not help improve the performance. The data augmentation technique proposed in this paper is based on paraphrasing the sentences by translating the original text back and forth. The major benefit is that it can bring more syntactical diversity to the enhanced data. ",
+        "bbox": [
+            174,
+            395,
+            825,
+            535
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            555,
+            318,
+            571
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we propose a fast and accurate end-to-end model, QANet, for machine reading comprehension. Our core innovation is to completely remove the recurrent networks in the encoder. The resulting model is fully feedforward, composed entirely of separable convolutions, attention, linear layers, and layer normalization, which is suitable for parallel computation. The resulting model is both fast and accurate: It surpasses the best published results on SQuAD dataset while up to 13/9 times faster than a competitive recurrent models for a training/inference iteration. Additionally, we find that we are able to achieve significant gains by utilizing data augmentation consisting of translating context and passage pairs to and from another language as a way of paraphrasing the questions and contexts. ",
+        "bbox": [
+            174,
+            588,
+            825,
+            713
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGEMENT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            734,
+            356,
+            750
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Adams Wei Yu is supported by NVIDIA PhD Fellowship and CMU Presidential Fellowship. We would like to thank Samy Bengio, Lei Huang, Minjoon Seo, Noam Shazeer, Ashish Vaswani, Barret Zoph and the Google Brain Team for helpful discussions. ",
+        "bbox": [
+            174,
+            765,
+            823,
+            808
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            830,
+            285,
+            844
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Mart´ın Abadi, Ashish Agarwal, Paul Barham, Eugene Brevdo, Zhifeng Chen, Craig Citro, Gregory S. Corrado, Andy Davis, Jeffrey Dean, Matthieu Devin, Sanjay Ghemawat, Ian J. Goodfellow, Andrew Harp, Geoffrey Irving, Michael Isard, Yangqing Jia, Rafal Jozefowicz, Lukasz ´ Kaiser, Manjunath Kudlur, Josh Levenberg, Dan Mane, Rajat Monga, Sherry Moore, Derek Gor- ´ don Murray, Chris Olah, Mike Schuster, Jonathon Shlens, Benoit Steiner, Ilya Sutskever, Kunal ",
+        "bbox": [
+            176,
+            854,
+            823,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Talwar, Paul A. Tucker, Vincent Vanhoucke, Vijay Vasudevan, Fernanda B. Viegas, Oriol Vinyals, ´ Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, and Xiaoqiang Zheng. Tensorflow: Large-scale machine learning on heterogeneous distributed systems. CoRR, abs/1603.04467, 2016. URL http://arxiv.org/abs/1603.04467. ",
+        "bbox": [
+            189,
+            103,
+            825,
+            160
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Lei Jimmy Ba, Ryan Kiros, and Geoffrey E. Hinton. Layer normalization. CoRR, abs/1607.06450, 2016. URL http://arxiv.org/abs/1607.06450. ",
+        "bbox": [
+            171,
+            167,
+            823,
+            196
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. In International Conference on Learning Representations, 2015. ",
+        "bbox": [
+            174,
+            205,
+            823,
+            234
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Danqi Chen, Adam Fisch, Jason Weston, and Antoine Bordes. Reading wikipedia to answer opendomain questions. In Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics, ACL 2017, Vancouver, Canada, July 30 - August 4, Volume 1: Long Papers, pp. 1870–1879, 2017. ",
+        "bbox": [
+            173,
+            243,
+            825,
+            299
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Franc¸ois Chollet. Xception: Deep learning with depthwise separable convolutions. CoRR, abs/1610.02357, 2016. URL http://arxiv.org/abs/1610.02357. ",
+        "bbox": [
+            173,
+            308,
+            821,
+            338
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "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": [
+            171,
+            344,
+            821,
+            375
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Christopher Clark and Matt Gardner. Simple and effective multi-paragraph reading comprehension. CoRR, abs/1710.10723, 2017. URL http://arxiv.org/abs/1710.10723. ",
+        "bbox": [
+            174,
+            382,
+            821,
+            412
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Yiming Cui, Zhipeng Chen, Si Wei, Shijin Wang, Ting Liu, and Guoping Hu. Attention-overattention neural networks for reading comprehension. In Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics, ACL 2017, Vancouver, Canada, July 30 - August 4, Volume 1: Long Papers, pp. 593–602, 2017. ",
+        "bbox": [
+            174,
+            420,
+            825,
+            477
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Li Dong, Jonathan Mallinson, Siva Reddy, and Mirella Lapata. Learning to paraphrase for question answering. In Proceedings of the 2017 Conference on Empirical Methods in Natural Language Processing, pp. 875–886. Association for Computational Linguistics, 2017. URL http://aclweb.org/anthology/D17-1091. ",
+        "bbox": [
+            173,
+            486,
+            825,
+            542
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Jonas Gehring, Michael Auli, David Grangier, Denis Yarats, and Yann N Dauphin. Convolutional sequence to sequence learning. In International Conference on Machine Learning, 2017. ",
+        "bbox": [
+            171,
+            550,
+            821,
+            579
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Yichen Gong and Samuel R. Bowman. Ruminating reader: Reasoning with gated multi-hop attention. CoRR, abs/1704.07415, 2017. URL http://arxiv.org/abs/1704.07415. ",
+        "bbox": [
+            173,
+            588,
+            823,
+            617
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Karl Moritz Hermann, Tomas Kocisk ´ y, Edward Grefenstette, Lasse Espeholt, Will Kay, Mustafa ´ Suleyman, and Phil Blunsom. Teaching machines to read and comprehend. In Advances in Neural Information Processing Systems 28: Annual Conference on Neural Information Processing Systems 2015, December 7-12, 2015, Montreal, Quebec, Canada, pp. 1693–1701, 2015. ",
+        "bbox": [
+            173,
+            625,
+            825,
+            681
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Daniel Hewlett, Alexandre Lacoste, Llion Jones, Illia Polosukhin, Andrew Fandrianto, Jay Han, Matthew Kelcey, and David Berthelot. Wikireading: A novel large-scale language understanding task over wikipedia. In Proceedings of the 54th Annual Meeting of the Association for Computational Linguistics, ACL 2016, August 7-12, 2016, Berlin, Germany, Volume 1: Long Papers, 2016. ",
+        "bbox": [
+            173,
+            689,
+            825,
+            760
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Felix Hill, Antoine Bordes, Sumit Chopra, and Jason Weston. The goldilocks principle: Reading children’s books with explicit memory representations. CoRR, abs/1511.02301, 2015. ",
+        "bbox": [
+            171,
+            768,
+            821,
+            797
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural computation, 9(8): 1735–1780, 1997. ",
+        "bbox": [
+            171,
+            806,
+            823,
+            835
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Minghao Hu, Yuxing Peng, and Xipeng Qiu. Reinforced mnemonic reader for machine comprehension. CoRR, abs/1705.02798, 2017. URL http://arxiv.org/abs/1705.02798. ",
+        "bbox": [
+            173,
+            843,
+            823,
+            873
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Gao Huang, Yu Sun, Zhuang Liu, Daniel Sedra, and Kilian Q. Weinberger. Deep networks with stochastic depth. In Computer Vision - ECCV 2016 - 14th European Conference, Amsterdam, The Netherlands, October 11-14, 2016, Proceedings, Part IV, pp. 646–661, 2016. ",
+        "bbox": [
+            174,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Robin Jia and Percy Liang. Adversarial examples for evaluating reading comprehension systems. In Proceedings of the 2017 Conference on Empirical Methods in Natural Language Processing, EMNLP 2017, Copenhagen, Denmark, September 9-11, 2017, pp. 2021–2031, 2017. ",
+        "bbox": [
+            178,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Mandar Joshi, Eunsol Choi, Daniel S. Weld, and Luke Zettlemoyer. Triviaqa: A large scale distantly supervised challenge dataset for reading comprehension. In Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics, ACL 2017, Vancouver, Canada, July 30 - August 4, Volume 1: Long Papers, pp. 1601–1611, 2017. ",
+        "bbox": [
+            173,
+            156,
+            825,
+            214
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Lukasz Kaiser, Aidan N Gomez, and Francois Chollet. Depthwise separable convolutions for neural machine translation. arXiv preprint arXiv:1706.03059, 2017. ",
+        "bbox": [
+            171,
+            224,
+            823,
+            253
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Yoon Kim. Convolutional neural networks for sentence classification. In Proceedings of the 2014 Conference on Empirical Methods in Natural Language Processing, EMNLP 2014, October 25- 29, 2014, Doha, Qatar, A meeting of SIGDAT, a Special Interest Group of the ACL, pp. 1746– 1751, 2014. ",
+        "bbox": [
+            173,
+            265,
+            826,
+            320
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. CoRR, abs/1412.6980, 2014. URL http://arxiv.org/abs/1412.6980. ",
+        "bbox": [
+            173,
+            332,
+            823,
+            361
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Kenton Lee, Tom Kwiatkowski, Ankur P. Parikh, and Dipanjan Das. Learning recurrent span representations for extractive question answering. CoRR, abs/1611.01436, 2016. ",
+        "bbox": [
+            173,
+            371,
+            823,
+            401
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Rui Liu, Junjie Hu, Wei Wei, Zi Yang, and Eric Nyberg. Structural embedding of syntactic trees for machine comprehension. In Proceedings of the 2017 Conference on Empirical Methods in Natural Language Processing, EMNLP 2017, Copenhagen, Denmark, September 9-11, 2017, pp. 826–835, 2017a. ",
+        "bbox": [
+            173,
+            411,
+            825,
+            468
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Xiaodong Liu, Yelong Shen, Kevin Duh, and Jianfeng Gao. Stochastic answer networks for machine reading comprehension. CoRR, abs/1712.03556, 2017b. URL http://arxiv.org/abs/ 1712.03556. ",
+        "bbox": [
+            173,
+            479,
+            823,
+            522
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Minh-Thang Luong, Hieu Pham, and Christopher D. Manning. Effective approaches to attentionbased neural machine translation. In EMNLP, 2015. ",
+        "bbox": [
+            173,
+            532,
+            821,
+            561
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Minh-Thang Luong, Eugene Brevdo, and Rui Zhao. Neural machine translation (seq2seq) tutorial. https://github.com/tensorflow/nmt, 2017. ",
+        "bbox": [
+            173,
+            571,
+            823,
+            602
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Jonathan Mallinson, Rico Sennrich, and Mirella Lapata. Paraphrasing revisited with neural machine translation. In Proceedings of the 15th Conference of the European Chapter of the Association for Computational Linguistics: Volume 1, Long Papers, pp. 881–893. Association for Computational Linguistics, 2017. URL http://aclweb.org/anthology/E17-1083. ",
+        "bbox": [
+            174,
+            612,
+            825,
+            670
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Boyuan Pan, Hao Li, Zhou Zhao, Bin Cao, Deng Cai, and Xiaofei He. MEMEN: multi-layer embedding with memory networks for machine comprehension. CoRR, abs/1707.09098, 2017. ",
+        "bbox": [
+            169,
+            679,
+            823,
+            709
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Jeffrey Pennington, Richard Socher, and Christopher D. Manning. Glove: Global vectors for word//w representation. In Empirical Methods in Natural Language Processing (EMNLP), pp. 1532–1543, 2014. URL http://www.aclweb.org/anthology/D14-1162. ",
+        "bbox": [
+            173,
+            719,
+            825,
+            763
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Jonathan Raiman and John Miller. Globally normalized reader. In Proceedings of the 2017 Conference on Empirical Methods in Natural Language Processing, EMNLP 2017, Copenhagen, Denmark, September 9-11, 2017, pp. 1070–1080, 2017. ",
+        "bbox": [
+            173,
+            773,
+            825,
+            816
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Pranav Rajpurkar, Jian Zhang, Konstantin Lopyrev, and Percy Liang. Squad: 100, $0 0 0 +$ questions for machine comprehension of text. In Proceedings of the 2016 Conference on Empirical Methods in Natural Language Processing, EMNLP 2016, Austin, Texas, USA, November 1-4, 2016, pp. 2383–2392, 2016. ",
+        "bbox": [
+            173,
+            827,
+            825,
+            883
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Rico Sennrich, Barry Haddow, and Alexandra Birch. Improving neural machine translation models with monolingual data. In ACL (1). The Association for Computer Linguistics, 2016. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Min Joon Seo, Aniruddha Kembhavi, Ali Farhadi, and Hannaneh Hajishirzi. Bidirectional attention flow for machine comprehension. CoRR, abs/1611.01603, 2016. URL http://arxiv.org/ abs/1611.01603. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Tao Shen, Tianyi Zhou, Guodong Long, Jing Jiang, Shirui Pan, and Chengqi Zhang. Disan: Directional self-attention network for rnn/cnn-free language understanding. CoRR, abs/1709.04696, 2017a. URL http://arxiv.org/abs/1709.04696. ",
+        "bbox": [
+            174,
+            156,
+            826,
+            199
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Yelong Shen, Po-Sen Huang, Jianfeng Gao, and Weizhu Chen. Reasonet: Learning to stop reading in machine comprehension. In Proceedings of the 23rd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, Halifax, NS, Canada, August 13 - 17, 2017, pp. 1047–1055, 2017b. ",
+        "bbox": [
+            174,
+            208,
+            825,
+            265
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Rupesh Kumar Srivastava, Klaus Greff, and Jurgen Schmidhuber. Highway networks. ¨ CoRR, abs/1505.00387, 2015. URL http://arxiv.org/abs/1505.00387. ",
+        "bbox": [
+            171,
+            275,
+            823,
+            304
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Lukasz Kaiser, and Illia Polosukhin. Attention is all you need. CoRR, abs/1706.03762, 2017a. URL http://arxiv.org/abs/1706.03762. ",
+        "bbox": [
+            174,
+            314,
+            823,
+            357
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Lukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Neural Information Processing Systems, 2017b. ",
+        "bbox": [
+            173,
+            366,
+            825,
+            409
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Shuohang Wang and Jing Jiang. Machine comprehension using match-lstm and answer pointer. CoRR, abs/1608.07905, 2016. URL http://arxiv.org/abs/1608.07905. ",
+        "bbox": [
+            173,
+            419,
+            823,
+            448
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Wenhui Wang, Nan Yang, Furu Wei, Baobao Chang, and Ming Zhou. Gated self-matching networks for reading comprehension and question answering. In Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics, ACL 2017, Vancouver, Canada, July 30 - August 4, Volume 1: Long Papers, pp. 189–198, 2017. ",
+        "bbox": [
+            174,
+            457,
+            826,
+            515
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Zhiguo Wang, Haitao Mi, Wael Hamza, and Radu Florian. Multi-perspective context matching for machine comprehension. CoRR, abs/1612.04211, 2016. URL http://arxiv.org/abs/ 1612.04211. ",
+        "bbox": [
+            173,
+            523,
+            826,
+            566
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Dirk Weissenborn, Georg Wiese, and Laura Seiffe. Making neural QA as simple as possible but not simpler. In Proceedings of the 21st Conference on Computational Natural Language Learning (CoNLL 2017), Vancouver, Canada, August 3-4, 2017, pp. 271–280, 2017. ",
+        "bbox": [
+            176,
+            577,
+            821,
+            619
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "John Wieting, Jonathan Mallinson, and Kevin Gimpel. Learning paraphrastic sentence embeddings from back-translated bitext. In EMNLP, pp. 274–285. Association for Computational Linguistics, 2017. ",
+        "bbox": [
+            174,
+            628,
+            823,
+            671
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Yonghui Wu, Mike Schuster, Zhifeng Chen, Quoc V. Le, Mohammad Norouzi, Wolfgang Macherey, Maxim Krikun, Yuan Cao, Qin Gao, Klaus Macherey, Jeff Klingner, Apurva Shah, Melvin Johnson, Xiaobing Liu, Lukasz Kaiser, Stephan Gouws, Yoshikiyo Kato, Taku Kudo, Hideto Kazawa, Keith Stevens, George Kurian, Nishant Patil, Wei Wang, Cliff Young, Jason Smith, Jason Riesa, Alex Rudnick, Oriol Vinyals, Greg Corrado, Macduff Hughes, and Jeffrey Dean. Google’s neural machine translation system: Bridging the gap between human and machine translation. arXiv preprint arXiv:1609.08144, 2016. ",
+        "bbox": [
+            174,
+            681,
+            825,
+            780
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Caiming Xiong, Victor Zhong, and Richard Socher. Dynamic coattention networks for question answering. CoRR, abs/1611.01604, 2016. URL http://arxiv.org/abs/1611.01604. ",
+        "bbox": [
+            169,
+            790,
+            823,
+            819
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Adams Wei Yu, Hongrae Lee, and Quoc V. Le. Learning to skim text. In Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics, ACL 2017, Vancouver, Canada, July 30 - August 4, Volume 1: Long Papers, pp. 1880–1890, 2017. ",
+        "bbox": [
+            173,
+            829,
+            823,
+            872
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Yang Yu, Wei Zhang, Kazi Saidul Hasan, Mo Yu, Bing Xiang, and Bowen Zhou. End-to-end reading comprehension with dynamic answer chunk ranking. CoRR, abs/1610.09996, 2016. URL http: //arxiv.org/abs/1610.09996. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Junbei Zhang, Xiao-Dan Zhu, Qian Chen, Li-Rong Dai, Si Wei, and Hui Jiang. Exploring question understanding and adaptation in neural-network-based question answering. CoRR, abs/1703.04617, 2017. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            145
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Xiang Zhang, Junbo Jake Zhao, and Yann LeCun. Character-level convolutional networks for text classification. In Advances in Neural Information Processing Systems 28: Annual Conference on Neural Information Processing Systems 2015, December 7-12, 2015, Montreal, Quebec, Canada, pp. 649–657, 2015. ",
+        "bbox": [
+            174,
+            155,
+            825,
+            212
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Qingyu Zhou, Nan Yang, Furu Wei, Chuanqi Tan, Hangbo Bao, and Ming Zhou. Neural question generation from text: A preliminary study. CoRR, abs/1704.01792, 2017. URL http: //arxiv.org/abs/1704.01792. ",
+        "bbox": [
+            174,
+            220,
+            825,
+            262
+        ],
+        "page_idx": 15
+    }
+]

parse/train/B1edvs05Y7/B1edvs05Y7.md

@@ -0,0 +1,359 @@
+# SPARSE BINARY COMPRESSION: TOWARDS DISTRIBUTED DEEP LEARNING WITH MINIMAL COMMUNICATION
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Currently, progressively larger deep neural networks are trained on ever growing data corpora. In result, distributed training schemes are becoming increasingly relevant. A major issue in distributed training is the limited communication bandwidth between contributing nodes or prohibitive communication cost in general. To mitigate this problem we propose Sparse Binary Compression (SBC), a compression framework that allows for a drastic reduction of communication cost for distributed training. SBC combines existing techniques of communication delay and gradient sparsification with a novel binarization method and optimal weight update encoding to push compression gains to new limits. By doing so, our method also allows us to smoothly trade-off gradient sparsity and temporal sparsity to adapt to the requirements of the learning task. Our experiments show, that SBC can reduce the upstream communication on a variety of convolutional and recurrent neural network architectures by more than four orders of magnitude without significantly harming the convergence speed in terms of forward-backward passes. For instance, we can train ResNet50 on ImageNet in the same number of iterations to the baseline accuracy, using $\times 3 5 3 1$ less bits or train it to a $1 \%$ lower accuracy using $\times 3 7 2 0 8$ less bits. In the latter case, the total upstream communication required is cut from 125 terabytes to 3.35 gigabytes for every participating client. Our method also achieves state-of-the-art compression rates in a Federated Learning setting with 400 clients.
+
+# 1 INTRODUCTION
+
+Distributed Stochastic Gradient Descent (DSGD) is a training setting, in which a number of clients jointly trains a deep learning model using stochastic gradient descent (Dean et al., 2012; Recht et al., 2011; Moritz et al., 2015). Every client holds an individual subset of the training data, used to improve the current master model. The improvement is obtained by investing computational resources to perform iterations of stochastic gradient descent (SGD). This local training produces a weight update $\Delta { \boldsymbol { \nu } } _ { }$ in every participating client, which in regular or irregular intervals ("communication rounds") is exchanged to produce a new master model. This exchange of weight updates can be performed indirectly via a centralized server or directly in an all-reduce operation. In both cases, all clients share the same master model after every communication round (see figure 1). In vanilla DSGD the clients have to communicate a full gradient update during every iteration. Every such update is of the same size as the full model, which can be in the range of gigabytes for modern architectures with millions of parameters (He et al., 2016; Huang et al., 2017). Over the course of multiple hundred thousands of training iterations on big datasets the total communication for every client can easily grow to more than a petabyte. Consequently, if communication bandwidth is limited, or communication is costly, distributed deep learning can become unproductive or even unfeasible. DSGD is a very popular training setting with many applications. On one end of the spectrum, DSGD can be used to greatly reduce the training time of large-scale deep learning models by introducing device-level data parallelism (Chilimbi et al., 2014; Zinkevich et al., 2010; Xing et al., 2015; Li et al., 2014), making use of the fact that the computation of a mini-batch gradient is perfectly parallelizable. In this setting, the clients are usually embodied by hardwired high-performance computation units (i.e. GPUs in a cluster) and every client performs one iteration of SGD per communication round. Since communication is high-frequent in this setting, bandwidth can be a significant bottleneck. On the other end of the spectrum DSGD can also be used to enable privacy-preserving deep learning (Shokri & Shmatikov, 2015; McMahan et al., 2016). Since the clients only ever share weight updates, DSGD makes it possible to train a model from the combined data of all clients without any individual client having to reveal their local training data to a centralized server. In this setting the clients typically are embedded or mobile devices with low network bandwidth, intermittent network connections, and an expensive mobile data plan. In both scenarios, the communication cost between the individual training nodes is a limiting factor for the performance of the whole learning system. For the synchronous distributed training scheme described above, the total amount of bits communicated by every client during training is given by
+
+![](images/bbfd0bb297fd001cc86bbc18d700f0530cf52fa5b998b8a1e2263f9564a97595.jpg)  
+Figure 1: One communication round of DSGD: a) Clients synchronize with the server. b) Clients compute a weight update independently based on their local data. c) Clients upload their local weight updates to the server, where they are averaged to produce the new master model.
+
+$$
+\begin{array} { r } { \mathsf { b } _ { t o t a l } \in \mathcal { O } ( \underbrace { N _ { i t e r } \times f } _ { \# \mathrm { c o m m u n i c a t i o n ~ r o u n d s } } \times \underbrace { | \Delta \mathcal { W } _ { \neq 0 } | \times ( \bar { \mathrm { b } } _ { p o s } + \bar { \mathrm { b } } _ { v a l } ) } _ { \# \mathrm { b i t s ~ p e r ~ c o m m u n i c a t i o n } } \times \underbrace { K } _ { \# \mathrm { r e c e i v i n g ~ n o d e s } } ) } \end{array}
+$$
+
+where $N _ { i t e r }$ is the total number of training iterations (forward-backward passes) every client performs, $f$ is the communication frequency, $| \mathcal { W } _ { \neq 0 } |$ is the sparsity of the weight update, $\bar { \mathrm { b } } _ { p o s }$ , $\bar { \mathrm { b } } _ { v a l }$ are the average number of bits required to communicate the position and the value of the non-zero elements respectively and $K$ is the number of receiving nodes (if $\mathcal { W }$ is dense, the positions of all weights are predetermined and no position bits are required).
+
+Substantial research has gone into the effort of reducing the amount of communication necessary between the clients via lossy compression schemes. Using the systematic of equation 1, we can organize prior approaches into three different groups:
+
+Sparsification methods restrict weight updates to modifying only a small subset of the parameters, thus reducing $| \Delta \mathcal { W } _ { \neq 0 } |$ . Strom (2015) presents an approach (later modified by Tsuzuku et al. (2018)) in which only gradients with a magnitude greater than a certain predefined threshold are sent to the server. All other gradients are aggregated into a residual. This method achieves compression rates of up to 3 orders of magnitude on an acoustic modeling task. In practice however, it is hard to choose appropriate values for the threshold, as it may vary a lot for different architectures and even different layers. Instead of using a fixed threshold to decide what gradient entries to send, Aji & Heafield (2017) use a fixed sparsity rate. They only communicate the fraction $p$ entries of the gradient with the biggest magnitude, while also collecting all other gradients in a residual. At a sparsity rate of $p = 0 . 0 0 1$ their method slightly degrades the convergence speed and final accuracy of the trained model. Lin et al. (2017) present modifications to the work of Aji et al. which close this performance gap. These modifications include using a curriculum to slowly increase the amount of sparsity in the first couple communication rounds and applying momentum factor masking to overcome the problem of gradient staleness. Their method achieves compression rates ranging from $\times 2 7 0$ to $\times 6 0 0$ on different architectures, without slowdown in convergence speed.
+
+Communication delay methods try to reduce the communication frequency $f$ . McMahan et al. (2016) propose Federated Averaging to reduce the cumulative communication. In Federated Averaging, instead of communicating after every iteration, every client performs multiple iterations of SGD to compute a weight update. The authors observe that this delay of communication does not significantly harm the convergence speed in terms of local iterations and report a reduction in the number of necessary communication rounds by a factor of $\times 1 0 - \times 1 0 0$ on different convolutional and recurrent neural network architectures. In a follow-up work Konecnˇ y et al. (2016) combine this \` communication delay with random sparsification and probabilistic quantization. They restrict the clients to learn random sparse weight updates or force random sparsity on them afterwards ("structured" vs "sketched" updates) and combine this sparsification with probabilistic quantization. While their method also combines communication delay with (random) sparsification and quantization, and achieves good compression gains for one particular CNN and LSTM model, it also causes a major drop in convergence speed and final accuracy.
+
+Dense quantization methods try to reduce the amount of value bits $\bar { \mathrm { b } } _ { v a l }$ . Different quantization methods have been proposed that reduce the bit-width of the gradients to ternary (Wen et al., 2017), binary (Seide et al., 2014; Bernstein et al., 2018) or arbitrary (Alistarh et al., 2017) bitwidths. While these are theoretically well-founded and come with strong convergence guarantees, they are also limited to a maximum compression rate of $\times 3 2$ , compared to the regular 32-bit encoding.
+
+![](images/16ab61f604048fb48daa23d796e8a481a8582f980e2571e696a8d2c176a492d9.jpg)  
+2 ON THE ACCUMULATION OF GRADIENT INFORMATION   
+Figure 2: Sources of noise in SGD (illustration): Left: Optimization noise, caused by Gradient Descent overshooting. Bouncing between the walls of the ravine results in negatively correlated noise. Middle: Batch noise, caused by the batch loss being only a noisy approximation of the full empirical loss. Right: The compressed path converges equally fast, but requires only half of the information to be communicated.
+
+Communication delay and sparsification methods as described above already achieve impressive compression rates, however the phenomenon underlying their successes is still only poorly understood. We present a new information-theoretic perspective that is based on the observation that both of these approaches achieve compression by accumulating gradient information locally before sending it to the server. In the case of communication delay all gradients are accumulated uniformly for a fixed amount of iterations, while in the case of sparsification methods they are accumulated non-uniformly until they exceed some fixed or adaptive threshold. In both cases the rate of compression is proportional to the number of steps that the updates are being delayed on average.
+
+Consider now the optimization path $\Delta { \mathcal { W } } _ { 1 } , . . , \Delta { \mathcal { W } } _ { T }$ taken by SGD on the loss-surface between some initialization point W0 and the model WT = W0 + PTt=1 trained for $T$ iterations. Following this path, we can model the changes occurring to any individual weight in the network $w$ as a noisy stochastic process via
+
+$$
+\Delta w ^ { t } = s ^ { t } + n ^ { t } , t = 1 , . . , T
+$$
+
+where $s ^ { t }$ denotes the deterministic signal (i.e. the true direction of the minimum), while $n ^ { t }$ denotes the noise, induced by mini-batch sampling in SGD ("batch noise") and the stochasticity of the learning process itself ("optimization noise", see figure 2 for an illustration). For the sake of simplicity, and motivated by the central limit theorem we can assume (a) that this noise $n ^ { t }$ is normally distributed at every time-step $n ^ { t } \sim \mathcal N ( 0 , \sigma ^ { 2 } )$ with the variance being constant in time $\mathbb { V } ( n ^ { t } ) \stackrel { } { = } \sigma ^ { 2 }$ for all $t = 1 , . . , T$ . Since the optimization process has the tendency to damp noise as investigated for instance in LeCun et al. (2012) it is also reasonable to assume (b) that the noise is (negatively) self-correlated. The noise process is then given by $n ^ { 1 } = N ^ { 1 }$ , $n ^ { t } = \alpha n ^ { t - 1 } + N ^ { t }$ , with $N ^ { t }$ normally distributed and all $N ^ { t }$ uncorrelated, $\alpha \in ( - 1 , 0 )$ . Given these assumptions we can bound the variance of the accumulated parameter updates.
+
+Theorem 2.1. Under assumptions (a) and $( b )$ , the variance of the accumulated noise can be bounded by
+
+$$
+\mathbb { V } ( \sum _ { t = 1 } ^ { T } n ^ { t } ) \le \sigma ^ { 2 } ( T ( 1 + \alpha ) + 1 ) .
+$$
+
+The proof can be found in the supplement. Theorem 2.1 directly leads us to a lower bound on the signal-to-noise ratio of the accumulated weight-updates:
+
+Corollary 2.1.1. Under assumptions (a) and $( b )$ , accumulation increases the signal-to-noise ratio from $\bar { s } / \sigma$ to
+
+$$
+S N R ( \sum _ { t = 1 } ^ { T } \Delta w ^ { t } ) = \frac { \mathbb { E } [ \sum _ { t = 1 } ^ { T } s ^ { t } + n ^ { t } ] } { \sqrt { \mathbb { V } [ \sum _ { t = 1 } ^ { T } s ^ { t } + n ^ { t } ] } } \geq \frac { \sum _ { t = 1 } ^ { T } s ^ { t } } { \sqrt { \sigma ^ { 2 } ( T ( 1 + \alpha ) + 1 ) } } \approx \frac { \sqrt { T } } { \sqrt { 1 + \alpha } } \frac { \bar { s } } { \sigma }
+$$
+
+$\begin{array} { r } { \bar { s } = \frac { 1 } { T } \sum _ { t = 1 } ^ { T } { s ^ { t } } } \end{array}$ being the signal-average over time.
+
+This means that a weight-update will be more informative the longer the accumulation period and the stronger the noise correlates temporally. Convergence speed will not be compromised for as long as the information content of the accumulated update is equal to the cumulative information content of the individual updates (c.f. fig. 2 (c)). This line of reasoning helps to shed light on both the successes of communication delay and gradient sparsification. In fact, it implies that both of these approaches are actually very similar in the way they affect the information flow from client to server on the individual weight level.
+
+We find that this intuition is also verified empirically. Figure 3 shows validation errors for ResNet32 model trained on CIFAR for 60000 iterations at different levels of communication delay and gradient sparsity. We observe multiple things: 1.) The validation error remains more or less constant along the off-diagonals of the matrix where the total sparsity (i.e. the product of communication delay and gradient sparsity) is constant. 2.) The existing methods of Federated Averaging (McMahan et al., 2016) (purple) and Gradient Dropping/ DGC (Aji & Heafield, 2017; Lin et al., 2017)(yellow) are just lines in the two-dimensional space of possible compression methods. 3.) There exists a roughly triangular area of approximately constant error, optimal compression methods lie along the hypotenuse of this triangle. We find this behavior consistently across different model architectures, more examples can be found in the supplement. These results indicate, that communication delay and sparsification affect the convergence in a roughly multiplicative way and that there seems to exist a fixed information budged in DSGD, necessary to maintain unhindered convergence.
+
+![](images/19e7ea356464d3e97b87fc82605d547a43177538b4a6011a877d3cd1804c873b.jpg)  
+Figure 3: Validation Error for ResNet32 trained on CIFAR at different levels of temporal and gradient sparsity (the error is color-coded, brighter means lower error). The prior approaches of Gradient Dropping and Federated Averaging can be embedded in a two-dimensional compression framework.
+
+In the following we present a framework that allows us to smoothly trade of these two types of gradient accumulation against one another. By doing so our proposed framework can adapt to the requirements of the distributed learning environment and achieve state-of-the-art compression results by reaping the benefits from both approaches.
+
+# 3 SPARSE BINARY COMPRESSION
+
+Inspired by our findings in the previous section, we propose Sparse Binary Compression (cf. Figure 4), to drastically reduce the number of communicated bits in distributed training. SBC makes use of multiple compression techniques simultaneously1 to reduce all multiplicative components of equation 1.
+
+![](images/746065ec084d2fd326f7cabd07148c0086f6a804fe554d6536ad8c47ebeb85ba.jpg)  
+Figure 4: Step-by-step explanation of techniques used in Sparse Binary Compression: (a) Illustrated is the traversal of the parameter space with regular DSGD (left) and Federated Averaging (right). With this form of communication delay, a bigger region of the loss surface can be traversed, in the same number of communication rounds. That way compression gains of up to $\times 1 0 0 0$ are possible. After a number of iterations, the clients communicate their locally computed weight updates. (b) Before communication, the weight update is first sparsified, by dropping all but the fraction $p$ weight updates with the highest magnitude. This achieves up to $\times 1 0 0 0$ compression gain. (c) Then the sparse weight update is binarized for an additional compression gain of approximately $\times 3 .$ . (d) Finally, we optimally encode the positions of the non-zero elements, using Golomb encoding. This reduces the bit size of the compressed weight update by up to another $\times 2$ compared to naive encoding.
+
+In the following $\mathcal { W }$ will refer to the entirety of neural network parameters, while $W \in { \mathcal { W } }$ will refer to one specific tensor of weights. Arithmetic operations on $\mathcal { W }$ are to be understood componentwise.
+
+Communication Delay, Fig. 4 (a): We use communication delay, proposed by McMahan et al. (2016), to introduce temporal sparsity into DSGD. Instead of communicating gradients after every local iteration, we allow the clients to compute more informative updates by performing multiple iterations of SGD. These generalized weight updates are given by
+
+$$
+\Delta \mathcal { W } _ { i } = \mathrm { S G D } _ { n } ( \mathcal { W } _ { i } , D _ { i } ) - \mathcal { W } _ { i }
+$$
+
+where $\mathrm { S G D } _ { n } ( \mathcal { W } _ { i } , D _ { i } )$ refers to the set of weights obtained by performing $n$ iterations of stochastic gradient descent on $\mathcal { W } _ { i }$ , while sampling mini-batches from the i-th client’s training data $D _ { i }$ . Empirical analysis by McMahan et al. (2016) suggests that communication can be delayed drastically, with only marginal degradation of accuracy. For $n = 1$ we obtain regular DSGD.
+
+Sparse Binarization, Fig. 4 (b), (c): Following the works of Lin et al. (2017)Strom (2015)Shokri & Shmatikov (2015) and Aji & Heafield (2017) we use the magnitude of an individual weight within a weight update as a heuristic for it’s importance. First, we set all but the fraction $p$ biggest and fraction $p$ smallest weight updates to zero. Next, we compute the mean of all remaining positive and all remaining negative weight updates independently. If the positive mean $\mu ^ { + }$ is bigger than the absolute negative mean $\mu ^ { - }$ , we set all negative values to zero and all positive values to the positive mean and vice versa. The method is illustrated in figure 4 and formalized in algorithm 2. Finding the fraction $p$ smallest and biggest values in a vector $W$ requires $\mathcal { O } ( | W | )$ operations, where $| W |$ refers to the number of elements in $W$ (Cormen et al., 2009). Lin et al. (2017) suggest to reduce the computational cost of this operation, by randomly subsampling from $W$ . However this comes at the cost of introducing (unbiased) noise in the amount of sparsity. Luckily, in our approach communication rounds (and thus compressions) are relatively infrequent, which helps to marginalize the overhead of the sparsification. Quantizing the non-zero elements of the sparsified weight update to the mean reduces the required value bits $\bar { b } _ { v a l }$ from 32 to $O$ . This translates to a reduction in communication cost by a factor of around $\times 3$ . We can get away with averaging out the non-zero weight updates because they are relatively homogeneous in value and because we accumulate our compression errors as described in the next paragraph.
+
+Residual Accumulation, Fig. 4 (d): It is well established (Lin et al., 2017; Strom, 2015; Aji & Heafield, 2017; Seide et al., 2014) that the convergence in sparsified DSGD can be greatly accelerated by accumulating the error that arises from only sending sparse approximations of the weight updates. After every communication round, the residual is updated via
+
+$$
+\mathcal { R } _ { \tau } = \sum _ { t = 1 } ^ { \tau } ( \Delta \mathcal { W } _ { t } - \Delta \mathcal { W } _ { t } ^ { * } ) = \mathcal { R } _ { \tau - 1 } + \Delta \mathcal { W } _ { \tau } - \Delta \mathcal { W } _ { \tau } ^ { * } .
+$$
+
+Error accumulation has the great benefit that no gradient information is lost (it may only become outdated or "stale"). In the context of pure sparsification residual accumulation can be interpreted to be equivalent to increasing the batch size for individual parameters (Lin et al., 2017). Moreover, we can show:
+
+Theorem 3.1. Let $\Delta W _ { 1 } , . . , \Delta W _ { T } \in \mathbb { R } ^ { n }$ be (flattened) weight updates, computed by one client in the first $T$ communication rounds. Let $\Delta W _ { 1 } ^ { * } , . . , \Delta W _ { T - 1 } ^ { * } \in \mathcal { S }$ be the actual weight updates, transferred in the previous rounds (restricted to some subspace $s$ ) and $\mathcal { R } _ { \tau }$ be the content of the residual at time $\tau$ as in equation 5. Then the orthogonal projection
+
+$$
+v = P r o j _ { S } ( \mathcal { R } _ { T - 1 } + \Delta W _ { T } )
+$$
+
+uniquely minimizes the accumulated error
+
+$$
+\operatorname { e r r } ( \Delta W _ { T } ^ { * } ) = \| \sum _ { t = 1 } ^ { T } ( \Delta W _ { t } - \Delta W _ { t } ^ { * } ) \|
+$$
+
+in S. (Proof in Supplement.)
+
+That means that the residual accumulation keeps the compressed optimization path as close as possible to optimization path taken with non-compressed weight updates.
+
+<table><tr><td></td><td>Algorithm 1: SynchronousDistributed Stochastic Gradient Descent (DSGD)</td></tr><tr><td></td><td>input: initial parameters W 2 outout: improved parameters W 3 init:all clients Ci are initialized with the</td></tr><tr><td></td><td>same parameters Wi ← W, the initial</td></tr><tr><td></td><td>global weight update and the residuals are set to zero △W,Ri←0</td></tr><tr><td></td><td>4 for t=1,..,T do for i∈ It ≌ {1,..,M} in parallel do</td></tr><tr><td>5 6</td><td>Client Ci does:</td></tr><tr><td>7</td><td>· msg ← downloads→C (msg)</td></tr><tr><td>8</td><td>· △W ← decode(msg)</td></tr><tr><td></td><td>·Wi←Wi+△W</td></tr><tr><td>9</td><td>· △Wi ← Ri+SGDn(Wi,Di)-Wi</td></tr><tr><td>10 11</td><td>· △W* ← compress(△Wi)</td></tr><tr><td>12</td><td>·Ri←△Wi-△W*</td></tr><tr><td></td><td>· msg: ← encode(△W*)</td></tr><tr><td>13 14</td><td>· uploadci→s(msg;)</td></tr><tr><td>15</td><td>end</td></tr><tr><td>16</td><td>Server S does:</td></tr><tr><td>17</td><td>： gatherci→s(△W*), i ∈ It</td></tr><tr><td>18</td><td>△W← £ielt △W*</td></tr><tr><td></td><td>. W←W+△W</td></tr><tr><td>19</td><td></td></tr><tr><td>20</td><td>broadcasts→c (△W), i=1,..,M</td></tr><tr><td>21</td><td>end</td></tr></table>
+
+# Algorithm 2: Sparse Binary Compression
+
+1 input: tensor $\Delta W$ , sparsity $p$   
+2 output: sparse tensor $\Delta W ^ { * }$   
+$\begin{array} { r l r } { { 3 } } & { { } \bullet } & { \mathrm { v a l ^ { + } }  \mathrm { t o p } _ { p \% } ( \Delta W ) ; } \end{array}$ ;   
+$\begin{array} { r } { \mathbf { \Sigma } ^ { \mathbf { \textsc { v a l } } } \mathbf { \Sigma } ^ {  } \mathbf { \Sigma } ^ { \mathbf { w p } } p \% \mathbf { \Sigma } ^ { \lfloor \Delta \nu \nu \rfloor , } } \\ { \mathbf { v a l } ^ { - }  \mathbf { t o p } _ { p \% } ( - \Delta W ) } \end{array}$   
+${ \mathfrak { a } } \bullet \mu ^ { + }  \operatorname { m e a n } ( \mathrm { v a l } ^ { + } ) ; \mu ^ { - }  \operatorname { m e a n } ( \mathrm { v a l } ^ { - } )$ 5 if $\mu ^ { + } \geq \mu ^ { - }$ then   
+6 return $\Delta W ^ { * } \gets \mu ^ { + } ( W \geq \mathrm { \ m i n } ( \mathrm { v a l } ^ { + } ) )$ 7 else   
+8 return   
+$\Delta W ^ { * } \gets - \mu ^ { - } ( W \le - \operatorname* { m i n } ( \mathrm { v a l } ^ { - } ) )$ 9 end
+
+# Algorithm 3: Golomb Position Encoding
+
+1 input: sparse tensor $\Delta W ^ { * }$ , sparsity $p$   
+2 output: binary message msg   
+3 • $\bar { \mathcal { T } }  \Delta W ^ { * } [ : ] _ { \neq 0 }$   
+4 $\begin{array} { r } { \bullet \ \mathbf { b } ^ { * }  1 + \lfloor \log _ { 2 } ( \frac { \log ( \phi - 1 ) } { \log ( 1 - p ) } ) \rfloor } \end{array}$   
+5 for $i = 1 , . . , | \mathcal { T } |$ do   
+6 • d ← Ii − Ii−1   
+7 • q ← (d − 1) div 2b∗   
+8 • r ← (d − 1) mod 2b∗   
+9 • msg.add(1, .., 1, 0, binaryb∗ (r))   
+| {z }q times   
+10 end   
+11 return msg
+
+Optimal Position Encoding, Fig. 4 (e): To communicate a set of sparse binary tensors produced by SGC, we only need to transfer the positions of the non-zero elements in the flattened tensors, along with one mean value $\mu ^ { + }$ or $\mu ^ { - }$ ) per tensor. Instead of communicating the absolute non-zero positions it is favorable to only communicate the distances between all non-zero elements. It is possible to show that for big values of $| W |$ and $k = p | W |$ , the distances are approximately geometrically distributed with success probability equal to the sparsity rate $p$ . Therefore, we can optimally encode the distances using the Golomb code Golomb (1966). Golomb encoding reduces the average number of position bits to
+
+$$
+\bar { \mathrm { b } } _ { p o s } = \mathbf { b } ^ { * } + \frac { 1 } { 1 - ( 1 - p ) ^ { 2 ^ { \mathbf { b } ^ { * } } } } ,
+$$
+
+with b∗ = 1 + blog2( log(φ−1)log(1−p) ) and $\textstyle \phi = { \frac { { \sqrt { 5 } } + 1 } { 2 } }$ being the golden ratio. For a sparsity rate of i.e. $p = 0 . 0 1$ , we get $\bar { \mathrm { b } } _ { p o s } = 8 . 3 8$ , which translates to $\times 1 . 9$ compression, compared to a naive distance encoding with 16 fixed bits. While the overhead for encoding and decoding makes it unproductive to use Golomb encoding in the situation of Strom (2015), this overhead becomes negligible in our situation due to the infrequency of weight update exchange resulting from communication delay. The encoding scheme is given in algorithm 3, while the decoding scheme can be found in the supplement.
+
+Momentum Correction, Warm-up Training and Momentum Masking: Lin et al. (2017) introduce multiple minor modifications to the vanilla Gradient Dropping method, to improve the convergence speed. We adopt momentum masking, while momentum correction is implicit to our approach. For more details on this we refer to the supplement.
+
+Our proposed method is described in Algorithms 1, 2 and 3. Algorithm 1 describes how compression and residual accumulation can be introduced into DSGD. Algorithm 2 describes our compression method. Algorithm 3 describes the Golomb encoding. Table 1 compares theoretical asymptotic compression rates of different popular compression methods.
+
+<table><tr><td colspan="2">Total Bits =</td><td>Baseline</td><td>SignSGD, TernGrad, QSGD</td><td>Gradient Dropping, DGC</td><td>Federated Averaging</td><td>Sparse Binary Compression</td></tr><tr><td rowspan="3">×</td><td>Temporal Sparsity</td><td>100%</td><td>100%</td><td>100%</td><td>0.1% - 10%</td><td>0.1% - 10%</td></tr><tr><td>Gradient Sparsity</td><td>100%</td><td>100%</td><td>0.1%</td><td>100%</td><td>0.1% - 10%</td></tr><tr><td>Value Bits</td><td>32</td><td>1-8</td><td>32</td><td>32</td><td>0</td></tr><tr><td colspan="2">×M Position Bits</td><td>0</td><td>0</td><td>16</td><td>0</td><td>8-14</td></tr><tr><td colspan="2">Compression Rate</td><td>×1</td><td>×4-×32</td><td>×666</td><td>×10-×1000</td><td>-×40000</td></tr></table>
+
+Table 1: Theoretical asymptotic compression rates for different compression methods broken down into components. Only SBC reduces all multiplicative components of the total bitsize (cf. eq. 1).
+
+# 4 EXPERIMENTS
+
+# 4.1 NETWORKS AND DATASETS
+
+We evaluate our method on commonly used convolutional and recurrent neural networks with millions of parameters, which we train on well-studied data sets that contain up to multiple millions of samples. We perform experiments with client numbers ranging from 4 to 400 to cover both the distributed training and federated learning use-case.
+
+Image Classification: We run experiments for LeNet5-Caffe2 on MNIST LeCun (1998), ResNet18 and ResNet34 He et al. (2016) on CIFAR-10 and CIFAR-100 Krizhevsky et al. (2014) and ResNet50 on ILSVRC12 (ImageNet) Deng et al. (2009). For the i.i.d. setting we split the training data randomly into equally sized shards and assign one shard to every one of the clients. For the non-i.i.d. setting every client is assigned samples from only two classes of the dataset, but the amount of data still remains the same for every client. All models are trained using momentum SGD, except for LeNet5- Caffe, which is trained using the Adam optimizer Kingma & Ba (2014). Learning rate, weight intitiallization and data augmentation are as in the respective papers.
+
+<table><tr><td></td><td colspan="2">Compression Method -→</td><td>Baseline</td><td>DGC3</td><td>Federated Averaging4</td><td>SBC (1)</td><td>SBC (2)</td><td>SBC (3)</td></tr><tr><td rowspan="9">taprrisititt</td><td>LeNet5-Caffe @MNIST</td><td>Accuracy</td><td>0.9946</td><td>0.994</td><td>0.994</td><td>0.994</td><td>0.994</td><td>0.991</td></tr><tr><td></td><td>Compression</td><td>×1</td><td>×718</td><td>×500</td><td>×2071</td><td>×3166</td><td>×24935</td></tr><tr><td>ResNet18 @CIFAR10</td><td>Accuracy</td><td>0.946</td><td>0.9383</td><td>0.9279</td><td>0.9422</td><td>0.9435</td><td>0.9219</td></tr><tr><td>ResNet34</td><td>Compression Accuracy</td><td>×1</td><td>×768</td><td>×1000</td><td>×2369</td><td>×3491 0.7655</td><td>× 31664 0.701</td></tr><tr><td>@CIFAR100</td><td>Compression</td><td>0.773 ×1</td><td>0.767 ×718</td><td>0.7316</td><td>0.767 ×2370</td><td>×3166</td><td>×31664</td></tr><tr><td>ResNet50</td><td>Accuracy</td><td>0.737</td><td>0.739</td><td>×1000 0.724</td><td>0.735</td><td>0.737</td><td>0.728</td></tr><tr><td>@ImageNet</td><td>Compression</td><td>×1</td><td>×601</td><td>×1000</td><td>×2569</td><td>×3531</td><td>×37208</td></tr><tr><td>WordLSTM</td><td>Perplexity</td><td>76.02</td><td>75.98</td><td>76.37</td><td>77.73</td><td>78.19</td><td>77.57</td></tr><tr><td>@PTB</td><td>Compression</td><td>×1</td><td>×719</td><td>×1000</td><td>×2371</td><td>×3165</td><td>×31658</td></tr><tr><td>WordLSTM*</td><td>Perplexity</td><td>101.5</td><td>102.318</td><td>131.51</td><td>103.95</td><td>103.95</td><td>104.62</td></tr><tr><td>@WIKI</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td>Compression</td><td></td><td>×719</td><td>×1000</td><td>×2371</td><td>×3165</td><td>×31657</td></tr><tr><td></td><td></td><td>×1</td><td></td><td></td><td></td><td></td><td></td></tr></table>
+
+Table 2: Final accuracy/perplexity achieved on the test split and average compression rate for different compression schemes in a distributed training setting with different numbers of clients.
+
+Language Modeling: We experiment with multilayer sequence-to-sequence LSTM models as described in Zaremba et al. (2014) on the Penn Treebank (PTB) Marcus et al. (1993) and Wikitext-2 corpora for next-word prediction. The PTB dataset consists of a sequence 923000 training, and 82000 validation words, while the Wikitext-2 dataset contains 2088628 train and 245569 test words. On both datasets we train a two-layer LSTM model with 650 and 200 hidden units respectively ("WordLSTM" / "WordLSTM\*") with tied weights between encoder and decoder as described in Inan et al. (2016). The training data is split into consecutive subsequences of equal length, out of which we assign one to every client.
+
+While the models we use in our experiments do not fully achieve state-of-the-art results on the respective tasks and datasets, they are still sufficient for the purpose of evaluating our compression method and demonstrate, that our method works well with common regularization techniques such as batch normalization Ioffe & Szegedy (2015) and dropout Srivastava et al. (2014). A complete description of models and hyperparameters can be found in the supplement.
+
+# 4.2 RESULTS
+
+We experiment with three configurations of our method: SBC (1) uses no communication delay and a gradient sparsity of $0 . 1 \%$ , SBC (2) uses 10 iterations of communication delay and $1 \%$ gradient sparsity and SBC (3) uses 100 iterations of communication delay and $1 \%$ gradient sparsity. Our decision for these points on the 2D grid of possible configurations is somewhat arbitrary. The experiments with SBC (1) serve the purpose of enabling us to directly compare our 0-value-bit quantization to the 32-value-bit Deep Gradient Compression (Lin et al., 2017)).
+
+Table 2 lists compression rates and final validation accuracies achieved by different compression methods, when applied to the training of neural networks on 5 different datasets. The number of iterations (forward-backward-passes) is held constant for all methods. On all benchmarks, our methods perform comparable to the baseline, while communicating significantly less bits.
+
+Figure 5 shows convergence speed in terms of iterations (left) and communicated bits (right) respectively for ResNet50 trained on ImageNet. The convergence speed is only marginally affected, by our different compression methods. In the first 30 epochs SBC (3) even achieves the highest accuracy, using about $\times 3 7 0 0 0$ less bits than the baseline. In total, SBC (3) reduces the upstream communication on this benchmark from 125 terabytes to 3.35 gigabytes for every participating client. After the learning rate is lowered in epochs 30 and 60 progress slows down for SBC (3) relative to the
+
+<table><tr><td rowspan=2 colspan=1></td><td rowspan=1 colspan=2>Compression Method -→</td><td rowspan=1 colspan=1>Baseline</td><td rowspan=1 colspan=1>GradientDroping</td><td rowspan=1 colspan=1>FederatedAveraging</td><td rowspan=1 colspan=1>SBC (1)</td><td rowspan=1 colspan=1>SBC (2)</td><td rowspan=1 colspan=1>SBC (3)</td></tr><tr><td rowspan=1 colspan=8> i.i.d. data</td></tr><tr><td rowspan=1 colspan=1>50</td><td rowspan=1 colspan=1>ResNet18*5@CIFAR10</td><td rowspan=1 colspan=1>AccuracyCompression</td><td rowspan=1 colspan=1>0.9254×1</td><td rowspan=1 colspan=1>0.9167×713</td><td rowspan=1 colspan=1>0.911×100</td><td rowspan=1 colspan=1>0.921×2362</td><td rowspan=1 colspan=1>0.902×3166</td><td rowspan=1 colspan=1>0.906×31664</td></tr><tr><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>LeNet5-Caffe@MNIST</td><td rowspan=1 colspan=1>AccuracyCompression</td><td rowspan=1 colspan=1>0.979×1</td><td rowspan=1 colspan=1>0.9811×714</td><td rowspan=1 colspan=1>0.967×100</td><td rowspan=1 colspan=1>0.979×2363</td><td rowspan=1 colspan=1>0.9818×3165</td><td rowspan=1 colspan=1>0.9536×31655</td></tr><tr><td rowspan=1 colspan=1>300</td><td rowspan=1 colspan=1>LeNet5-Caffe@MNIST</td><td rowspan=1 colspan=1>AccuracyCompression</td><td rowspan=1 colspan=1>0.9758×1</td><td rowspan=1 colspan=1>0.9744×714</td><td rowspan=1 colspan=1>0.899×100</td><td rowspan=1 colspan=1>0.9731×2363</td><td rowspan=1 colspan=1>0.9733×3165</td><td rowspan=1 colspan=1>0.8919×31655</td></tr><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=8> non-i.i.d. data</td></tr><tr><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>LeNet5-Caffe@MNIST</td><td rowspan=1 colspan=1> AccuracyCompression</td><td rowspan=1 colspan=1>0.9506×1</td><td rowspan=1 colspan=1>0.9498×714</td><td rowspan=1 colspan=1>0.8592×100</td><td rowspan=1 colspan=1>0.9522×2363</td><td rowspan=1 colspan=1>0.9583×3165</td><td rowspan=1 colspan=1>0.8344×31655</td></tr></table>
+
+Table 3: Final accuracy achieved on the test split and average compression rate for different compression schemes in a Federated learning setting with different numbers of clients.
+
+methods which do not use communication delay. In direct comparison SBC (1) performs very similar to Gradient Dropping, while using about $\times 4$ less bits (that is $\times 2 5 6 9$ less bits than the baseline).
+
+![](images/d95f32a3debc2a8c33cf286c97024edb8738782ebd2391fe72729308fd25a2b0.jpg)  
+Figure 5: Left: Top-1 validation accuracy vs number of epochs. Right: Top-1 validation error vs number of transferred bits (log-log). Epochs 30 and 60 at which the learning rate is reduced are marked in the plot. ResNet50 trained on ImageNet.
+
+Table 3 shows results for the federated learning setting with much higher numbers of clients trained on both i.i.d. and non-i.i.d. splits of data. We can see that in particular with growing numbers of clients and in the non-i.i.d. case, Federated Averaging significantly slows down the convergence and degrades the final accuracy. SBC (3) also suffers in this scenario as is also relies on 100 steps of communication delay. Conversely, our methods SBC (1) and (2) that rely more heavily on gradient sparsification perform much better in this setting and in some cases even beat the baseline. This behavior is expected, as the frequent exchange of gradient information in SBC (1) and (2) keeps all clients aligned, while they diverge further from one another for every iteration that communication is delayed in Federated Averaging.
+
+Our experiments suggest that the distinction between the two formerly treated as separate distributed training settings of federated learning and data-parallel training is somewhat arbitrary and misleading and that better results can be achieved by combining the best approaches from both of these worlds. Contrary to the paradigm suggested in previous literature (McMahan et al., 2016), communication delay does not seem to be a well-suited approach for communication reduction in the federated learning setting. Instead our experiments demonstrate, that drastically better performance can be achieved under an even lower communication budged, if individual weight-updates are sparsified instead of delayed. On the other hand, it’s easy to see that communication delay has the potential to speed-up parallel training as it allows the individual computation devices to perform multiple steps of SGD without interruption. Our experiments with 4 clients demonstrate that introducing communication delay into data parallel training is not harmful to the convergence of the model in terms of training iterations.
+
+# 5 CONCLUSION
+
+The gradient information for training deep neural networks with SGD is highly redundant (see e.g. Lin et al. (2017)). We exploit this fact to the extreme by combining 3 powerful compression strategies and are able to achieve compression gains of up to four orders of magnitude with only a slight decrease in accuracy. More fundamentally, we present theoretical and empirical evidence suggesting that the formerly treated as separate compression methods of communication delay and gradient sparsification in fact can be viewed as two very similar forms of gradient delay that affect the convergence speed in a roughly multiplicative way. Based on this insight we propose a framework that is able to reap the benefits from both compression approaches and can smoothly adapt to communication-constraints in the learning environment, such as network bandwidth and latency and (SGD-)computation time as well as temporal inhomogeneities therein. This leads to advantages in both federated learning and data-parallel training of deep neural networks. We would like to highlight, that in no case we did modify the hyperparameters of the respective baseline models to accommodate our method. This demonstrates that our method is easily applicable. Note however that an extensive hyperparameter search could further improve the results. Furthermore, our findings in sections 2 and 4 indicate that even higher compression rates are possible if we adapt communication delay and gradient sparsity to the particular training objective. It remains an interesting direction of further research to identify heuristics and theoretical insights that can help to find the optimal balance and thus guide sparsity towards optimality.
+
+# REFERENCES
+
+Alham Fikri Aji and Kenneth Heafield. Sparse communication for distributed gradient descent. arXiv preprint arXiv:1704.05021, 2017.
+
+Dan Alistarh, Demjan Grubic, Jerry Li, Ryota Tomioka, and Milan Vojnovic. Qsgd: Communicationefficient sgd via gradient quantization and encoding. In Advances in Neural Information Processing Systems, pp. 1707–1718, 2017.
+
+Jeremy Bernstein, Yu-Xiang Wang, Kamyar Azizzadenesheli, and Anima Anandkumar. signsgd: compressed optimisation for non-convex problems. arXiv preprint arXiv:1802.04434, 2018.
+
+Trishul M Chilimbi, Yutaka Suzue, Johnson Apacible, and Karthik Kalyanaraman. Project adam: Building an efficient and scalable deep learning training system. In OSDI, volume 14, pp. 571–582, 2014.
+
+Thomas H Cormen, Charles E Leiserson, Ronald L Rivest, and Clifford Stein. Introduction to algorithms. MIT press, 2009.
+
+Jeffrey Dean, Greg Corrado, Rajat Monga, Kai Chen, Matthieu Devin, Mark Mao, Andrew Senior, Paul Tucker, Ke Yang, Quoc V Le, et al. Large scale distributed deep networks. In Advances in neural information processing systems, pp. 1223–1231, 2012.
+
+Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. In Computer Vision and Pattern Recognition, 2009. CVPR 2009. IEEE Conference on, pp. 248–255. IEEE, 2009.
+
+Solomon Golomb. Run-length encodings (corresp.). IEEE transactions on information theory, 12(3): 399–401, 1966.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 770–778, 2016.
+
+Gao Huang, Zhuang Liu, Kilian Q Weinberger, and Laurens van der Maaten. Densely connected convolutional networks. In Proceedings of the IEEE conference on computer vision and pattern recognition, volume 1, pp. 3, 2017.
+
+Hakan Inan, Khashayar Khosravi, and Richard Socher. Tying word vectors and word classifiers: A loss framework for language modeling. arXiv preprint arXiv:1611.01462, 2016.
+
+Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In International conference on machine learning, pp. 448–456, 2015.
+
+Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
+
+Jakub Konecnˇ y, H Brendan McMahan, Felix X Yu, Peter Richtárik, Ananda Theertha Suresh, and \` Dave Bacon. Federated learning: Strategies for improving communication efficiency. arXiv preprint arXiv:1610.05492, 2016.
+
+Alex Krizhevsky, Vinod Nair, and Geoffrey Hinton. The cifar-10 dataset. online: http://www. cs. toronto. edu/kriz/cifar. html, 2014.
+
+Yann LeCun. The mnist database of handwritten digits. http://yann. lecun. com/exdb/mnist/, 1998.
+
+Yann LeCun, Léon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998.
+
+Yann A LeCun, Léon Bottou, Genevieve B Orr, and Klaus-Robert Müller. Efficient backprop. In Neural networks: Tricks of the trade, pp. 9–48. Springer, 2012.
+
+Mu Li, David G Andersen, Alexander J Smola, and Kai Yu. Communication efficient distributed machine learning with the parameter server. In Advances in Neural Information Processing Systems, pp. 19–27, 2014.
+
+Yujun Lin, Song Han, Huizi Mao, Yu Wang, and William J Dally. Deep gradient compression: Reducing the communication bandwidth for distributed training. arXiv preprint arXiv:1712.01887, 2017.
+
+Mitchell P Marcus, Mary Ann Marcinkiewicz, and Beatrice Santorini. Building a large annotated corpus of english: The penn treebank. Computational linguistics, 19(2):313–330, 1993.
+
+H Brendan McMahan, Eider Moore, Daniel Ramage, Seth Hampson, et al. Communication-efficient learning of deep networks from decentralized data. arXiv preprint arXiv:1602.05629, 2016.
+
+Philipp Moritz, Robert Nishihara, Ion Stoica, and Michael I Jordan. Sparknet: Training deep networks in spark. arXiv preprint arXiv:1511.06051, 2015.
+
+Benjamin Recht, Christopher Re, Stephen Wright, and Feng Niu. Hogwild: A lock-free approach to parallelizing stochastic gradient descent. In Advances in neural information processing systems, pp. 693–701, 2011.
+
+Frank Seide, Hao Fu, Jasha Droppo, Gang Li, and Dong Yu. 1-bit stochastic gradient descent and its application to data-parallel distributed training of speech dnns. In Fifteenth Annual Conference of the International Speech Communication Association, 2014.
+
+Reza Shokri and Vitaly Shmatikov. Privacy-preserving deep learning. In Proceedings of the 22nd ACM SIGSAC conference on computer and communications security, pp. 1310–1321. ACM, 2015.
+
+Nitish Srivastava, Geoffrey Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: A simple way to prevent neural networks from overfitting. The Journal of Machine Learning Research, 15(1):1929–1958, 2014.
+
+Nikko Strom. Scalable distributed dnn training using commodity gpu cloud computing. In Sixteenth Annual Conference of the International Speech Communication Association, 2015.
+
+Yusuke Tsuzuku, Hiroto Imachi, and Takuya Akiba. Variance-based gradient compression for efficient distributed deep learning. arXiv preprint arXiv:1802.06058, 2018.
+
+Wei Wen, Cong Xu, Feng Yan, Chunpeng Wu, Yandan Wang, Yiran Chen, and Hai Li. Terngrad: Ternary gradients to reduce communication in distributed deep learning. arXiv preprint arXiv:1705.07878, 2017.
+
+Eric P Xing, Qirong Ho, Wei Dai, Jin Kyu Kim, Jinliang Wei, Seunghak Lee, Xun Zheng, Pengtao Xie, Abhimanu Kumar, and Yaoliang Yu. Petuum: A new platform for distributed machine learning on big data. IEEE Transactions on Big Data, 1(2):49–67, 2015.
+
+Wojciech Zaremba, Ilya Sutskever, and Oriol Vinyals. Recurrent neural network regularization. arXiv preprint arXiv:1409.2329, 2014.
+
+Martin Zinkevich, Markus Weimer, Lihong Li, and Alex J Smola. Parallelized stochastic gradient descent. In Advances in neural information processing systems, pp. 2595–2603, 2010.
+
+# 6 SUPPLEMENT
+
+6.1 MOMENTUM CORRECTION, WARM-UP TRAINING AND MOMENTUM MASKING:
+
+Lin et al. introduce multiple minor modifications to the vanilla Gradient Dropping method. With these modifications they achieve up to around $1 \%$ higher accuracy compared to Gradient Dropping on a variety of benchmarks. Those modifications include:
+
+Momentum correction: Instead of adding the raw gradient to the residuum, the momentum-corrected gradient is added. This is used implicitly in our approach, as our weight updates are already momentum-corrected.
+
+Warm-up Training: The sparsity rate is increased exponentially from $2 5 \%$ to $0 . 1 \%$ in the first epochs. We find that warm-up training can indeed speed-up convergence in the beginning of training, but ultimately has no effect on the final accuracy of the model. We therefore omit warm up training in our experiments, as it adds an additional hyperparameter to the method, without any real benefit.
+
+Momentum Masking: To avoid stale momentum from carrying the optimization into a wrong direction after a weight update is performed, Lin et al. suggest to set the momentum to zero for updated weights. We adopt momentum correction in our method.
+
+# 6.2 GOLOMB POSITION DECODING
+
+Algorithm 4 describes the decoding of a binary sequence produced by Golomb Position Encoding (see main paper). Since the shapes of all weight-tensors are known to both the server and all clients, we can omit the shape information in both encoding and decoding.
+
+# Algorithm 4: Golomb Position Decoding
+
+1 input: binary message msg, bitsize $\mathbf { b } ^ { * }$ , mean value $\mu$   
+2 output: sparse tensor $\Delta W ^ { * }$   
+3 init: $\Delta W ^ { * }  0 \in \mathbb { R } ^ { n }$   
+4 $i \gets 0$ ; $q \gets 0$ ; $j  0$   
+5 while $i < s i z e ( \mathrm { m s g } )$ do   
+6 i ${ \bf f } \log [ i ] = 0$ then   
+7 • $j \gets j + q 2 ^ { \mathbf { b } ^ { \ast } } + \mathrm { i n t } _ { \mathbf { b } ^ { \ast } } ( \mathrm { m s g } [ i + 1 ] , . . , \mathrm { m s g } [ i + \mathbf { b } ^ { \ast } ] ) + 1$   
+8 • ∆W ∗j ← µ   
+9 q 0; i i + b∗ + 1   
+10 else   
+11 • q ← q + 1; i ← i + 1   
+12 end   
+13 end   
+14 return ∆W ∗
+
+# 6.3 MODEL SPECIFICATION
+
+Below, we describe the neural network models used in our experiments. Table 4 list the training hyperparameters that were used.
+
+Table 4: Hyperparameters used for our experiments in sections 2 and 4.   
+
+<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>Experiment</td><td rowspan=1 colspan=1>Iterations</td><td rowspan=1 colspan=1>Batchsize</td><td rowspan=1 colspan=1>LR</td><td rowspan=1 colspan=1>LR Decay</td><td rowspan=1 colspan=1>Optimizer</td></tr><tr><td rowspan=6 colspan=1>tettittt</td><td rowspan=1 colspan=1>LeNet5-Caffe@MNIST</td><td rowspan=1 colspan=1>2000</td><td rowspan=1 colspan=1>128×4</td><td rowspan=1 colspan=1>0.001</td><td rowspan=1 colspan=1>=</td><td rowspan=1 colspan=1>Adam</td></tr><tr><td rowspan=1 colspan=1>ResNet18@CIFAR10</td><td rowspan=1 colspan=1>36000</td><td rowspan=1 colspan=1>32×4</td><td rowspan=1 colspan=1>0.1</td><td rowspan=1 colspan=1>0.1 @ ep 40 and 80</td><td rowspan=1 colspan=1>Momentum SGD</td></tr><tr><td rowspan=1 colspan=1>ResNet34@CIFAR100</td><td rowspan=1 colspan=1>36000</td><td rowspan=1 colspan=1>32×4</td><td rowspan=1 colspan=1>0.1</td><td rowspan=1 colspan=1>0.1@ep 40 and 80</td><td rowspan=1 colspan=1>Momentum SGD</td></tr><tr><td rowspan=1 colspan=1>ResNet50@ImageNet</td><td rowspan=1 colspan=1>900000</td><td rowspan=1 colspan=1>32×4</td><td rowspan=1 colspan=1>0.1</td><td rowspan=1 colspan=1>0.1@ep 30 and 60</td><td rowspan=1 colspan=1>Momentum SGD</td></tr><tr><td rowspan=1 colspan=1>WordLSTM@PTB</td><td rowspan=1 colspan=1>53000</td><td rowspan=1 colspan=1>5×4</td><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>decay 0.25 if losshas not decreased</td><td rowspan=1 colspan=1>SGD</td></tr><tr><td rowspan=1 colspan=1>WordLSTM*@WIKI</td><td rowspan=1 colspan=1>120000</td><td rowspan=1 colspan=1>5×4</td><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>decay 0.25 if losshas not decreased</td><td rowspan=1 colspan=1>SGD</td></tr><tr><td rowspan=1 colspan=1>50</td><td rowspan=1 colspan=1>Resnet18*@CIFAR10</td><td rowspan=1 colspan=1>23000</td><td rowspan=1 colspan=1>4×50</td><td rowspan=1 colspan=1>0.1</td><td rowspan=1 colspan=1>0.1@ ep 40 and 80</td><td rowspan=1 colspan=1>Momentum SGD</td></tr><tr><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>LeNet5-Caffe@MNIST</td><td rowspan=1 colspan=1>2500</td><td rowspan=1 colspan=1>8×100</td><td rowspan=1 colspan=1>0.001</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>Adam</td></tr><tr><td rowspan=1 colspan=1>40</td><td rowspan=1 colspan=1>LeNet5-Caffe@MNIST</td><td rowspan=1 colspan=1>2500</td><td rowspan=1 colspan=1>2×400</td><td rowspan=1 colspan=1>0.001</td><td rowspan=1 colspan=1>=</td><td rowspan=1 colspan=1>Adam</td></tr></table>
+
+LeNet5-Caffe: The model specification can be downloaded from the Caffe MNIST tutorial page: https://github.com/BVLC/caffe/blob/master/examples/mnist/lenet_ train_test.prototxt. (Features convolutional layers, fully connected layers, pooling.)
+
+ResNet18, ResNet32, ResNet50: We use the implementation from the official PyTorch repository: https://github.com/pytorch/examples/tree/master/imagenet. (Features skip-connections, batch-normalization.)
+
+WordLSTM: We use the implementation from the official PyTorch repository (configuration "medium"): https://github.com/pytorch/examples/tree/master/word_ language_model. (Features trainable word-embeddings, multilayer LSTM-cells, dropout.)
+
+# 6.4 PROOF OF THEOREM 2.1.
+
+Proof. Since
+
+$$
+\begin{array} { r } { n ^ { t } = \alpha n ^ { t - 1 } + N ^ { t } = \alpha ( \alpha n ^ { t - 2 } + N ^ { t - 1 } ) + N ^ { t } = \alpha ^ { 2 } n ^ { t - 2 } + \alpha N ^ { t - 1 } + N ^ { t } } \\ { = \alpha ^ { \tau } n ^ { t - \tau } + \displaystyle \sum _ { i = 0 } ^ { \tau - 1 } \alpha ^ { i } N ^ { t - i } } \end{array}
+$$
+
+it holds that
+
+$$
+\mathrm { c o v } ( n ^ { t - \tau } , n ^ { t } ) = \mathrm { c o v } ( n ^ { t - \tau } , \alpha ^ { \tau } n ^ { t - \tau } + \sum _ { i = 0 } ^ { \tau - 1 } \alpha ^ { i } N ^ { t - i } ) = \alpha ^ { \tau } \sigma ^ { 2 } + \sum _ { i = 0 } ^ { \tau - 1 } \alpha ^ { i } \underbrace { \mathrm { c o v } ( n ^ { t - \tau } , N ^ { t - i } ) } _ { = 0 } = \alpha ^ { \tau } \sigma ^ { 2 }
+$$
+
+With equation equation 10 it follows that
+
+$$
+\begin{array} { r l r } {  { \mathbb { V } ( \sum _ { t = 1 } ^ { T } n ^ { t } ) = \sum _ { t _ { 1 } = 1 } ^ { T } \sum _ { t _ { 2 } = 1 } ^ { T } \operatorname { c o v } ( n ^ { t _ { 1 } } , n ^ { t _ { 2 } } ) } } \\ & { } & { = \underbrace { \sum _ { t = 1 } ^ { T } \operatorname { c o v } ( n ^ { t } , n ^ { t } ) } _ { T \sigma ^ { 2 } } + 2 \underbrace { \sum _ { t = 1 } ^ { T - 1 } \operatorname { c o v } ( n ^ { t } , n ^ { t + 1 } ) } _ { \alpha ( T - 1 ) \sigma ^ { 2 } } + 2 \underbrace { \sum _ { t = 1 } ^ { T - 2 } \operatorname { c o v } ( n ^ { t } , n ^ { t + 2 } ) } _ { \alpha ^ { 2 } ( T - 2 ) \sigma ^ { 2 } } + \dots + 2 \underbrace { \operatorname { c o v } ( n ^ { 1 } , n ^ { T } ) } _ { \alpha ^ { T - 1 } ( 1 ) \sigma ^ { 2 } } } \end{array}
+$$
+
+For negatively correlated noise $\alpha \in ( - 1 , 0 )$ we can bound this term by
+
+$$
+\begin{array} { r l } & { \Psi \big ( \displaystyle \sum _ { t = 1 } ^ { T } n ^ { t } \big ) = \sigma ^ { 2 } ( T + 2 \displaystyle \sum _ { \tau = 1 } ^ { T - 1 } \alpha ^ { \tau } ( T - \tau ) ) } \\ & { \qquad = \sigma ^ { 2 } ( T + 2 \frac { \alpha ^ { T + 1 } - \alpha ^ { 2 } T + \alpha T - \alpha } { ( \alpha - 1 ) ^ { 2 } } ) } \\ & { \qquad = \sigma ^ { 2 } ( T + 2 \underbrace { \frac { ( \alpha - \alpha ^ { 2 } ) } { ( \alpha - 1 ) ^ { 2 } } } _ { \le \frac { 1 } { 2 } \alpha } T + 2 \underbrace { \frac { \alpha ^ { T + 1 } - \alpha } { ( \alpha - 1 ) ^ { 2 } } } _ { \le \frac { 1 } { 2 } } ) } \\ & { \qquad \le \sigma ^ { 2 } ( T ( 1 + \alpha ) + 1 ) } \end{array}
+$$
+
+# 6.5 PROOF OF THEOREM 3.1.
+
+Proof. It holds that
+
+$$
+\mathrm { e r r } ( \mathcal { R } _ { T - 1 } + \Delta W _ { T } ) = \| \sum _ { t = 1 } ^ { T } \Delta W _ { t } - \sum _ { t = 1 } ^ { T - 1 } \Delta W _ { t } ^ { * } - \mathcal { R } _ { T - 1 } - \Delta W _ { T } \| = 0 .
+$$
+
+Since $s$ is a metric subspace, the projection
+
+$$
+\Delta W _ { T } ^ { * } = \mathrm { P r o j } _ { \cal S } ( { \mathcal { R } } _ { T - 1 } + \Delta W _ { T } )
+$$
+
+uniquely solves the minimization problem in $s$ .
+
+# 6.6 ADDITIONAL RESULTS
+
+Figure 6 shows validation error for WordLSTM trained on PTB at different levels of gradient sparsity and temporal sparsity. The total sparsity, defined as the product of temporal and gradient sparsity remains constant along the diagonals of the matrix. We observe that different forms of sparsity perform best during different stages of training. Phrased differently, this means that there is not one optimal sparsity setup, but rather sparsity needs to be adapted to the current training phase to achieve optimal compression.
+
+![](images/570169075c94d2ced3e9339b2521904bac6d1a28ed33fac971c71b090746e136.jpg)  
+Figure 6: Perplexity for different levels of gradient sparsity and temporal sparsity at different stages of training. WordLSTM trained on PTB.

parse/train/B1edvs05Y7/B1edvs05Y7_content_list.json

@@ -0,0 +1,1731 @@
+[
+    {
+        "type": "text",
+        "text": "SPARSE BINARY COMPRESSION: TOWARDS DISTRIBUTED DEEP LEARNING WITH MINIMAL COMMUNICATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            828,
+            170
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            195,
+            398,
+            223
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            261,
+            544,
+            275
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Currently, progressively larger deep neural networks are trained on ever growing data corpora. In result, distributed training schemes are becoming increasingly relevant. A major issue in distributed training is the limited communication bandwidth between contributing nodes or prohibitive communication cost in general. To mitigate this problem we propose Sparse Binary Compression (SBC), a compression framework that allows for a drastic reduction of communication cost for distributed training. SBC combines existing techniques of communication delay and gradient sparsification with a novel binarization method and optimal weight update encoding to push compression gains to new limits. By doing so, our method also allows us to smoothly trade-off gradient sparsity and temporal sparsity to adapt to the requirements of the learning task. Our experiments show, that SBC can reduce the upstream communication on a variety of convolutional and recurrent neural network architectures by more than four orders of magnitude without significantly harming the convergence speed in terms of forward-backward passes. For instance, we can train ResNet50 on ImageNet in the same number of iterations to the baseline accuracy, using $\\times 3 5 3 1$ less bits or train it to a $1 \\%$ lower accuracy using $\\times 3 7 2 0 8$ less bits. In the latter case, the total upstream communication required is cut from 125 terabytes to 3.35 gigabytes for every participating client. Our method also achieves state-of-the-art compression rates in a Federated Learning setting with 400 clients. ",
+        "bbox": [
+            233,
+            291,
+            766,
+            569
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            599,
+            336,
+            616
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Distributed Stochastic Gradient Descent (DSGD) is a training setting, in which a number of clients jointly trains a deep learning model using stochastic gradient descent (Dean et al., 2012; Recht et al., 2011; Moritz et al., 2015). Every client holds an individual subset of the training data, used to improve the current master model. The improvement is obtained by investing computational resources to perform iterations of stochastic gradient descent (SGD). This local training produces a weight update $\\Delta { \\boldsymbol { \\nu } } _ { }$ in every participating client, which in regular or irregular intervals (\"communication rounds\") is exchanged to produce a new master model. This exchange of weight updates can be performed indirectly via a centralized server or directly in an all-reduce operation. In both cases, all clients share the same master model after every communication round (see figure 1). In vanilla DSGD the clients have to communicate a full gradient update during every iteration. Every such update is of the same size as the full model, which can be in the range of gigabytes for modern architectures with millions of parameters (He et al., 2016; Huang et al., 2017). Over the course of multiple hundred thousands of training iterations on big datasets the total communication for every client can easily grow to more than a petabyte. Consequently, if communication bandwidth is limited, or communication is costly, distributed deep learning can become unproductive or even unfeasible. DSGD is a very popular training setting with many applications. On one end of the spectrum, DSGD can be used to greatly reduce the training time of large-scale deep learning models by introducing device-level data parallelism (Chilimbi et al., 2014; Zinkevich et al., 2010; Xing et al., 2015; Li et al., 2014), making use of the fact that the computation of a mini-batch gradient is perfectly parallelizable. In this setting, the clients are usually embodied by hardwired high-performance computation units (i.e. GPUs in a cluster) and every client performs one iteration of SGD per communication round. Since communication is high-frequent in this setting, bandwidth can be a significant bottleneck. On the other end of the spectrum DSGD can also be used to enable privacy-preserving deep learning (Shokri & Shmatikov, 2015; McMahan et al., 2016). Since the clients only ever share weight updates, DSGD makes it possible to train a model from the combined data of all clients without any individual client having to reveal their local training data to a centralized server. In this setting the clients typically are embedded or mobile devices with low network bandwidth, intermittent network connections, and an expensive mobile data plan. In both scenarios, the communication cost between the individual training nodes is a limiting factor for the performance of the whole learning system. For the synchronous distributed training scheme described above, the total amount of bits communicated by every client during training is given by ",
+        "bbox": [
+            174,
+            632,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/bbfd0bb297fd001cc86bbc18d700f0530cf52fa5b998b8a1e2263f9564a97595.jpg",
+        "image_caption": [
+            "Figure 1: One communication round of DSGD: a) Clients synchronize with the server. b) Clients compute a weight update independently based on their local data. c) Clients upload their local weight updates to the server, where they are averaged to produce the new master model. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            102,
+            821,
+            196
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            277,
+            825,
+            417
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ac59f44bd27c9292f6f0c84ff8f3b64592d4779f420d0e21eec435c791540086.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathsf { b } _ { t o t a l } \\in \\mathcal { O } ( \\underbrace { N _ { i t e r } \\times f } _ { \\# \\mathrm { c o m m u n i c a t i o n ~ r o u n d s } } \\times \\underbrace { | \\Delta \\mathcal { W } _ { \\neq 0 } | \\times ( \\bar { \\mathrm { b } } _ { p o s } + \\bar { \\mathrm { b } } _ { v a l } ) } _ { \\# \\mathrm { b i t s ~ p e r ~ c o m m u n i c a t i o n } } \\times \\underbrace { K } _ { \\# \\mathrm { r e c e i v i n g ~ n o d e s } } ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            240,
+            425,
+            758,
+            463
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $N _ { i t e r }$ is the total number of training iterations (forward-backward passes) every client performs, $f$ is the communication frequency, $| \\mathcal { W } _ { \\neq 0 } |$ is the sparsity of the weight update, $\\bar { \\mathrm { b } } _ { p o s }$ , $\\bar { \\mathrm { b } } _ { v a l }$ are the average number of bits required to communicate the position and the value of the non-zero elements respectively and $K$ is the number of receiving nodes (if $\\mathcal { W }$ is dense, the positions of all weights are predetermined and no position bits are required). ",
+        "bbox": [
+            174,
+            472,
+            825,
+            541
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Substantial research has gone into the effort of reducing the amount of communication necessary between the clients via lossy compression schemes. Using the systematic of equation 1, we can organize prior approaches into three different groups: ",
+        "bbox": [
+            174,
+            547,
+            825,
+            590
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Sparsification methods restrict weight updates to modifying only a small subset of the parameters, thus reducing $| \\Delta \\mathcal { W } _ { \\neq 0 } |$ . Strom (2015) presents an approach (later modified by Tsuzuku et al. (2018)) in which only gradients with a magnitude greater than a certain predefined threshold are sent to the server. All other gradients are aggregated into a residual. This method achieves compression rates of up to 3 orders of magnitude on an acoustic modeling task. In practice however, it is hard to choose appropriate values for the threshold, as it may vary a lot for different architectures and even different layers. Instead of using a fixed threshold to decide what gradient entries to send, Aji & Heafield (2017) use a fixed sparsity rate. They only communicate the fraction $p$ entries of the gradient with the biggest magnitude, while also collecting all other gradients in a residual. At a sparsity rate of $p = 0 . 0 0 1$ their method slightly degrades the convergence speed and final accuracy of the trained model. Lin et al. (2017) present modifications to the work of Aji et al. which close this performance gap. These modifications include using a curriculum to slowly increase the amount of sparsity in the first couple communication rounds and applying momentum factor masking to overcome the problem of gradient staleness. Their method achieves compression rates ranging from $\\times 2 7 0$ to $\\times 6 0 0$ on different architectures, without slowdown in convergence speed. ",
+        "bbox": [
+            173,
+            597,
+            825,
+            805
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Communication delay methods try to reduce the communication frequency $f$ . McMahan et al. (2016) propose Federated Averaging to reduce the cumulative communication. In Federated Averaging, instead of communicating after every iteration, every client performs multiple iterations of SGD to compute a weight update. The authors observe that this delay of communication does not significantly harm the convergence speed in terms of local iterations and report a reduction in the number of necessary communication rounds by a factor of $\\times 1 0 - \\times 1 0 0$ on different convolutional and recurrent neural network architectures. In a follow-up work Konecnˇ y et al. (2016) combine this \\` communication delay with random sparsification and probabilistic quantization. They restrict the clients to learn random sparse weight updates or force random sparsity on them afterwards (\"structured\" vs \"sketched\" updates) and combine this sparsification with probabilistic quantization. While their method also combines communication delay with (random) sparsification and quantization, and achieves good compression gains for one particular CNN and LSTM model, it also causes a major drop in convergence speed and final accuracy. ",
+        "bbox": [
+            174,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Dense quantization methods try to reduce the amount of value bits $\\bar { \\mathrm { b } } _ { v a l }$ . Different quantization methods have been proposed that reduce the bit-width of the gradients to ternary (Wen et al., 2017), binary (Seide et al., 2014; Bernstein et al., 2018) or arbitrary (Alistarh et al., 2017) bitwidths. While these are theoretically well-founded and come with strong convergence guarantees, they are also limited to a maximum compression rate of $\\times 3 2$ , compared to the regular 32-bit encoding. ",
+        "bbox": [
+            174,
+            180,
+            825,
+            251
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/16ab61f604048fb48daa23d796e8a481a8582f980e2571e696a8d2c176a492d9.jpg",
+        "image_caption": [
+            "2 ON THE ACCUMULATION OF GRADIENT INFORMATION ",
+            "Figure 2: Sources of noise in SGD (illustration): Left: Optimization noise, caused by Gradient Descent overshooting. Bouncing between the walls of the ravine results in negatively correlated noise. Middle: Batch noise, caused by the batch loss being only a noisy approximation of the full empirical loss. Right: The compressed path converges equally fast, but requires only half of the information to be communicated. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            311,
+            813,
+            462
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Communication delay and sparsification methods as described above already achieve impressive compression rates, however the phenomenon underlying their successes is still only poorly understood. We present a new information-theoretic perspective that is based on the observation that both of these approaches achieve compression by accumulating gradient information locally before sending it to the server. In the case of communication delay all gradients are accumulated uniformly for a fixed amount of iterations, while in the case of sparsification methods they are accumulated non-uniformly until they exceed some fixed or adaptive threshold. In both cases the rate of compression is proportional to the number of steps that the updates are being delayed on average. ",
+        "bbox": [
+            173,
+            575,
+            825,
+            688
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Consider now the optimization path $\\Delta { \\mathcal { W } } _ { 1 } , . . , \\Delta { \\mathcal { W } } _ { T }$ taken by SGD on the loss-surface between some initialization point W0 and the model WT = W0 + PTt=1 trained for $T$ iterations. Following this path, we can model the changes occurring to any individual weight in the network $w$ as a noisy stochastic process via ",
+        "bbox": [
+            173,
+            694,
+            825,
+            753
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/212cc9d07000b4c26ebe3a0ebc31c73015c3a608b0dadadbb12c62dd4aeb7834.jpg",
+        "text": "$$\n\\Delta w ^ { t } = s ^ { t } + n ^ { t } , t = 1 , . . , T\n$$",
+        "text_format": "latex",
+        "bbox": [
+            405,
+            758,
+            593,
+            776
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $s ^ { t }$ denotes the deterministic signal (i.e. the true direction of the minimum), while $n ^ { t }$ denotes the noise, induced by mini-batch sampling in SGD (\"batch noise\") and the stochasticity of the learning process itself (\"optimization noise\", see figure 2 for an illustration). For the sake of simplicity, and motivated by the central limit theorem we can assume (a) that this noise $n ^ { t }$ is normally distributed at every time-step $n ^ { t } \\sim \\mathcal N ( 0 , \\sigma ^ { 2 } )$ with the variance being constant in time $\\mathbb { V } ( n ^ { t } ) \\stackrel { } { = } \\sigma ^ { 2 }$ for all $t = 1 , . . , T$ . Since the optimization process has the tendency to damp noise as investigated for instance in LeCun et al. (2012) it is also reasonable to assume (b) that the noise is (negatively) self-correlated. The noise process is then given by $n ^ { 1 } = N ^ { 1 }$ , $n ^ { t } = \\alpha n ^ { t - 1 } + N ^ { t }$ , with $N ^ { t }$ normally distributed and all $N ^ { t }$ uncorrelated, $\\alpha \\in ( - 1 , 0 )$ . Given these assumptions we can bound the variance of the accumulated parameter updates. ",
+        "bbox": [
+            173,
+            784,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Theorem 2.1. Under assumptions (a) and $( b )$ , the variance of the accumulated noise can be bounded by ",
+        "bbox": [
+            169,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3e50afe126f9219429604be541b8722ca97970ba408426584698260b8bb18bee.jpg",
+        "text": "$$\n\\mathbb { V } ( \\sum _ { t = 1 } ^ { T } n ^ { t } ) \\le \\sigma ^ { 2 } ( T ( 1 + \\alpha ) + 1 ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            388,
+            133,
+            607,
+            179
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The proof can be found in the supplement. Theorem 2.1 directly leads us to a lower bound on the signal-to-noise ratio of the accumulated weight-updates: ",
+        "bbox": [
+            173,
+            188,
+            823,
+            217
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Corollary 2.1.1. Under assumptions (a) and $( b )$ , accumulation increases the signal-to-noise ratio from $\\bar { s } / \\sigma$ to ",
+        "bbox": [
+            174,
+            219,
+            823,
+            247
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8aeac17ad38dd000580db3076e0296f4067b67d75ea14f49551154c2d8042370.jpg",
+        "text": "$$\nS N R ( \\sum _ { t = 1 } ^ { T } \\Delta w ^ { t } ) = \\frac { \\mathbb { E } [ \\sum _ { t = 1 } ^ { T } s ^ { t } + n ^ { t } ] } { \\sqrt { \\mathbb { V } [ \\sum _ { t = 1 } ^ { T } s ^ { t } + n ^ { t } ] } } \\geq \\frac { \\sum _ { t = 1 } ^ { T } s ^ { t } } { \\sqrt { \\sigma ^ { 2 } ( T ( 1 + \\alpha ) + 1 ) } } \\approx \\frac { \\sqrt { T } } { \\sqrt { 1 + \\alpha } } \\frac { \\bar { s } } { \\sigma }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            241,
+            251,
+            756,
+            300
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "$\\begin{array} { r } { \\bar { s } = \\frac { 1 } { T } \\sum _ { t = 1 } ^ { T } { s ^ { t } } } \\end{array}$ being the signal-average over time. ",
+        "bbox": [
+            173,
+            303,
+            544,
+            323
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "This means that a weight-update will be more informative the longer the accumulation period and the stronger the noise correlates temporally. Convergence speed will not be compromised for as long as the information content of the accumulated update is equal to the cumulative information content of the individual updates (c.f. fig. 2 (c)). This line of reasoning helps to shed light on both the successes of communication delay and gradient sparsification. In fact, it implies that both of these approaches are actually very similar in the way they affect the information flow from client to server on the individual weight level. ",
+        "bbox": [
+            173,
+            330,
+            825,
+            429
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We find that this intuition is also verified empirically. Figure 3 shows validation errors for ResNet32 model trained on CIFAR for 60000 iterations at different levels of communication delay and gradient sparsity. We observe multiple things: 1.) The validation error remains more or less constant along the off-diagonals of the matrix where the total sparsity (i.e. the product of communication delay and gradient sparsity) is constant. 2.) The existing methods of Federated Averaging (McMahan et al., 2016) (purple) and Gradient Dropping/ DGC (Aji & Heafield, 2017; Lin et al., 2017)(yellow) are just lines in the two-dimensional space of possible compression methods. 3.) There exists a roughly triangular area of approximately constant error, optimal compression methods lie along the hypotenuse of this triangle. We find this behavior consistently across different model architectures, more examples can be found in the supplement. These results indicate, that communication delay and sparsification affect the convergence in a roughly multiplicative way and that there seems to exist a fixed information budged in DSGD, necessary to maintain unhindered convergence. ",
+        "bbox": [
+            174,
+            436,
+            486,
+            781
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/19e7ea356464d3e97b87fc82605d547a43177538b4a6011a877d3cd1804c873b.jpg",
+        "image_caption": [
+            "Figure 3: Validation Error for ResNet32 trained on CIFAR at different levels of temporal and gradient sparsity (the error is color-coded, brighter means lower error). The prior approaches of Gradient Dropping and Federated Averaging can be embedded in a two-dimensional compression framework. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            506,
+            458,
+            816,
+            667
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In the following we present a framework that allows us to smoothly trade of these two types of gradient accumulation against one another. By doing so our proposed framework can adapt to the requirements of the distributed learning environment and achieve state-of-the-art compression results by reaping the benefits from both approaches. ",
+        "bbox": [
+            174,
+            790,
+            826,
+            845
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 SPARSE BINARY COMPRESSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            864,
+            468,
+            881
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Inspired by our findings in the previous section, we propose Sparse Binary Compression (cf. Figure 4), to drastically reduce the number of communicated bits in distributed training. SBC makes use of multiple compression techniques simultaneously1 to reduce all multiplicative components of equation 1. ",
+        "bbox": [
+            173,
+            895,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            825,
+            133
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/746065ec084d2fd326f7cabd07148c0086f6a804fe554d6536ad8c47ebeb85ba.jpg",
+        "image_caption": [
+            "Figure 4: Step-by-step explanation of techniques used in Sparse Binary Compression: (a) Illustrated is the traversal of the parameter space with regular DSGD (left) and Federated Averaging (right). With this form of communication delay, a bigger region of the loss surface can be traversed, in the same number of communication rounds. That way compression gains of up to $\\times 1 0 0 0$ are possible. After a number of iterations, the clients communicate their locally computed weight updates. (b) Before communication, the weight update is first sparsified, by dropping all but the fraction $p$ weight updates with the highest magnitude. This achieves up to $\\times 1 0 0 0$ compression gain. (c) Then the sparse weight update is binarized for an additional compression gain of approximately $\\times 3 .$ . (d) Finally, we optimally encode the positions of the non-zero elements, using Golomb encoding. This reduces the bit size of the compressed weight update by up to another $\\times 2$ compared to naive encoding. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            154,
+            823,
+            289
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In the following $\\mathcal { W }$ will refer to the entirety of neural network parameters, while $W \\in { \\mathcal { W } }$ will refer to one specific tensor of weights. Arithmetic operations on $\\mathcal { W }$ are to be understood componentwise. ",
+        "bbox": [
+            174,
+            474,
+            823,
+            503
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Communication Delay, Fig. 4 (a): We use communication delay, proposed by McMahan et al. (2016), to introduce temporal sparsity into DSGD. Instead of communicating gradients after every local iteration, we allow the clients to compute more informative updates by performing multiple iterations of SGD. These generalized weight updates are given by ",
+        "bbox": [
+            174,
+            511,
+            825,
+            566
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4cdccd4925160236acbf7ccbf55ac4487b4a76c3669dda1dd2e408f484d6e75c.jpg",
+        "text": "$$\n\\Delta \\mathcal { W } _ { i } = \\mathrm { S G D } _ { n } ( \\mathcal { W } _ { i } , D _ { i } ) - \\mathcal { W } _ { i }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            397,
+            574,
+            601,
+            592
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathrm { S G D } _ { n } ( \\mathcal { W } _ { i } , D _ { i } )$ refers to the set of weights obtained by performing $n$ iterations of stochastic gradient descent on $\\mathcal { W } _ { i }$ , while sampling mini-batches from the i-th client’s training data $D _ { i }$ . Empirical analysis by McMahan et al. (2016) suggests that communication can be delayed drastically, with only marginal degradation of accuracy. For $n = 1$ we obtain regular DSGD. ",
+        "bbox": [
+            174,
+            599,
+            825,
+            655
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Sparse Binarization, Fig. 4 (b), (c): Following the works of Lin et al. (2017)Strom (2015)Shokri & Shmatikov (2015) and Aji & Heafield (2017) we use the magnitude of an individual weight within a weight update as a heuristic for it’s importance. First, we set all but the fraction $p$ biggest and fraction $p$ smallest weight updates to zero. Next, we compute the mean of all remaining positive and all remaining negative weight updates independently. If the positive mean $\\mu ^ { + }$ is bigger than the absolute negative mean $\\mu ^ { - }$ , we set all negative values to zero and all positive values to the positive mean and vice versa. The method is illustrated in figure 4 and formalized in algorithm 2. Finding the fraction $p$ smallest and biggest values in a vector $W$ requires $\\mathcal { O } ( | W | )$ operations, where $| W |$ refers to the number of elements in $W$ (Cormen et al., 2009). Lin et al. (2017) suggest to reduce the computational cost of this operation, by randomly subsampling from $W$ . However this comes at the cost of introducing (unbiased) noise in the amount of sparsity. Luckily, in our approach communication rounds (and thus compressions) are relatively infrequent, which helps to marginalize the overhead of the sparsification. Quantizing the non-zero elements of the sparsified weight update to the mean reduces the required value bits $\\bar { b } _ { v a l }$ from 32 to $O$ . This translates to a reduction in communication cost by a factor of around $\\times 3$ . We can get away with averaging out the non-zero weight updates because they are relatively homogeneous in value and because we accumulate our compression errors as described in the next paragraph. ",
+        "bbox": [
+            173,
+            661,
+            825,
+            898
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Residual Accumulation, Fig. 4 (d): It is well established (Lin et al., 2017; Strom, 2015; Aji & Heafield, 2017; Seide et al., 2014) that the convergence in sparsified DSGD can be greatly accelerated by accumulating the error that arises from only sending sparse approximations of the weight updates. After every communication round, the residual is updated via ",
+        "bbox": [
+            174,
+            102,
+            826,
+            160
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7957f127b7bd68af2a12aed9b7dcdf5151a480ef6a46694ff1fe491e5d715362.jpg",
+        "text": "$$\n\\mathcal { R } _ { \\tau } = \\sum _ { t = 1 } ^ { \\tau } ( \\Delta \\mathcal { W } _ { t } - \\Delta \\mathcal { W } _ { t } ^ { * } ) = \\mathcal { R } _ { \\tau - 1 } + \\Delta \\mathcal { W } _ { \\tau } - \\Delta \\mathcal { W } _ { \\tau } ^ { * } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            318,
+            165,
+            678,
+            205
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Error accumulation has the great benefit that no gradient information is lost (it may only become outdated or \"stale\"). In the context of pure sparsification residual accumulation can be interpreted to be equivalent to increasing the batch size for individual parameters (Lin et al., 2017). Moreover, we can show: ",
+        "bbox": [
+            173,
+            209,
+            825,
+            265
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Theorem 3.1. Let $\\Delta W _ { 1 } , . . , \\Delta W _ { T } \\in \\mathbb { R } ^ { n }$ be (flattened) weight updates, computed by one client in the first $T$ communication rounds. Let $\\Delta W _ { 1 } ^ { * } , . . , \\Delta W _ { T - 1 } ^ { * } \\in \\mathcal { S }$ be the actual weight updates, transferred in the previous rounds (restricted to some subspace $s$ ) and $\\mathcal { R } _ { \\tau }$ be the content of the residual at time $\\tau$ as in equation 5. Then the orthogonal projection ",
+        "bbox": [
+            173,
+            268,
+            825,
+            327
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f1edfcb24ae965d3dac24d1b3e5923d9265aa5a0223e3ceaceac22b26a5bd41a.jpg",
+        "text": "$$\nv = P r o j _ { S } ( \\mathcal { R } _ { T - 1 } + \\Delta W _ { T } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            406,
+            332,
+            591,
+            348
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "uniquely minimizes the accumulated error ",
+        "bbox": [
+            176,
+            354,
+            450,
+            368
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d9f2e3ca7cdbf91322cfc33ff4f49053768053c7fac01d6dc2bd0aa9019037c8.jpg",
+        "text": "$$\n\\operatorname { e r r } ( \\Delta W _ { T } ^ { * } ) = \\| \\sum _ { t = 1 } ^ { T } ( \\Delta W _ { t } - \\Delta W _ { t } ^ { * } ) \\|\n$$",
+        "text_format": "latex",
+        "bbox": [
+            375,
+            373,
+            620,
+            416
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "in S. (Proof in Supplement.) ",
+        "bbox": [
+            174,
+            420,
+            362,
+            435
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "That means that the residual accumulation keeps the compressed optimization path as close as possible to optimization path taken with non-compressed weight updates. ",
+        "bbox": [
+            173,
+            445,
+            825,
+            476
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/3a361b943354d85061c8a4c1066e16be2c3a436797fb607cf9b315eb92aa7e0e.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>Algorithm 1: SynchronousDistributed Stochastic Gradient Descent (DSGD)</td></tr><tr><td></td><td>input: initial parameters W 2 outout: improved parameters W 3 init:all clients Ci are initialized with the</td></tr><tr><td></td><td>same parameters Wi ← W, the initial</td></tr><tr><td></td><td>global weight update and the residuals are set to zero △W,Ri←0</td></tr><tr><td></td><td>4 for t=1,..,T do for i∈ It ≌ {1,..,M} in parallel do</td></tr><tr><td>5 6</td><td>Client Ci does:</td></tr><tr><td>7</td><td>· msg ← downloads→C (msg)</td></tr><tr><td>8</td><td>· △W ← decode(msg)</td></tr><tr><td></td><td>·Wi←Wi+△W</td></tr><tr><td>9</td><td>· △Wi ← Ri+SGDn(Wi,Di)-Wi</td></tr><tr><td>10 11</td><td>· △W* ← compress(△Wi)</td></tr><tr><td>12</td><td>·Ri←△Wi-△W*</td></tr><tr><td></td><td>· msg: ← encode(△W*)</td></tr><tr><td>13 14</td><td>· uploadci→s(msg;)</td></tr><tr><td>15</td><td>end</td></tr><tr><td>16</td><td>Server S does:</td></tr><tr><td>17</td><td>： gatherci→s(△W*), i ∈ It</td></tr><tr><td>18</td><td>△W← £ielt △W*</td></tr><tr><td></td><td>. W←W+△W</td></tr><tr><td>19</td><td></td></tr><tr><td>20</td><td>broadcasts→c (△W), i=1,..,M</td></tr><tr><td>21</td><td>end</td></tr></table>",
+        "bbox": [
+            156,
+            501,
+            470,
+            916
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 2: Sparse Binary Compression ",
+        "text_level": 1,
+        "bbox": [
+            531,
+            503,
+            803,
+            518
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "1 input: tensor $\\Delta W$ , sparsity $p$   \n2 output: sparse tensor $\\Delta W ^ { * }$   \n$\\begin{array} { r l r } { { 3 } } & { { } \\bullet } & { \\mathrm { v a l ^ { + } }  \\mathrm { t o p } _ { p \\% } ( \\Delta W ) ; } \\end{array}$ ;   \n$\\begin{array} { r } { \\mathbf { \\Sigma } ^ { \\mathbf { \\textsc { v a l } } } \\mathbf { \\Sigma } ^ {  } \\mathbf { \\Sigma } ^ { \\mathbf { w p } } p \\% \\mathbf { \\Sigma } ^ { \\lfloor \\Delta \\nu \\nu \\rfloor , } } \\\\ { \\mathbf { v a l } ^ { - }  \\mathbf { t o p } _ { p \\% } ( - \\Delta W ) } \\end{array}$   \n${ \\mathfrak { a } } \\bullet \\mu ^ { + }  \\operatorname { m e a n } ( \\mathrm { v a l } ^ { + } ) ; \\mu ^ { - }  \\operatorname { m e a n } ( \\mathrm { v a l } ^ { - } )$ 5 if $\\mu ^ { + } \\geq \\mu ^ { - }$ then   \n6 return $\\Delta W ^ { * } \\gets \\mu ^ { + } ( W \\geq \\mathrm { \\ m i n } ( \\mathrm { v a l } ^ { + } ) )$ 7 else   \n8 return   \n$\\Delta W ^ { * } \\gets - \\mu ^ { - } ( W \\le - \\operatorname* { m i n } ( \\mathrm { v a l } ^ { - } ) )$ 9 end ",
+        "bbox": [
+            513,
+            521,
+            815,
+            690
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 3: Golomb Position Encoding ",
+        "text_level": 1,
+        "bbox": [
+            531,
+            703,
+            803,
+            718
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "1 input: sparse tensor $\\Delta W ^ { * }$ , sparsity $p$   \n2 output: binary message msg   \n3 • $\\bar { \\mathcal { T } }  \\Delta W ^ { * } [ : ] _ { \\neq 0 }$   \n4 $\\begin{array} { r } { \\bullet \\ \\mathbf { b } ^ { * }  1 + \\lfloor \\log _ { 2 } ( \\frac { \\log ( \\phi - 1 ) } { \\log ( 1 - p ) } ) \\rfloor } \\end{array}$   \n5 for $i = 1 , . . , | \\mathcal { T } |$ do   \n6 • d ← Ii − Ii−1   \n7 • q ← (d − 1) div 2b∗   \n8 • r ← (d − 1) mod 2b∗   \n9 • msg.add(1, .., 1, 0, binaryb∗ (r))   \n| {z }q times   \n10 end   \n11 return msg ",
+        "bbox": [
+            511,
+            722,
+            779,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Optimal Position Encoding, Fig. 4 (e): To communicate a set of sparse binary tensors produced by SGC, we only need to transfer the positions of the non-zero elements in the flattened tensors, along with one mean value $\\mu ^ { + }$ or $\\mu ^ { - }$ ) per tensor. Instead of communicating the absolute non-zero positions it is favorable to only communicate the distances between all non-zero elements. It is possible to show that for big values of $| W |$ and $k = p | W |$ , the distances are approximately geometrically distributed with success probability equal to the sparsity rate $p$ . Therefore, we can optimally encode the distances using the Golomb code Golomb (1966). Golomb encoding reduces the average number of position bits to ",
+        "bbox": [
+            173,
+            103,
+            825,
+            214
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/58115fb3f1a70efec6240601a5598074aca3d17819c345d53bae82c627f2925c.jpg",
+        "text": "$$\n\\bar { \\mathrm { b } } _ { p o s } = \\mathbf { b } ^ { * } + \\frac { 1 } { 1 - ( 1 - p ) ^ { 2 ^ { \\mathbf { b } ^ { * } } } } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            398,
+            214,
+            598,
+            248
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "with b∗ = 1 + blog2( log(φ−1)log(1−p) ) and $\\textstyle \\phi = { \\frac { { \\sqrt { 5 } } + 1 } { 2 } }$ being the golden ratio. For a sparsity rate of i.e. $p = 0 . 0 1$ , we get $\\bar { \\mathrm { b } } _ { p o s } = 8 . 3 8$ , which translates to $\\times 1 . 9$ compression, compared to a naive distance encoding with 16 fixed bits. While the overhead for encoding and decoding makes it unproductive to use Golomb encoding in the situation of Strom (2015), this overhead becomes negligible in our situation due to the infrequency of weight update exchange resulting from communication delay. The encoding scheme is given in algorithm 3, while the decoding scheme can be found in the supplement. ",
+        "bbox": [
+            173,
+            252,
+            825,
+            343
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Momentum Correction, Warm-up Training and Momentum Masking: Lin et al. (2017) introduce multiple minor modifications to the vanilla Gradient Dropping method, to improve the convergence speed. We adopt momentum masking, while momentum correction is implicit to our approach. For more details on this we refer to the supplement. ",
+        "bbox": [
+            173,
+            349,
+            825,
+            405
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Our proposed method is described in Algorithms 1, 2 and 3. Algorithm 1 describes how compression and residual accumulation can be introduced into DSGD. Algorithm 2 describes our compression method. Algorithm 3 describes the Golomb encoding. Table 1 compares theoretical asymptotic compression rates of different popular compression methods. ",
+        "bbox": [
+            174,
+            425,
+            823,
+            483
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/0d8e73349a2fa9c63af9ebd71026ef096188627a1e38ad9067835ebe334c3e62.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"2\">Total Bits =</td><td>Baseline</td><td>SignSGD, TernGrad, QSGD</td><td>Gradient Dropping, DGC</td><td>Federated Averaging</td><td>Sparse Binary Compression</td></tr><tr><td rowspan=\"3\">×</td><td>Temporal Sparsity</td><td>100%</td><td>100%</td><td>100%</td><td>0.1% - 10%</td><td>0.1% - 10%</td></tr><tr><td>Gradient Sparsity</td><td>100%</td><td>100%</td><td>0.1%</td><td>100%</td><td>0.1% - 10%</td></tr><tr><td>Value Bits</td><td>32</td><td>1-8</td><td>32</td><td>32</td><td>0</td></tr><tr><td colspan=\"2\">×M Position Bits</td><td>0</td><td>0</td><td>16</td><td>0</td><td>8-14</td></tr><tr><td colspan=\"2\">Compression Rate</td><td>×1</td><td>×4-×32</td><td>×666</td><td>×10-×1000</td><td>-×40000</td></tr></table>",
+        "bbox": [
+            210,
+            494,
+            781,
+            599
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 1: Theoretical asymptotic compression rates for different compression methods broken down into components. Only SBC reduces all multiplicative components of the total bitsize (cf. eq. 1). ",
+        "bbox": [
+            173,
+            616,
+            825,
+            643
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            670,
+            326,
+            686
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.1 NETWORKS AND DATASETS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            700,
+            406,
+            715
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We evaluate our method on commonly used convolutional and recurrent neural networks with millions of parameters, which we train on well-studied data sets that contain up to multiple millions of samples. We perform experiments with client numbers ranging from 4 to 400 to cover both the distributed training and federated learning use-case. ",
+        "bbox": [
+            173,
+            727,
+            825,
+            784
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Image Classification: We run experiments for LeNet5-Caffe2 on MNIST LeCun (1998), ResNet18 and ResNet34 He et al. (2016) on CIFAR-10 and CIFAR-100 Krizhevsky et al. (2014) and ResNet50 on ILSVRC12 (ImageNet) Deng et al. (2009). For the i.i.d. setting we split the training data randomly into equally sized shards and assign one shard to every one of the clients. For the non-i.i.d. setting every client is assigned samples from only two classes of the dataset, but the amount of data still remains the same for every client. All models are trained using momentum SGD, except for LeNet5- Caffe, which is trained using the Adam optimizer Kingma & Ba (2014). Learning rate, weight intitiallization and data augmentation are as in the respective papers. ",
+        "bbox": [
+            173,
+            789,
+            825,
+            901
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/6f2a8da4af23d87f744e29a96644bcf36b3979838035ad76eea271fcb8482842.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"2\">Compression Method -→</td><td>Baseline</td><td>DGC3</td><td>Federated Averaging4</td><td>SBC (1)</td><td>SBC (2)</td><td>SBC (3)</td></tr><tr><td rowspan=\"9\">taprrisititt</td><td>LeNet5-Caffe @MNIST</td><td>Accuracy</td><td>0.9946</td><td>0.994</td><td>0.994</td><td>0.994</td><td>0.994</td><td>0.991</td></tr><tr><td></td><td>Compression</td><td>×1</td><td>×718</td><td>×500</td><td>×2071</td><td>×3166</td><td>×24935</td></tr><tr><td>ResNet18 @CIFAR10</td><td>Accuracy</td><td>0.946</td><td>0.9383</td><td>0.9279</td><td>0.9422</td><td>0.9435</td><td>0.9219</td></tr><tr><td>ResNet34</td><td>Compression Accuracy</td><td>×1</td><td>×768</td><td>×1000</td><td>×2369</td><td>×3491 0.7655</td><td>× 31664 0.701</td></tr><tr><td>@CIFAR100</td><td>Compression</td><td>0.773 ×1</td><td>0.767 ×718</td><td>0.7316</td><td>0.767 ×2370</td><td>×3166</td><td>×31664</td></tr><tr><td>ResNet50</td><td>Accuracy</td><td>0.737</td><td>0.739</td><td>×1000 0.724</td><td>0.735</td><td>0.737</td><td>0.728</td></tr><tr><td>@ImageNet</td><td>Compression</td><td>×1</td><td>×601</td><td>×1000</td><td>×2569</td><td>×3531</td><td>×37208</td></tr><tr><td>WordLSTM</td><td>Perplexity</td><td>76.02</td><td>75.98</td><td>76.37</td><td>77.73</td><td>78.19</td><td>77.57</td></tr><tr><td>@PTB</td><td>Compression</td><td>×1</td><td>×719</td><td>×1000</td><td>×2371</td><td>×3165</td><td>×31658</td></tr><tr><td>WordLSTM*</td><td>Perplexity</td><td>101.5</td><td>102.318</td><td>131.51</td><td>103.95</td><td>103.95</td><td>104.62</td></tr><tr><td>@WIKI</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td>Compression</td><td></td><td>×719</td><td>×1000</td><td>×2371</td><td>×3165</td><td>×31657</td></tr><tr><td></td><td></td><td>×1</td><td></td><td></td><td></td><td></td><td></td></tr></table>",
+        "bbox": [
+            179,
+            101,
+            825,
+            297
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 2: Final accuracy/perplexity achieved on the test split and average compression rate for different compression schemes in a distributed training setting with different numbers of clients. ",
+        "bbox": [
+            174,
+            318,
+            823,
+            345
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Language Modeling: We experiment with multilayer sequence-to-sequence LSTM models as described in Zaremba et al. (2014) on the Penn Treebank (PTB) Marcus et al. (1993) and Wikitext-2 corpora for next-word prediction. The PTB dataset consists of a sequence 923000 training, and 82000 validation words, while the Wikitext-2 dataset contains 2088628 train and 245569 test words. On both datasets we train a two-layer LSTM model with 650 and 200 hidden units respectively (\"WordLSTM\" / \"WordLSTM\\*\") with tied weights between encoder and decoder as described in Inan et al. (2016). The training data is split into consecutive subsequences of equal length, out of which we assign one to every client. ",
+        "bbox": [
+            173,
+            377,
+            825,
+            488
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "While the models we use in our experiments do not fully achieve state-of-the-art results on the respective tasks and datasets, they are still sufficient for the purpose of evaluating our compression method and demonstrate, that our method works well with common regularization techniques such as batch normalization Ioffe & Szegedy (2015) and dropout Srivastava et al. (2014). A complete description of models and hyperparameters can be found in the supplement. ",
+        "bbox": [
+            174,
+            496,
+            825,
+            565
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.2 RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            587,
+            277,
+            601
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We experiment with three configurations of our method: SBC (1) uses no communication delay and a gradient sparsity of $0 . 1 \\%$ , SBC (2) uses 10 iterations of communication delay and $1 \\%$ gradient sparsity and SBC (3) uses 100 iterations of communication delay and $1 \\%$ gradient sparsity. Our decision for these points on the 2D grid of possible configurations is somewhat arbitrary. The experiments with SBC (1) serve the purpose of enabling us to directly compare our 0-value-bit quantization to the 32-value-bit Deep Gradient Compression (Lin et al., 2017)). ",
+        "bbox": [
+            174,
+            614,
+            825,
+            699
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 2 lists compression rates and final validation accuracies achieved by different compression methods, when applied to the training of neural networks on 5 different datasets. The number of iterations (forward-backward-passes) is held constant for all methods. On all benchmarks, our methods perform comparable to the baseline, while communicating significantly less bits. ",
+        "bbox": [
+            174,
+            705,
+            825,
+            762
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Figure 5 shows convergence speed in terms of iterations (left) and communicated bits (right) respectively for ResNet50 trained on ImageNet. The convergence speed is only marginally affected, by our different compression methods. In the first 30 epochs SBC (3) even achieves the highest accuracy, using about $\\times 3 7 0 0 0$ less bits than the baseline. In total, SBC (3) reduces the upstream communication on this benchmark from 125 terabytes to 3.35 gigabytes for every participating client. After the learning rate is lowered in epochs 30 and 60 progress slows down for SBC (3) relative to the ",
+        "bbox": [
+            173,
+            768,
+            825,
+            852
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/da3d8276997d2b2ced675ea1d0e165cbf581e3ef4793256517730cc531ffed55.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=2 colspan=1></td><td rowspan=1 colspan=2>Compression Method -→</td><td rowspan=1 colspan=1>Baseline</td><td rowspan=1 colspan=1>GradientDroping</td><td rowspan=1 colspan=1>FederatedAveraging</td><td rowspan=1 colspan=1>SBC (1)</td><td rowspan=1 colspan=1>SBC (2)</td><td rowspan=1 colspan=1>SBC (3)</td></tr><tr><td rowspan=1 colspan=8> i.i.d. data</td></tr><tr><td rowspan=1 colspan=1>50</td><td rowspan=1 colspan=1>ResNet18*5@CIFAR10</td><td rowspan=1 colspan=1>AccuracyCompression</td><td rowspan=1 colspan=1>0.9254×1</td><td rowspan=1 colspan=1>0.9167×713</td><td rowspan=1 colspan=1>0.911×100</td><td rowspan=1 colspan=1>0.921×2362</td><td rowspan=1 colspan=1>0.902×3166</td><td rowspan=1 colspan=1>0.906×31664</td></tr><tr><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>LeNet5-Caffe@MNIST</td><td rowspan=1 colspan=1>AccuracyCompression</td><td rowspan=1 colspan=1>0.979×1</td><td rowspan=1 colspan=1>0.9811×714</td><td rowspan=1 colspan=1>0.967×100</td><td rowspan=1 colspan=1>0.979×2363</td><td rowspan=1 colspan=1>0.9818×3165</td><td rowspan=1 colspan=1>0.9536×31655</td></tr><tr><td rowspan=1 colspan=1>300</td><td rowspan=1 colspan=1>LeNet5-Caffe@MNIST</td><td rowspan=1 colspan=1>AccuracyCompression</td><td rowspan=1 colspan=1>0.9758×1</td><td rowspan=1 colspan=1>0.9744×714</td><td rowspan=1 colspan=1>0.899×100</td><td rowspan=1 colspan=1>0.9731×2363</td><td rowspan=1 colspan=1>0.9733×3165</td><td rowspan=1 colspan=1>0.8919×31655</td></tr><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=8> non-i.i.d. data</td></tr><tr><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>LeNet5-Caffe@MNIST</td><td rowspan=1 colspan=1> AccuracyCompression</td><td rowspan=1 colspan=1>0.9506×1</td><td rowspan=1 colspan=1>0.9498×714</td><td rowspan=1 colspan=1>0.8592×100</td><td rowspan=1 colspan=1>0.9522×2363</td><td rowspan=1 colspan=1>0.9583×3165</td><td rowspan=1 colspan=1>0.8344×31655</td></tr></table>",
+        "bbox": [
+            178,
+            101,
+            820,
+            275
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Table 3: Final accuracy achieved on the test split and average compression rate for different compression schemes in a Federated learning setting with different numbers of clients. ",
+        "bbox": [
+            173,
+            294,
+            825,
+            321
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "methods which do not use communication delay. In direct comparison SBC (1) performs very similar to Gradient Dropping, while using about $\\times 4$ less bits (that is $\\times 2 5 6 9$ less bits than the baseline). ",
+        "bbox": [
+            174,
+            348,
+            825,
+            376
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/d95f32a3debc2a8c33cf286c97024edb8738782ebd2391fe72729308fd25a2b0.jpg",
+        "image_caption": [
+            "Figure 5: Left: Top-1 validation accuracy vs number of epochs. Right: Top-1 validation error vs number of transferred bits (log-log). Epochs 30 and 60 at which the learning rate is reduced are marked in the plot. ResNet50 trained on ImageNet. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            395,
+            802,
+            571
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Table 3 shows results for the federated learning setting with much higher numbers of clients trained on both i.i.d. and non-i.i.d. splits of data. We can see that in particular with growing numbers of clients and in the non-i.i.d. case, Federated Averaging significantly slows down the convergence and degrades the final accuracy. SBC (3) also suffers in this scenario as is also relies on 100 steps of communication delay. Conversely, our methods SBC (1) and (2) that rely more heavily on gradient sparsification perform much better in this setting and in some cases even beat the baseline. This behavior is expected, as the frequent exchange of gradient information in SBC (1) and (2) keeps all clients aligned, while they diverge further from one another for every iteration that communication is delayed in Federated Averaging. ",
+        "bbox": [
+            174,
+            656,
+            825,
+            782
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Our experiments suggest that the distinction between the two formerly treated as separate distributed training settings of federated learning and data-parallel training is somewhat arbitrary and misleading and that better results can be achieved by combining the best approaches from both of these worlds. Contrary to the paradigm suggested in previous literature (McMahan et al., 2016), communication delay does not seem to be a well-suited approach for communication reduction in the federated learning setting. Instead our experiments demonstrate, that drastically better performance can be achieved under an even lower communication budged, if individual weight-updates are sparsified instead of delayed. On the other hand, it’s easy to see that communication delay has the potential to speed-up parallel training as it allows the individual computation devices to perform multiple steps of SGD without interruption. Our experiments with 4 clients demonstrate that introducing communication delay into data parallel training is not harmful to the convergence of the model in terms of training iterations. ",
+        "bbox": [
+            174,
+            789,
+            825,
+            900
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            159
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            181,
+            318,
+            196
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The gradient information for training deep neural networks with SGD is highly redundant (see e.g. Lin et al. (2017)). We exploit this fact to the extreme by combining 3 powerful compression strategies and are able to achieve compression gains of up to four orders of magnitude with only a slight decrease in accuracy. More fundamentally, we present theoretical and empirical evidence suggesting that the formerly treated as separate compression methods of communication delay and gradient sparsification in fact can be viewed as two very similar forms of gradient delay that affect the convergence speed in a roughly multiplicative way. Based on this insight we propose a framework that is able to reap the benefits from both compression approaches and can smoothly adapt to communication-constraints in the learning environment, such as network bandwidth and latency and (SGD-)computation time as well as temporal inhomogeneities therein. This leads to advantages in both federated learning and data-parallel training of deep neural networks. We would like to highlight, that in no case we did modify the hyperparameters of the respective baseline models to accommodate our method. This demonstrates that our method is easily applicable. Note however that an extensive hyperparameter search could further improve the results. Furthermore, our findings in sections 2 and 4 indicate that even higher compression rates are possible if we adapt communication delay and gradient sparsity to the particular training objective. It remains an interesting direction of further research to identify heuristics and theoretical insights that can help to find the optimal balance and thus guide sparsity towards optimality. ",
+        "bbox": [
+            174,
+            212,
+            825,
+            463
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            486,
+            285,
+            500
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alham Fikri Aji and Kenneth Heafield. Sparse communication for distributed gradient descent. arXiv preprint arXiv:1704.05021, 2017. ",
+        "bbox": [
+            174,
+            508,
+            823,
+            537
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Dan Alistarh, Demjan Grubic, Jerry Li, Ryota Tomioka, and Milan Vojnovic. Qsgd: Communicationefficient sgd via gradient quantization and encoding. In Advances in Neural Information Processing Systems, pp. 1707–1718, 2017. ",
+        "bbox": [
+            174,
+            547,
+            823,
+            590
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jeremy Bernstein, Yu-Xiang Wang, Kamyar Azizzadenesheli, and Anima Anandkumar. signsgd: compressed optimisation for non-convex problems. arXiv preprint arXiv:1802.04434, 2018. ",
+        "bbox": [
+            169,
+            602,
+            826,
+            631
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Trishul M Chilimbi, Yutaka Suzue, Johnson Apacible, and Karthik Kalyanaraman. Project adam: Building an efficient and scalable deep learning training system. In OSDI, volume 14, pp. 571–582, 2014. ",
+        "bbox": [
+            174,
+            641,
+            825,
+            684
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Thomas H Cormen, Charles E Leiserson, Ronald L Rivest, and Clifford Stein. Introduction to algorithms. MIT press, 2009. ",
+        "bbox": [
+            173,
+            694,
+            823,
+            724
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jeffrey Dean, Greg Corrado, Rajat Monga, Kai Chen, Matthieu Devin, Mark Mao, Andrew Senior, Paul Tucker, Ke Yang, Quoc V Le, et al. Large scale distributed deep networks. In Advances in neural information processing systems, pp. 1223–1231, 2012. ",
+        "bbox": [
+            174,
+            734,
+            825,
+            777
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. In Computer Vision and Pattern Recognition, 2009. CVPR 2009. IEEE Conference on, pp. 248–255. IEEE, 2009. ",
+        "bbox": [
+            173,
+            787,
+            825,
+            830
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Solomon Golomb. Run-length encodings (corresp.). IEEE transactions on information theory, 12(3): 399–401, 1966. ",
+        "bbox": [
+            171,
+            842,
+            825,
+            871
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 770–778, 2016. ",
+        "bbox": [
+            176,
+            882,
+            825,
+            922
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Gao Huang, Zhuang Liu, Kilian Q Weinberger, and Laurens van der Maaten. Densely connected convolutional networks. In Proceedings of the IEEE conference on computer vision and pattern recognition, volume 1, pp. 3, 2017. ",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Hakan Inan, Khashayar Khosravi, and Richard Socher. Tying word vectors and word classifiers: A loss framework for language modeling. arXiv preprint arXiv:1611.01462, 2016. ",
+        "bbox": [
+            173,
+            155,
+            823,
+            185
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In International conference on machine learning, pp. 448–456, 2015. ",
+        "bbox": [
+            174,
+            194,
+            826,
+            236
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014. ",
+        "bbox": [
+            174,
+            246,
+            823,
+            275
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jakub Konecnˇ y, H Brendan McMahan, Felix X Yu, Peter Richtárik, Ananda Theertha Suresh, and \\` Dave Bacon. Federated learning: Strategies for improving communication efficiency. arXiv preprint arXiv:1610.05492, 2016. ",
+        "bbox": [
+            173,
+            285,
+            826,
+            328
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky, Vinod Nair, and Geoffrey Hinton. The cifar-10 dataset. online: http://www. cs. toronto. edu/kriz/cifar. html, 2014. ",
+        "bbox": [
+            173,
+            337,
+            823,
+            367
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun. The mnist database of handwritten digits. http://yann. lecun. com/exdb/mnist/, 1998. ",
+        "bbox": [
+            176,
+            376,
+            818,
+            392
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun, Léon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998. ",
+        "bbox": [
+            171,
+            401,
+            823,
+            430
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yann A LeCun, Léon Bottou, Genevieve B Orr, and Klaus-Robert Müller. Efficient backprop. In Neural networks: Tricks of the trade, pp. 9–48. Springer, 2012. ",
+        "bbox": [
+            171,
+            439,
+            823,
+            469
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Mu Li, David G Andersen, Alexander J Smola, and Kai Yu. Communication efficient distributed machine learning with the parameter server. In Advances in Neural Information Processing Systems, pp. 19–27, 2014. ",
+        "bbox": [
+            174,
+            478,
+            825,
+            521
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yujun Lin, Song Han, Huizi Mao, Yu Wang, and William J Dally. Deep gradient compression: Reducing the communication bandwidth for distributed training. arXiv preprint arXiv:1712.01887, 2017. ",
+        "bbox": [
+            174,
+            530,
+            825,
+            573
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Mitchell P Marcus, Mary Ann Marcinkiewicz, and Beatrice Santorini. Building a large annotated corpus of english: The penn treebank. Computational linguistics, 19(2):313–330, 1993. ",
+        "bbox": [
+            173,
+            583,
+            823,
+            613
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "H Brendan McMahan, Eider Moore, Daniel Ramage, Seth Hampson, et al. Communication-efficient learning of deep networks from decentralized data. arXiv preprint arXiv:1602.05629, 2016. ",
+        "bbox": [
+            174,
+            621,
+            825,
+            651
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Philipp Moritz, Robert Nishihara, Ion Stoica, and Michael I Jordan. Sparknet: Training deep networks in spark. arXiv preprint arXiv:1511.06051, 2015. ",
+        "bbox": [
+            173,
+            660,
+            825,
+            689
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Benjamin Recht, Christopher Re, Stephen Wright, and Feng Niu. Hogwild: A lock-free approach to parallelizing stochastic gradient descent. In Advances in neural information processing systems, pp. 693–701, 2011. ",
+        "bbox": [
+            173,
+            699,
+            826,
+            742
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Frank Seide, Hao Fu, Jasha Droppo, Gang Li, and Dong Yu. 1-bit stochastic gradient descent and its application to data-parallel distributed training of speech dnns. In Fifteenth Annual Conference of the International Speech Communication Association, 2014. ",
+        "bbox": [
+            174,
+            751,
+            825,
+            795
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Reza Shokri and Vitaly Shmatikov. Privacy-preserving deep learning. In Proceedings of the 22nd ACM SIGSAC conference on computer and communications security, pp. 1310–1321. ACM, 2015. ",
+        "bbox": [
+            169,
+            804,
+            825,
+            833
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nitish Srivastava, Geoffrey Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: A simple way to prevent neural networks from overfitting. The Journal of Machine Learning Research, 15(1):1929–1958, 2014. ",
+        "bbox": [
+            176,
+            843,
+            825,
+            886
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nikko Strom. Scalable distributed dnn training using commodity gpu cloud computing. In Sixteenth Annual Conference of the International Speech Communication Association, 2015. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yusuke Tsuzuku, Hiroto Imachi, and Takuya Akiba. Variance-based gradient compression for efficient distributed deep learning. arXiv preprint arXiv:1802.06058, 2018. ",
+        "bbox": [
+            171,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Wei Wen, Cong Xu, Feng Yan, Chunpeng Wu, Yandan Wang, Yiran Chen, and Hai Li. Terngrad: Ternary gradients to reduce communication in distributed deep learning. arXiv preprint arXiv:1705.07878, 2017. ",
+        "bbox": [
+            174,
+            143,
+            821,
+            186
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Eric P Xing, Qirong Ho, Wei Dai, Jin Kyu Kim, Jinliang Wei, Seunghak Lee, Xun Zheng, Pengtao Xie, Abhimanu Kumar, and Yaoliang Yu. Petuum: A new platform for distributed machine learning on big data. IEEE Transactions on Big Data, 1(2):49–67, 2015. ",
+        "bbox": [
+            174,
+            198,
+            821,
+            241
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Wojciech Zaremba, Ilya Sutskever, and Oriol Vinyals. Recurrent neural network regularization. arXiv preprint arXiv:1409.2329, 2014. ",
+        "bbox": [
+            173,
+            252,
+            823,
+            281
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Martin Zinkevich, Markus Weimer, Lihong Li, and Alex J Smola. Parallelized stochastic gradient descent. In Advances in neural information processing systems, pp. 2595–2603, 2010. ",
+        "bbox": [
+            176,
+            292,
+            823,
+            323
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "6 SUPPLEMENT ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            352,
+            318,
+            368
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "6.1 MOMENTUM CORRECTION, WARM-UP TRAINING AND MOMENTUM MASKING: ",
+        "bbox": [
+            173,
+            383,
+            761,
+            398
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Lin et al. introduce multiple minor modifications to the vanilla Gradient Dropping method. With these modifications they achieve up to around $1 \\%$ higher accuracy compared to Gradient Dropping on a variety of benchmarks. Those modifications include: ",
+        "bbox": [
+            174,
+            410,
+            823,
+            453
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Momentum correction: Instead of adding the raw gradient to the residuum, the momentum-corrected gradient is added. This is used implicitly in our approach, as our weight updates are already momentum-corrected. ",
+        "bbox": [
+            176,
+            460,
+            825,
+            501
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Warm-up Training: The sparsity rate is increased exponentially from $2 5 \\%$ to $0 . 1 \\%$ in the first epochs. We find that warm-up training can indeed speed-up convergence in the beginning of training, but ultimately has no effect on the final accuracy of the model. We therefore omit warm up training in our experiments, as it adds an additional hyperparameter to the method, without any real benefit. ",
+        "bbox": [
+            174,
+            502,
+            825,
+            556
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Momentum Masking: To avoid stale momentum from carrying the optimization into a wrong direction after a weight update is performed, Lin et al. suggest to set the momentum to zero for updated weights. We adopt momentum correction in our method. ",
+        "bbox": [
+            176,
+            558,
+            825,
+            598
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "6.2 GOLOMB POSITION DECODING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            617,
+            431,
+            632
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 4 describes the decoding of a binary sequence produced by Golomb Position Encoding (see main paper). Since the shapes of all weight-tensors are known to both the server and all clients, we can omit the shape information in both encoding and decoding. ",
+        "bbox": [
+            174,
+            645,
+            825,
+            686
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 4: Golomb Position Decoding ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            699,
+            447,
+            714
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "1 input: binary message msg, bitsize $\\mathbf { b } ^ { * }$ , mean value $\\mu$   \n2 output: sparse tensor $\\Delta W ^ { * }$   \n3 init: $\\Delta W ^ { * }  0 \\in \\mathbb { R } ^ { n }$   \n4 $i \\gets 0$ ; $q \\gets 0$ ; $j  0$   \n5 while $i < s i z e ( \\mathrm { m s g } )$ do   \n6 i ${ \\bf f } \\log [ i ] = 0$ then   \n7 • $j \\gets j + q 2 ^ { \\mathbf { b } ^ { \\ast } } + \\mathrm { i n t } _ { \\mathbf { b } ^ { \\ast } } ( \\mathrm { m s g } [ i + 1 ] , . . , \\mathrm { m s g } [ i + \\mathbf { b } ^ { \\ast } ] ) + 1$   \n8 • ∆W ∗j ← µ   \n9 q 0; i i + b∗ + 1   \n10 else   \n11 • q ← q + 1; i ← i + 1   \n12 end   \n13 end   \n14 return ∆W ∗ ",
+        "bbox": [
+            158,
+            718,
+            606,
+            922
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "6.3 MODEL SPECIFICATION",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            380,
+            118
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Below, we describe the neural network models used in our experiments. Table 4 list the training hyperparameters that were used. ",
+        "bbox": [
+            173,
+            131,
+            825,
+            159
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/6a9e3a072a201f86c1b2d5bd62b65f3be68b3926c36c490abd2e2b85f6e1f706.jpg",
+        "table_caption": [
+            "Table 4: Hyperparameters used for our experiments in sections 2 and 4. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>Experiment</td><td rowspan=1 colspan=1>Iterations</td><td rowspan=1 colspan=1>Batchsize</td><td rowspan=1 colspan=1>LR</td><td rowspan=1 colspan=1>LR Decay</td><td rowspan=1 colspan=1>Optimizer</td></tr><tr><td rowspan=6 colspan=1>tettittt</td><td rowspan=1 colspan=1>LeNet5-Caffe@MNIST</td><td rowspan=1 colspan=1>2000</td><td rowspan=1 colspan=1>128×4</td><td rowspan=1 colspan=1>0.001</td><td rowspan=1 colspan=1>=</td><td rowspan=1 colspan=1>Adam</td></tr><tr><td rowspan=1 colspan=1>ResNet18@CIFAR10</td><td rowspan=1 colspan=1>36000</td><td rowspan=1 colspan=1>32×4</td><td rowspan=1 colspan=1>0.1</td><td rowspan=1 colspan=1>0.1 @ ep 40 and 80</td><td rowspan=1 colspan=1>Momentum SGD</td></tr><tr><td rowspan=1 colspan=1>ResNet34@CIFAR100</td><td rowspan=1 colspan=1>36000</td><td rowspan=1 colspan=1>32×4</td><td rowspan=1 colspan=1>0.1</td><td rowspan=1 colspan=1>0.1@ep 40 and 80</td><td rowspan=1 colspan=1>Momentum SGD</td></tr><tr><td rowspan=1 colspan=1>ResNet50@ImageNet</td><td rowspan=1 colspan=1>900000</td><td rowspan=1 colspan=1>32×4</td><td rowspan=1 colspan=1>0.1</td><td rowspan=1 colspan=1>0.1@ep 30 and 60</td><td rowspan=1 colspan=1>Momentum SGD</td></tr><tr><td rowspan=1 colspan=1>WordLSTM@PTB</td><td rowspan=1 colspan=1>53000</td><td rowspan=1 colspan=1>5×4</td><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>decay 0.25 if losshas not decreased</td><td rowspan=1 colspan=1>SGD</td></tr><tr><td rowspan=1 colspan=1>WordLSTM*@WIKI</td><td rowspan=1 colspan=1>120000</td><td rowspan=1 colspan=1>5×4</td><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>decay 0.25 if losshas not decreased</td><td rowspan=1 colspan=1>SGD</td></tr><tr><td rowspan=1 colspan=1>50</td><td rowspan=1 colspan=1>Resnet18*@CIFAR10</td><td rowspan=1 colspan=1>23000</td><td rowspan=1 colspan=1>4×50</td><td rowspan=1 colspan=1>0.1</td><td rowspan=1 colspan=1>0.1@ ep 40 and 80</td><td rowspan=1 colspan=1>Momentum SGD</td></tr><tr><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>LeNet5-Caffe@MNIST</td><td rowspan=1 colspan=1>2500</td><td rowspan=1 colspan=1>8×100</td><td rowspan=1 colspan=1>0.001</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>Adam</td></tr><tr><td rowspan=1 colspan=1>40</td><td rowspan=1 colspan=1>LeNet5-Caffe@MNIST</td><td rowspan=1 colspan=1>2500</td><td rowspan=1 colspan=1>2×400</td><td rowspan=1 colspan=1>0.001</td><td rowspan=1 colspan=1>=</td><td rowspan=1 colspan=1>Adam</td></tr></table>",
+        "bbox": [
+            204,
+            175,
+            785,
+            453
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "LeNet5-Caffe: The model specification can be downloaded from the Caffe MNIST tutorial page: https://github.com/BVLC/caffe/blob/master/examples/mnist/lenet_ train_test.prototxt. (Features convolutional layers, fully connected layers, pooling.) ",
+        "bbox": [
+            174,
+            513,
+            826,
+            556
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "ResNet18, ResNet32, ResNet50: We use the implementation from the official PyTorch repository: https://github.com/pytorch/examples/tree/master/imagenet. (Features skip-connections, batch-normalization.) ",
+        "bbox": [
+            173,
+            577,
+            826,
+            619
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "WordLSTM: We use the implementation from the official PyTorch repository (configuration \"medium\"): https://github.com/pytorch/examples/tree/master/word_ language_model. (Features trainable word-embeddings, multilayer LSTM-cells, dropout.) ",
+        "bbox": [
+            174,
+            638,
+            826,
+            683
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "6.4 PROOF OF THEOREM 2.1. ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            715,
+            390,
+            729
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Proof. Since ",
+        "bbox": [
+            173,
+            742,
+            261,
+            757
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4007439e545507f13a5853d6c57f28750410845ddf5a45e020a980dd07ef34f2.jpg",
+        "text": "$$\n\\begin{array} { r } { n ^ { t } = \\alpha n ^ { t - 1 } + N ^ { t } = \\alpha ( \\alpha n ^ { t - 2 } + N ^ { t - 1 } ) + N ^ { t } = \\alpha ^ { 2 } n ^ { t - 2 } + \\alpha N ^ { t - 1 } + N ^ { t } } \\\\ { = \\alpha ^ { \\tau } n ^ { t - \\tau } + \\displaystyle \\sum _ { i = 0 } ^ { \\tau - 1 } \\alpha ^ { i } N ^ { t - i } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            253,
+            765,
+            745,
+            830
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "it holds that ",
+        "bbox": [
+            173,
+            838,
+            254,
+            852
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6d2e156871d20e089b1005bba3c91d5b082861dead96599d5686aae85f769969.jpg",
+        "text": "$$\n\\mathrm { c o v } ( n ^ { t - \\tau } , n ^ { t } ) = \\mathrm { c o v } ( n ^ { t - \\tau } , \\alpha ^ { \\tau } n ^ { t - \\tau } + \\sum _ { i = 0 } ^ { \\tau - 1 } \\alpha ^ { i } N ^ { t - i } ) = \\alpha ^ { \\tau } \\sigma ^ { 2 } + \\sum _ { i = 0 } ^ { \\tau - 1 } \\alpha ^ { i } \\underbrace { \\mathrm { c o v } ( n ^ { t - \\tau } , N ^ { t - i } ) } _ { = 0 } = \\alpha ^ { \\tau } \\sigma ^ { 2 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            179,
+            859,
+            813,
+            906
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "With equation equation 10 it follows that ",
+        "bbox": [
+            173,
+            103,
+            442,
+            118
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ff6e0a9dfb6f635283a079ca51a87fbb80b3f758dcb2c2bfcdcc6c8d964ffb15.jpg",
+        "text": "$$\n\\begin{array} { r l r } {  { \\mathbb { V } ( \\sum _ { t = 1 } ^ { T } n ^ { t } ) = \\sum _ { t _ { 1 } = 1 } ^ { T } \\sum _ { t _ { 2 } = 1 } ^ { T } \\operatorname { c o v } ( n ^ { t _ { 1 } } , n ^ { t _ { 2 } } ) } } \\\\ & { } & { = \\underbrace { \\sum _ { t = 1 } ^ { T } \\operatorname { c o v } ( n ^ { t } , n ^ { t } ) } _ { T \\sigma ^ { 2 } } + 2 \\underbrace { \\sum _ { t = 1 } ^ { T - 1 } \\operatorname { c o v } ( n ^ { t } , n ^ { t + 1 } ) } _ { \\alpha ( T - 1 ) \\sigma ^ { 2 } } + 2 \\underbrace { \\sum _ { t = 1 } ^ { T - 2 } \\operatorname { c o v } ( n ^ { t } , n ^ { t + 2 } ) } _ { \\alpha ^ { 2 } ( T - 2 ) \\sigma ^ { 2 } } + \\dots + 2 \\underbrace { \\operatorname { c o v } ( n ^ { 1 } , n ^ { T } ) } _ { \\alpha ^ { T - 1 } ( 1 ) \\sigma ^ { 2 } } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            186,
+            121,
+            812,
+            233
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "For negatively correlated noise $\\alpha \\in ( - 1 , 0 )$ we can bound this term by ",
+        "bbox": [
+            173,
+            250,
+            637,
+            266
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1c1c3d776ec81bffb6a12e2d9aec4acd308b8fc4be98ed1d31fb87d213c354d2.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\Psi \\big ( \\displaystyle \\sum _ { t = 1 } ^ { T } n ^ { t } \\big ) = \\sigma ^ { 2 } ( T + 2 \\displaystyle \\sum _ { \\tau = 1 } ^ { T - 1 } \\alpha ^ { \\tau } ( T - \\tau ) ) } \\\\ & { \\qquad = \\sigma ^ { 2 } ( T + 2 \\frac { \\alpha ^ { T + 1 } - \\alpha ^ { 2 } T + \\alpha T - \\alpha } { ( \\alpha - 1 ) ^ { 2 } } ) } \\\\ & { \\qquad = \\sigma ^ { 2 } ( T + 2 \\underbrace { \\frac { ( \\alpha - \\alpha ^ { 2 } ) } { ( \\alpha - 1 ) ^ { 2 } } } _ { \\le \\frac { 1 } { 2 } \\alpha } T + 2 \\underbrace { \\frac { \\alpha ^ { T + 1 } - \\alpha } { ( \\alpha - 1 ) ^ { 2 } } } _ { \\le \\frac { 1 } { 2 } } ) } \\\\ & { \\qquad \\le \\sigma ^ { 2 } ( T ( 1 + \\alpha ) + 1 ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            325,
+            268,
+            673,
+            428
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "6.5 PROOF OF THEOREM 3.1. ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            468,
+            390,
+            483
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Proof. It holds that ",
+        "bbox": [
+            174,
+            494,
+            303,
+            510
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e504390ccb4fd4396dc66d7c9766ecc85c60f246239bb6268fb634fb4f691994.jpg",
+        "text": "$$\n\\mathrm { e r r } ( \\mathcal { R } _ { T - 1 } + \\Delta W _ { T } ) = \\| \\sum _ { t = 1 } ^ { T } \\Delta W _ { t } - \\sum _ { t = 1 } ^ { T - 1 } \\Delta W _ { t } ^ { * } - \\mathcal { R } _ { T - 1 } - \\Delta W _ { T } \\| = 0 .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            258,
+            512,
+            738,
+            556
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Since $s$ is a metric subspace, the projection ",
+        "bbox": [
+            176,
+            559,
+            462,
+            574
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/232ce0be830f6f876b87923056e5c575a303f8a1ef4c6fbf24dd3197ebe81b46.jpg",
+        "text": "$$\n\\Delta W _ { T } ^ { * } = \\mathrm { P r o j } _ { \\cal S } ( { \\mathcal { R } } _ { T - 1 } + \\Delta W _ { T } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            392,
+            578,
+            606,
+            595
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "uniquely solves the minimization problem in $s$ . ",
+        "bbox": [
+            173,
+            598,
+            486,
+            613
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "6.6 ADDITIONAL RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            628,
+            372,
+            643
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Figure 6 shows validation error for WordLSTM trained on PTB at different levels of gradient sparsity and temporal sparsity. The total sparsity, defined as the product of temporal and gradient sparsity remains constant along the diagonals of the matrix. We observe that different forms of sparsity perform best during different stages of training. Phrased differently, this means that there is not one optimal sparsity setup, but rather sparsity needs to be adapted to the current training phase to achieve optimal compression. ",
+        "bbox": [
+            173,
+            655,
+            825,
+            739
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/570169075c94d2ced3e9339b2521904bac6d1a28ed33fac971c71b090746e136.jpg",
+        "image_caption": [
+            "Figure 6: Perplexity for different levels of gradient sparsity and temporal sparsity at different stages of training. WordLSTM trained on PTB. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            756,
+            816,
+            862
+        ],
+        "page_idx": 13
+    }
+]

parse/train/Bk9zbyZCZ/Bk9zbyZCZ.md

@@ -0,0 +1,317 @@
+# NEURAL MAP: STRUCTURED MEMORY FOR DEEP REINFORCEMENT LEARNING
+
+Emilio Parisotto & Ruslan Salakhutdinov   
+Department of Machine Learning   
+Carnegie Mellon University   
+Pittsburgh, PA 15213, USA   
+{eparisot,rsalakhu}@cs.cmu.edu
+
+# ABSTRACT
+
+A critical component to enabling intelligent reasoning in partially observable environments is memory. Despite this importance, Deep Reinforcement Learning (DRL) agents have so far used relatively simple memory architectures, with the main methods to overcome partial observability being either a temporal convolution over the past $k$ frames or an LSTM layer. More recent work (Oh et al., 2016) has went beyond these architectures by using memory networks which can allow more sophisticated addressing schemes over the past $k$ frames. But even these architectures are unsatisfactory due to the reason that they are limited to only remembering information from the last $k$ frames. In this paper, we develop a memory system with an adaptable write operator that is customized to the sorts of 3D environments that DRL agents typically interact with. This architecture, called the Neural Map, uses a spatially structured 2D memory image to learn to store arbitrary information about the environment over long time lags. We demonstrate empirically that the Neural Map surpasses previous DRL memories on a set of challenging 2D and 3D maze environments and show that it is capable of generalizing to environments that were not seen during training.
+
+# 1 INTRODUCTION
+
+Memory is a crucial aspect of an intelligent agent’s ability to plan and reason in partially observable environments. Without memory, agents must act reflexively according only to their immediate percepts and cannot execute plans that occur over an extended time interval. Recently, Deep Reinforcement Learning agents have been capable of solving many challenging tasks such as Atari Arcade Games (Mnih et al., 2015), robot control (Levine et al., 2016) and 3D games such as Doom (Lample & Chaplot, 2016), but successful behaviours in these tasks have often only been based on a relatively short-term temporal context or even just a single frame. On the other hand, many tasks require long-term planning, such as a robot gathering objects or an agent searching a level to find a key in a role-playing game.
+
+Neural networks that utilized external memories have recently had an explosion in variety, which can be distinguished along two main axes: memories with write operators and those without. Writeless external memory systems, often referred to as “Memory Networks” (Sukhbaatar et al., 2015; Oh et al., 2016), typically fix which memories are stored. For example, at each time step, the memory network would store the past M states seen in an environment. What is learnt by the network is therefore how to access or read from this fixed memory pool, rather than what contents to store within it.
+
+The memory network approach has been successful in language modeling, question answering (Sukhbaatar et al., 2015) and was shown to be a sucessful memory for deep reinforcement learning agents in complex 3D environments (Oh et al., 2016). By side-steping the difficulty involved in learning what information is salient enough to store in memory, the memory network introduces two main disadvantages. The first disadvantage is that a potentially significant amount of redundant information could be stored. The second disadvantage is that a domain expert must choose what to store in the memory, e.g. for the DRL agent, the expert must set M to a value that is larger than the time horizon of the currently considered task.
+
+On the other hand, external neural memories having write operations are potentially far more efficient, since they can learn to store salient information for unbounded time steps and ignore any other useless information, without explicitly needing any a priori knowledge on what to store. One prominent research direction within write-based architectures has been neural memories based on the types of memory structures that are found in computers, such as tapes, RAM, and GPUs. In contrast to typical recurrent neural networks, these neural computer emulators have far more structured memories which follow many of the same design paradigms that digital computers have traditionally utilized. One such model, the Differentiable Neural Computer (DNC) (Graves et al., 2016) and its predecessor the Neural Turing Machine (NTM) (Graves et al., 2014), structure the architecture to explicitly separate memory from computation. The DNC has a recurrent neural controller that can access an external memory resource by executing differentiable read and write operations. This allows the DNC to act and memorize in a structured manner resembling a computer processor, where read and write operations are sequential and data is store distinctly from computation. The DNC has been used sucessfully to solve complicated algorithmic tasks, such as finding shortest paths in a graph or querying a database for entity relations.
+
+Building off these previous external memories, we introduce a new architecture called the Neural Map, a structured memory designed specifically for reinforcement learning agents in 3D environments. The Neural Map architecture overcomes some of the shortcomings of the previously mentioned neural memories. First, it uses an adaptable write operation and so its size and computational cost does not grow with the time horizon of the environment as it does with memory networks. Second, we impose a particular inductive bias on the write operation so that it is 1) well suited to 3D environments where navigation is a core component of sucessful behaviours, and 2) uses a sparse write operation that prevents frequent overwriting of memory locations that can occur with NTMs and DNCs. To accomplish this, we structure a DNC-style external memory in the form of a 2-dimensional map, where each position in the map is a distinct memory.
+
+To demonstrate the effectiveness of the neural map, we run it on a variety of 2D partially-observable maze-based environments and test it against LSTM and memory network policies. Finally, to establish its scalability, we run a Neural Map agent on a set of challenging 3D maze environments based on the video game Doom.
+
+# 2 BACKGROUND
+
+A Markov Decision Process (MDP) is defined as a tuple $( S , { \mathcal { A } } , { \mathcal { T } } , \gamma , { \mathcal { R } } )$ where $s$ is a finite set of states, $\mathcal { A }$ is a finite set of actions, $\boldsymbol { \mathcal { T } } ( s ^ { \prime } | s , a )$ is the transition probability of arriving in state $s ^ { \prime }$ when executing action $a$ in initial state $s$ , $\gamma$ is a discount factor, and $\mathcal { R } ( s , a , s ^ { \prime } )$ is the reward function of executing action $a$ in state $s$ and ending up at state $s ^ { \prime }$ . We define a policy $\pi ( \cdot | s )$ as a mapping from a state $s$ to a distribution over actions, where $\pi ( a _ { i } | s )$ denotes the probability of action $a _ { i }$ given that we are in state $s$ . The value of a policy $V ^ { \pi } ( s )$ is the expected discounted cumulative reward when starting from state $s$ and sampling actions according to $\pi$ , i.e.: $\begin{array} { r } { V ^ { \pi } ( s ) = \mathbb { E } _ { \pi } \left[ \sum _ { t = 0 } ^ { \infty } \gamma ^ { t } R _ { t } | s _ { 0 } = s \right] } \end{array}$ .
+
+An optimal value function, denoted $V ^ { * } ( s )$ , is the maximum value we can get from state $s$ according   
+to any policy, i.e. $V ^ { * } ( s ) = \operatorname* { m a x } _ { \pi } V ^ { \pi } ( s )$ . An optimal policy $\pi ^ { * }$ is defined as a policy which achieves   
+optimal value at each state, i.e. $V ^ { \pi ^ { * } } ( s ) = V ^ { * } ( s )$ . An optimal policy is guaranteed to exist (Sutton &   
+Barto, 1998). The REINFORCE algorithm (Williams, 1992) iteratively updates a given policy $\pi$ in the optimal policy. This update direction is defined by being the future cumulated reward for a particular ep $\nabla _ { \pi } \log \pi ( a _ { t } | s _ { t } ) G _ { t }$ with varia $G _ { t } =$   
+$\scriptstyle \sum _ { k = 0 } ^ { \infty } \gamma ^ { k } R _ { t + k }$ $b _ { t } ( s _ { t } )$   
+of the current state. Therefore the baseline-augmented update equation is $\begin{array} { r } { \nabla _ { \pi } \log \pi ( { a } _ { t } | { s } _ { t } ) ( G _ { t } - } \end{array}$   
+$b _ { t } ( s _ { t } ) )$ . The typically used baseline is the value function, $b _ { t } ( s _ { t } ) \stackrel { \textstyle - } { = } V ^ { \pi } ( s _ { t } )$ . This combination of   
+REINFORCE with value function baseline is commonly termed the “Actor-Critic” algorithm.
+
+In this paper, we utilize Advantage Actor-Critic (A2C) (Mnih et al., 2016) with Generalized Advantage Estimation (Schulman et al., 2015), which can be seen as a specialization of the actor-critic framework when using deep networks to parameterize the policy and value function. The policy is a function of the state, parameterized as a deep neural network: ${ \dot { \pi } } ( a | s ) = f _ { \theta } ( s , a )$ , where f is a deep neural network with parameter vector $\theta$ .
+
+# 3 NEURAL MAP
+
+In this section, we will describe the details of the neural map. We assume we want our agent to act within some 2- or 3-dimensional environment. The neural map is the agent’s internal memory storage that can be read from and written to during interaction with its environment, but where the write operator is selectively limited to affect only the part of the neural map that represents the area where the agent is currently located. For this paper, we assume for simplicity that we are dealing with a 2-dimensional map. This can easily be extended to 3-dimensional or even higher-dimensional maps (i.e. a 4D map with a 3D sub-map for each cardinal direction the agent can face).
+
+Let the agent’s position be $( x , y )$ with $x \in \mathbb { R }$ and $y \in \mathbb { R }$ and let the neural map $M$ be a $C \times H \times W$ feature block, where $C$ is the feature dimension, $H$ is the vertical extent of the map and $W$ is the horizontal extent. Assume there exists some coordinate normalization function $\psi ( x , y )$ such that every unique $( x , y )$ can be mapped into $( x ^ { \prime } , y ^ { \prime } )$ , where $x ^ { \prime } \in \{ 0 , \ldots , W { - } 1 \}$ and $y ^ { \prime } \in \{ 0 , \ldots , H { - } 1 \}$ . For ease of notation, suppose in the sequel that all coordinates have been normalized by $\psi$ into neural map space.
+
+Let $s _ { t }$ be the current state embedding, $M _ { t }$ be the current neural map, and $( x _ { t } , y _ { t } )$ be the current position of the agent. The Neural Map is defined by the following set of equations:
+
+$$
+\begin{array} { r l } & { { r _ { t } } = r e a d ( M _ { t } ) , ~ { c _ { t } } = c o n t e x t ( M _ { t } , s _ { t } , r _ { t } ) , } \\ & { } \\ { w _ { t + 1 } ^ { ( x _ { t } , y _ { t } ) } = w r i t e ( s _ { t } , r _ { t } , c _ { t } , M _ { t } ^ { ( x _ { t } , y _ { t } ) } ) , ~ M _ { t + 1 } = u p d a t e ( M _ { t } , w _ { t + 1 } ^ { ( x _ { t } , y _ { t } ) } ) , } \\ & { } \\ { o _ { t } = [ { r _ { t } } , c _ { t } , w _ { t + 1 } ^ { ( x _ { t } , y _ { t } ) } ] , ~ \pi _ { t } ( a | s ) = \mathrm { S o f t m a x } ( f ( o _ { t } ) ) , } \end{array}
+$$
+
+where $w _ { t } ^ { ( x _ { t } , y _ { t } ) }$ represents the feature at position $( x _ { t } , y _ { t } )$ at time $t$ , $[ x _ { 1 } , \ldots , x _ { k } ]$ represents a concatenation operation, and $o _ { t }$ is the output of the neural map at time $t$ which is then processed by another deep network $f$ to get the policy outputs $\pi _ { t } ( a | s )$ . We will now separately describe each of the above operations in more detail:
+
+Global Read Operation: The read operation passes the current neural map $M _ { t }$ through a deep convolutional network and produces a $C$ -dimensional feature vector $r _ { t }$ . The global read vector $r _ { t }$ summarizes information about the entire map.
+
+Context Read Operation: The context operation performs context-based addressing to check whether certain features are stored in the map. It takes as input the current state embedding $s _ { t }$ and the current global read vector $r _ { t }$ and first produces a query vector $q _ { t }$ . The inner product of the query vector and each feature $M _ { t } ^ { ( x , y ) }$ in the neural map is then taken to get scores $a _ { t } ^ { ( x , y ) }$ at all positions $( x , y )$ . The scores are then normalized to get a probability distribution $\alpha _ { t } ^ { ( x , y ) }$ over every position in the map, also known as “soft attention” (Bahdanau et al., 2015). This probability distribution is used to compute a weighted average $c _ { t }$ over all features $M _ { t } ^ { ( x , y ) }$ . To summarize:
+
+$$
+\begin{array} { r c l } { { } } & { { } } & { { q _ { t } = W [ s _ { t } , r _ { t } ] , a _ { t } ^ { ( x , y ) } = q _ { t } \cdot M _ { t } ^ { ( x , y ) } , } } \\ { { } } & { { } } & { { \alpha _ { t } ^ { ( x , y ) } = \displaystyle \frac { e ^ { a _ { t } ^ { ( x , y ) } } } { \sum _ { ( w , z ) } e ^ { a _ { t } ^ { ( w , z ) } } } , c _ { t } = \sum _ { ( x , y ) } \alpha _ { t } ^ { ( x , y ) } M _ { t } ^ { ( x , y ) } , } } \end{array}
+$$
+
+where $W$ is a weight matrix. The context read operation allows the neural map to operate as an associative memory: the agent provides some possibly incomplete memory (the query vector $q _ { t } \mathrm { ~ . ~ }$ ) and the operation will return the completed memory that most closely matches $q _ { t }$ . So, for example, the agent can query whether it has seen something similar to a particular landmark that is currently within its view.
+
+Local Write Operation: Given the agent’s current position $( x _ { t } , y _ { t } )$ at time $t$ , the write operation takes as input the current state embedding $s _ { t }$ , the global read output $r _ { t }$ , the context read vector $c _ { t }$ and the current feature at position $( x _ { t } , y _ { t } )$ in the neural map $M _ { t } ^ { ( x _ { t } , y _ { t } ) }$ and produces, using a deep neural network fw, a new C-dimensional vector w(xt,yt+1 . This vector functions as the new local write candidate vector at the current position $( x _ { t } , y _ { t } )$ : $w _ { t + 1 } ^ { ( x _ { t } , y _ { t } ) } = f _ { w } ( [ s _ { t } , r _ { t } , c _ { t } , M _ { t } ^ { ( x _ { t } , y _ { t } ) } ] )$
+
+GRU-based Local Write Operation As previously defined, the write operation simply replaces the vector at the agent’s current position with a new feature produced by a deep network. Instead of this hard rewrite of the current position’s feature vector, we can use a gated write operation based on the recurrent update equations of the Gated Recurrent Unit (GRU) (Chung et al., 2014). Gated write operations have a long history in unstructured recurrent networks and they have shown a superior ability to maintain information over long time lags versus ungated networks. The GRU-based write operation is defined as:
+
+$$
+\begin{array} { r l } & { r _ { t + 1 } ^ { ( x _ { t } , y _ { t } ) } = \sigma ( W _ { r } [ s _ { t } , r _ { t } , c _ { t } , M _ { t } ^ { ( x _ { t } , y _ { t } ) } ] ) } \\ & { \hat { w } _ { t + 1 } ^ { ( x _ { t } , y _ { t } ) } = \operatorname { t a n h } ( W _ { \hat { h } } [ s _ { t } , r _ { t } , c _ { t } ] + U _ { \hat { h } } ( r _ { t + 1 } ^ { ( x _ { t } , y _ { t } ) } \odot M _ { t } ^ { ( x _ { t } , y _ { t } ) } ) ) } \\ & { z _ { t + 1 } ^ { ( x _ { t } , y _ { t } ) } = \sigma ( W _ { z } [ s _ { t } , r _ { t } , c _ { t } , M _ { t } ^ { ( x _ { t } , y _ { t } ) } ] ) } \\ & { w _ { t + 1 } ^ { ( x _ { t } , y _ { t } ) } = ( 1 - z _ { t + 1 } ^ { ( x _ { t } , y _ { t } ) } ) \odot M _ { t } ^ { ( x _ { t } , y _ { t } ) } + z _ { t + 1 } ^ { ( x _ { t } , y _ { t } ) } \odot \hat { w } _ { t + 1 } ^ { ( x _ { t } , y _ { t } ) } , } \end{array}
+$$
+
+where $x { \odot } y$ is the Hadamard product between vectors $x$ and $y , \sigma ( \cdot )$ is the sigmoid activation function and W∗ and U∗ are weight matrices. Using GRU terminology, r(xt,yt+1 ) is the reset gate, wˆ(xt,t+1 $\hat { w } _ { t + 1 } ^ { ( x _ { t } , y _ { t } ) }$ is the candidate activation and the GRU-based update can $z _ { t + 1 } ^ { ( x _ { t } , y _ { t } ) }$ is the update gate. By making use of the reset and update gates,e how much the new write vector should differ from the currently stored feature.
+
+Map Update Operation: The update operation creates the neural map for the next time step. The new neural map $M _ { t + 1 }$ is equal to the old neural map $M _ { t }$ , except at the current agent position $( x _ { t } , y _ { t } )$ , where the current write candidate vector w(xt,yt+1 is stored:
+
+$$
+\begin{array} { r } { M _ { t + 1 } ^ { ( a , b ) } = \left\{ \begin{array} { l l } { w _ { t + 1 } ^ { ( x _ { t } , y _ { t } ) } , } & { \mathrm { f o r } ( a , b ) = ( x _ { t } , y _ { t } ) } \\ { M _ { t } ^ { ( a , b ) } , } & { \mathrm { f o r } ( a , b ) \neq ( x _ { t } , y _ { t } ) } \end{array} \right. } \end{array}
+$$
+
+# 4 EGO-CENTRIC NEURAL MAP
+
+A major disadvantage of the neural map as previously described is that it requires some oracle to provide the current $( x , y )$ position of the agent. This is a difficult problem in and of itself, and, despite being well studied, it is far from solved. The alternative to using absolute positions within the map is to use relative positions. That is, whenever the agent moves between time steps with some velocity $( u , v )$ , the map is counter-transformed by $\left( - u , - v \right)$ , i.e. each feature in the map is shifted in the $H$ and $W$ dimensions. This will mean that the map will be ego-centric, i.e. the agent’s position will stay stationary in the center of the neural map while the world as defined by the map moves around them. Therefore in this setup we only need some way of extracting the agent’s velocity, which is typically a simpler task in real environments (for example, animals have inner ears and robots have accelerometers). Here we assume that there is some function $ { \boldsymbol { \xi } } ( u ^ { \prime } , v ^ { \prime } )$ that discretizes the agent velocities $( u ^ { \prime } , v ^ { \prime } )$ so that they represent valid velocities within the neural map $( u , v )$ . In the sequel, we assume that all velocies have been properly normalized by $\xi$ into neural map space.
+
+Let $( p w , p h )$ be the center position of the neural map. The updated ego-centric neural map operations are shown below:
+
+$$
+\begin{array} { r l } & { \overline { { M } } _ { t } = C o u n t e r T r a n s f o r m ( M _ { t } , ( u _ { t } , v _ { t } ) ) } \\ & { \qquad r _ { t } = r e a d ( \overline { { M } } _ { t } ) \quad c _ { t } = c o n t e x t ( \overline { { M } } _ { t } , s _ { t } , r _ { t } ) } \\ & { w _ { t + 1 } ^ { ( p w , p h ) } = w r i t e \big ( s _ { t } , r _ { t } , c _ { t } , \overline { { M } } _ { t } ^ { ( p w , p h ) } \big ) \quad M _ { t + 1 } = e g o u p d a t e ( \overline { { M } } _ { t } , w _ { t + 1 } ^ { ( p w , p h ) } ) } \\ & { \qquad \quad o _ { t } = \big [ r _ { t } , c _ { t } , w _ { t + 1 } ^ { ( p w , p h ) } \big ] \quad \pi _ { t } = \mathrm { S o f t m a x } ( f ( o _ { t } ) ) } \end{array}
+$$
+
+Where $\overline { { M } } _ { t }$ is the current neural map $M _ { t }$ reverse transformed by the current velocity $\left( { { u } _ { t } } , { { v } _ { t } } \right)$ so that the agents map position remains in the center $( p w , p h )$ .
+
+Counter Transform Operation: The CounterT ransform operation transforms the current neural map $M _ { t }$ by the inverse of the agent’s current velocity $\left( { { u } _ { t } } , { { v } _ { t } } \right)$ . Written formally:
+
+$$
+\overline { { { M } } } _ { t } ^ { ( a , b ) } = \left\{ \begin{array} { l r } { { M _ { t } ^ { ( a - u , b - v ) } , } } & { { \mathrm { f o r ~ } ( a - u ) \in \{ 1 , . . . , W \} \wedge ( b - v ) \in \{ 1 , . . . , H \} } } \\ { { 0 , } } & { { \mathrm { e l s e } } } \end{array} \right.
+$$
+
+![](images/48b8373f7563b8c9f4e3fc95fa0ca6cc4755cc7ad4e7b8acb7bb536536aa4e7b.jpg)  
+Figure 1: Left: Images showing the 2D maze environment. The left side (Fig. 1a) represents the fully observable maze while the right side (Fig. 1b) represents the agent observations. The agent is represented by the yellow pixel with its orientation indicated by the black arrow within the yellow block. The starting position is always the topmost position of the maze. The red bounding box represents the area of the maze that is subsampled for the agent observation. In “Goal-Search”, the goal of the agent is to find a certain color block (either red or teal), where the correct color is provided by an indicator (either green or blue). This indicator has a fixed position near the start position of the agent. Right: State observations from the “Indicator” Doom maze environment. The agent starts in the middle of a maze looking in the direction of a torch indicator. The torch can be either green (top-left image) or red (bottom-left image) and indicates which of the goals to search for. The goals are two towers which are randomly located within the maze and match the indicator color. The episode ends whenever the agent touches a tower, whereupon it receives a positive reward if it reached the correct tower, while a negative reward otherwise.
+
+While here we only deal with reverse translation, it is possible to handle rotations as well if the agent can measure it’s angular velocity.
+
+Map Egoupdate Operation: The egoupdate operation is functionally equivalent to the update operation except only the center position $( p w , p h )$ is ever written to:
+
+$$
+M _ { t + 1 } ^ { \left( a , b \right) } = \left\{ \begin{array} { l l } { w _ { t + 1 } ^ { \left( p w , p h \right) } , } & { \mathrm { f o r } \left( a , b \right) = \left( p w , p h \right) } \\ { \overline { { M } } _ { t } ^ { \left( a , b \right) } , } & { \mathrm { f o r } \left( a , b \right) \neq \left( p w , p h \right) } \end{array} \right.
+$$
+
+# 5 EXPERIMENTS
+
+To demonstrate the effectiveness of the Neural Map, we run it on 2D and 3D maze-based environments where memory is crucial to optimal behaviour. We compare to previous memory-based DRL agents, namely a simple LSTM-based agent which consists of a single pre-output LSTM layer as well as MemNN (Oh et al., 2016) agents.
+
+# 5.1 2D GOAL-SEARCH ENVIRONMENT
+
+The “Goal-Search” environment is adapted from Oh et al. (2016). Here the agent starts in a fixed starting position within some randomly generated maze with two randomly positioned goal states. It then observes an indicator at a fixed position near the starting state (i.e. the green tile at the top of the maze in Fig. 1a). This indicator will tell the agent which of the two goals it needs to go to (blue indicator teal goal, green indicator red goal). If the agent goes to the correct goal, it gains a positive reward while if it goes to the incorrect goal it gains a negative reward. Therefore the agent needs to remember the indicator as it searches for the correct goal state. In depth details of the 2D environment are given in Appendix B. The mazes during training are generated using a random generator. A held-out set of 1000 random mazes is kept for testing. This test set therefore represents maze geometries that have never been seen during training, and measure the agent’s ability to generalize to new environments.
+
+The first baseline agent we evaluate is a recurrent network with 128 LSTM units. The other baseline is the MQN, which is a memory-network-based architecture that performs attention over the past K states it has seen (Oh et al., 2016). Both LSTM and MQN models receive a one-hot encoding of the agent’s current location, previous velocity, and current orientation at each time step, in order to make the comparison to the fixed-frame Neural Map fair. We test these baselines against several Neural Map architectures, with each architecture having a different design choice.
+
+2D Goal-Search   
+Table 1: Results of several different agent architectures on the “Goal-Search” environment. The “train” columns represents the number of mazes solved (in $\%$ ) when sampling from the same distribution as used during training. The “test” columns represents the number of mazes solved when run on a set of held-out maze samples which are guaranteed not to have been sampled during training.   
+
+<table><tr><td rowspan="2">Agent</td><td colspan="3">Train</td><td colspan="3">Test</td></tr><tr><td>7-11</td><td>13-15</td><td>Total</td><td>7-11</td><td>13-15</td><td>Total</td></tr><tr><td>Random</td><td>41.9%</td><td>25.7%</td><td>38.1%</td><td>46.0%</td><td>29.6%</td><td>38.8%</td></tr><tr><td>LSTM</td><td>84.7%</td><td>74.1%</td><td>87.4%</td><td>96.3%</td><td>83.4%</td><td>91.4%</td></tr><tr><td>MQN-32</td><td>80.2%</td><td>64.4%</td><td>83.3%</td><td>95.9%</td><td>74.6%</td><td>87.4%</td></tr><tr><td>MQN-64</td><td>83.2%</td><td>69.6%</td><td>85.8%</td><td>96.5%</td><td>76.7%</td><td>88.3%</td></tr><tr><td>Neural Map (15x15)</td><td>92.4%</td><td>80.5%</td><td>89.2%</td><td>93.5%</td><td>87.9%</td><td>91.7%</td></tr><tr><td>Neural Map + GRU (15x15)</td><td>97.0%</td><td>89.2%</td><td>94.9%</td><td>97.7%</td><td>94.0%</td><td>96.4%</td></tr><tr><td>Neural Map + GRU(8x8)</td><td>94.9%</td><td>90.7%</td><td>95.6%</td><td>98.0%</td><td>95.8%</td><td>97.3%</td></tr><tr><td>Neural Map +GRU + Pos (8x8)</td><td>95.0%</td><td>91.0%</td><td>95.9%</td><td>98.3%</td><td>94.3%</td><td>96.5%</td></tr><tr><td>Neural Map + GRU + Pos (6x6)</td><td>90.9%</td><td>83.2%</td><td>91.8%</td><td>97.1%</td><td>90.5%</td><td>94.0%</td></tr><tr><td>Ego Neural Map + GRU (15x15)</td><td>94.6%</td><td>91.1%</td><td>95.4%</td><td>97.7%</td><td>92.1%</td><td>95.5%</td></tr><tr><td>Ego Neural Map +GRU + Pos (15x15)</td><td>74.6%</td><td>63.9%</td><td>78.6%</td><td>87.8%</td><td>73.2%</td><td>82.7%</td></tr></table>
+
+The results are reported in Table 1. During testing, we extend the maximum episode length from 100 to 500 steps so that the agent is given more time to solve the maze. The brackets next to the model name represent the Neural Map dimensions of that particular model. From the results we can see that the Neural Map architectures solve the most mazes in both the training and test distributions compared to both LSTM and MQN baselines.
+
+The results also demonstrate the effect of certain design decisions. One thing that can be observed is that using GRU updates adds several percentage points to the success rate (“Neural Map (15x15)” v.s. “Neural $\mathrm { M a p } + \mathrm { G R U } \left( 1 5 \mathrm { x } 1 5 \right) ^ { \circ } )$ . We also tried downsampled Neural Maps, such that a pixel in the memory map represents several discrete locations in the environment. The Neural Map seems quite robust to this downsampling, with a downsampling of around 3 (6x6 v.s. 15x15) doing just a few percentage points worse, and still beating all baseline models. The 6x6 model has approximately the same number of memory cells as “MQN- $. 3 2 ^ { \circ }$ , but its performance is much better, showing the benefit of having learnable write operations. For the egocentric model, in order to cover the entire map we set the pixels to be $2 \mathbf { x }$ smaller in each direction, so each pixel is only a quarter of a pixel in the fixed-frame map. Even with this coarser representation, the egocentric model did similarly to the fixed frame one. We demonstrate an example of what the Neural Map learned to address using its context operator in Appendix E.
+
+Finally, we tried adding the one-hot position encoding as a state input to the Neural Map, as is done for the baselines. We can see that there is a small improvement, but it is largely marginal, with the Neural Map doing a decent job of learning how to represent its own position without needing to be told explicitly. One interesting thing that we observed is that having the one-hot position encoding as an input to the egocentric map decreased performance, perhaps because it is difficult for the network to learn a mapping between fixed and egocentric frames.
+
+Note that sometimes the percentage results are lower for the training distribution. This is mainly because the training set encompases almost all random mazes except the fixed 1000 of the test set, thus making it likely that the agent sees each training map only once.
+
+Beyond train/test splits, the results are further separated by maze size. This information reveals that the memory networks are hardest hit by increasing maze size with sometimes a $20 \%$ drop in success on 13-15 v.s. 7-11. This is perhaps unsurprising given the inherent fixed time horizon of memory netwoks, and further reveals the benefit of using write-based memories.
+
+![](images/4214ed9336fcb3cd9e922057d42b4aa5a46c785d9a82e03be29dbdf15a3a7649.jpg)  
+Figure 2: Top-down views showing succesful episodes in each of the 3 Doom maze tasks. The red lines indicate the path traveled by the agent. Indicator is shown in Fig. 2a, where the agent receives positive reward when entering the corresponding tower that matches the torch color it saw at the start of the episode and a negative reward otherwise. The episode terminates once the agent has reached a tower. Repeating, shown in Fig. 2b, has the same underlying mechanics except (1) the episode persists for $T$ time steps regardless of towers entered and (2) the torch indicator is removed from the maze after the agent has reached a tower once. Therefore the agent needs to find the correct tower and then optimize its path to that tower. Minotaur shown in Fig. 2c requires the agent to reach the red goal and then return to the green goal that is at its starting position. Here the torch does not have any function. This fully-observable top-down view was not made available to the agent and is only used for visualization.
+
+# 5.2 3D DOOM ENVIRONMENT DESCRIPTION
+
+To demonstrate that our method can work in much more complicated 3D environments with longer time lags, we implemented three 3D maze environments using the ViZDoom (Kempka et al., 2016) API and a random maze generator. Examples of all three environments are given in Figure 2.
+
+Indicator Maze: The first environment is a recreation of the 2D indicator maze task, where an indicator is positioned in view of the player’s starting state which is either a torch of red or green color. The goals are corresponding red/green towers that are randomly positioned throughout the maze that the player must locate.
+
+Repeating Maze: The second environment is a variant of this indicator maze but whenever the player enters a goal state, it is teleported back to the beginning of the maze without terminating the episode (i.e. it retains its memory of the current maze). It gains a positive reward if it reaches the correct goal and a negative reward if it reaches the incorrect goal. After the first goal is reached, the correct indicator color is no longer displayed within the maze and a red indicator is displayed afterwards instead (regardless if the correct goal is green). An episode ends after a predetermined number of steps which depends on the maze size. The goal is therefore to find a path to the correct goal, and then optimize that path so that it can reach it as many times as possible.
+
+Minotaur Maze: The third environment has the agent start in a fixed starting position next to the green tower, while the red tower is randomly placed somewhere in the maze. The agent receives a small positive reward if it reaches the red tower, and a larger positive reward if after reaching the red tower it returns to the green tower. Therefore the agent must efficiently navigate to the red goal while accurately remember its entire path it so that it can backtrack to the start.
+
+All three environments used a $\mathrm { R G B + D }$ image of size $1 0 0 \mathrm { x } 6 0$ as input. We generate maze geometries randomly at train time but make sure to exclude a test set of 10 mazes for each size [4, 5, 6, 7, 8] (50 total). For these environments, we tested out four architectures (see Appendix C for more details on both environments and architectures):
+
+Neural Map with Controller LSTM: Standard Neural Map with fixed frame addressing and GRU updates. We combine the neural map design with an LSTM that aggregates past state, read and context vectors and produces the query vector for the next time step’s context read operation. See Appendix A for the modified Neural Map equations.
+
+Ego Neural Map with Controller LSTM: Same as previous but with ego-centric addressing. The other difference is that the Ego Neural Map does not receive any positional input unlike the other 3 models, only receiving frame-by-frame ego-motion (quantized to a coarse grid).
+
+LSTM: Single pre-output 256-dimensional LSTM layer.
+
+<table><tr><td rowspan="2">Agent Maze Size</td><td colspan="6">Indicator</td><td colspan="6">Repeating</td><td colspan="4">Minotaur</td></tr><tr><td>4</td><td></td><td>5</td><td>6</td><td>8</td><td></td><td>4</td><td>5</td><td>6</td><td>7</td><td>8</td><td>4</td><td>5</td><td>6</td><td>7</td><td>8</td></tr><tr><td rowspan="2">LSTM</td><td>Acc</td><td>95.7</td><td>87.5</td><td>81.1</td><td>71.4</td><td>60.3</td><td>-</td><td>-</td><td>-</td><td>1</td><td>-</td><td>90.0</td><td>71.5</td><td>48.0</td><td>34.2</td><td>29.4</td></tr><tr><td>Rew</td><td>-</td><td>1</td><td>1</td><td>1</td><td>-</td><td>7.26</td><td>7.58</td><td>6.065.32</td><td></td><td>4.98</td><td>1.35</td><td>1.07</td><td>0.72</td><td>0.51</td><td>0.44</td></tr><tr><td rowspan="2">FRMQN</td><td>Acc</td><td>87.3</td><td>82.9</td><td>78.0</td><td>72.0</td><td>59.8</td><td>-</td><td>-</td><td>1</td><td>1</td><td>1</td><td>72.7</td><td>54.5</td><td>38.8</td><td>28.8</td><td>23.7</td></tr><tr><td>Rew</td><td>-</td><td>-</td><td>-</td><td>1</td><td>-</td><td>1.45</td><td>1.65</td><td>1.51</td><td>1.37</td><td>1.09</td><td>1.09</td><td>0.82</td><td>0.58</td><td>0.43</td><td>0.36</td></tr><tr><td rowspan="2">Controller</td><td>Acc</td><td>95.8</td><td>90.3</td><td>81.8</td><td>80.4</td><td>70.3</td><td>-</td><td>1</td><td>1</td><td></td><td></td><td>99.7</td><td>92.2</td><td>67.5</td><td>37.9</td><td>30.2</td></tr><tr><td>Rew</td><td>-</td><td>1</td><td>-</td><td>1</td><td>-</td><td>17.4</td><td>17.1</td><td>12.0</td><td>1 11.4</td><td>1 12.3</td><td>1.50</td><td>1.38</td><td>1.01</td><td>0.57</td><td>0.45</td></tr><tr><td>NMap Controller</td><td>Acc</td><td>94.6</td><td>91.0</td><td>87.6</td><td>85.8</td><td>72.2</td><td></td><td>-</td><td></td><td></td><td></td><td>98.6</td><td>90.0</td><td>65.2</td><td>44.7</td><td>33.8</td></tr><tr><td>Ego-NMap</td><td>Rew</td><td>1</td><td>-</td><td>-</td><td>1</td><td>1</td><td>- 12.8</td><td>14.1</td><td>1 11.0</td><td>- 10.4</td><td>- 9.72</td><td>1.48</td><td>1.35</td><td>0.98</td><td>0.67</td><td>0.51</td></tr></table>
+
+Table 2: Doom results on mazes not observed during training for the three tasks: Indicator, Repeating and Minotaur. Acc stands for Accuracy and Rew for Reward. Accuracy for Indicator means $\%$ of correct goals reached, while for Minotaur it means $\%$ of episodes where the agent successfully reached the goal and then backtracked to the beginning. Reward for Repeating is number of times correct goal was visited within the allotted time steps $_ { + 1 }$ for correct goal, -1 for incorrect goal). Reward for Minotaur is $+ 0 . 5$ for reaching the goal and then $+ 1 . 0$ for backtracking to start after reaching goal (max episode reward is $+ 1 . 5$ ). We tested on maze sizes between [4,8] with 10 test mazes for each size. For each of the 50 total test mazes we ran 100 episodes with random goal locations and averaged the result.
+
+FRMQN (Oh et al., 2016): Memory network with LSTM feedback. This design uses an LSTM to make recurrent context queries to the memory network database. In addition, for the memory network baselines we did not set a fixed $\mathbf { k }$ but instead let it access any state from its entire episode. This means no information is lost to the memory network, it only needs to process its history.
+
+The results are shown in Table 2. We can see that the Neural Map architectures work better than the baseline models, even though the memory network has access to its entire episode history at every time step. The ego-centric Neural Map beats the fixed frame map at Indicator, and gets similar performance on both Repeating and Minotaur environments, showing the ability of the Neural Map to function effectively even without global position information. It is possible that having a fixed frame makes path optimization easier, which would explain the larger rewards that the fixed-frame model got in the Repeating task. We also investigated whether the neural map is robust to localization noise, which would be the case in a real world setting where we do not have access to a localization oracle and must instead rely on an error-prone odometry or SLAM-type algorithm to do localization. These results are presented in Appendix D.
+
+For the baselines, we can see that FRMQN has difficulty learning on Repeating, only reaching the goal on average once. This could be because the indicator is only shown before the first goal is reached and so afterwards it needs to remember increasingly longer time horizons. Furthermore, because the red indicator is always shown after the first goal is reached, it might be difficult for the model to learn to do retrieval since the original correct indicator must be indexed by time and not image similarity. The FRMQN also has difficulty on Minotaur, probably due to needing to remember and organize a lot of spatial information (i.e. what actions were taken along the path). For Indicator, the FRMQN does similarly to the LSTM. We can see that the spatial structure of the Neural Map aids in optimizing the path in Repeating, averaging 12 goal reaches even in the largest maze size.
+
+# 6 RELATED WORK
+
+Other than the straightforward architectures of combining an LSTM with Deep Reinforcement Learning (DRL) (Mnih et al., 2016; Hausknecht & Stone, 2015), there has also been work on using more advanced external memory systems with DRL agents to handle partial observability. Oh et al. (2016) used a memory network (MemNN) to solve maze-based environments similar to the ones presented in this paper. MemNN keeps the last $M$ states in memory and encodes them into (key, value) feature pairs. It then queries this memory using a soft attention mechanism similar to the context operation of the Neural Map, except in the Neural Map the key/value features were written by the agent and aren’t just a stored representation of the last $M$ frames seen. Oh et al. (2016) tested a few variants of this basic model, including ones which combined both LSTM and memory-network style memories.
+
+In contrast to memory networks, another research direction is to design recurrent architectures that mimic computer memory systems. These architectures explicitly separate computation and memory in a way anagolous to a modern digital computer, in which some neural controller (akin to a CPU) interacts with an external memory (RAM). One recent model is similar to the Neural Map, called the Differentiable Neural Computer (DNC) (Graves et al., 2016), which combines a recurrent controller with an external memory system that allows several types of read/write access. In addition to defining an unconstrained write operator (in contrast to the neural map’s write location being fixed), the DNC has a selective read operation that reads out the memory either by content or in the order that it was written. While the DNC is more specialized to solving algorithmic problems, the Neural Map can be seen as an extension of this Neural Computer framework to 3D environments, with a specific inductive bias on its write operator that allows sparse writes. Recently work has also been done toward sparsifying the read and write operations of the DNC (Rae et al., 2016). This work was not focused on 3D environments and did not make any use of task-specific biases like agent location, but instead used more general biases like “Least-Recently-Used” memory addresses to force sparsity. More recently, the DNC, in conjunction with a VIN planning network (Tamar et al., 2016), has been applied to the task of navigating partially-observable environments (Khan et al., 2018) although it still relied on supervised learning in order to train the complete system.
+
+Gupta et al. (2017) designed a similar 2D map structured memory, with the aim to do robot navigation in 3D environments. These environments were based off image scans of real office buildings, and they were preprocessed into a grid-world by quantizing the possible positions and orientations the agent could assume. In contrast to our paper, which presents the Neural Map more as a general memory architecture for DRL agents, Gupta et al. (2017) focuses mainly on solving the task of robot navigation, with the internal map’s representation mainly used to represent free space around the robot. More concretely, the task in these environments was to navigate to a goal state, with the goal position either stated semantically (find a chair) or stated in terms of the position relative to the robot’s coordinate frame. Another key difference was that their formulation lacked a context addressing operation. Finally, their method used DAGGER (Ross et al., 2011), an imitation learning algorithm, to train their agent. Since Doom actions affect translational/rotational accelerations, training using imitation learning is more difficult since a search algorithm cannot be used directly as supervision. An interesting addition they made was the use of a multi-scale map representation and a Value Iteration network (Tamar et al., 2016) to do better path planning. Another related work, Neural SLAM (Zhang et al., 2017) extends spatial memories to settings where localization/odometry is not provided a priori, but instead has to be completed in tandem with the mapping of the environment. In order to accomplish that, a grid-based localization system was combined with a Neural Map-style memory in order to do differentiable SLAM-like combined localization and mapping.
+
+# 7 CONCLUSION
+
+In this paper we developed a neural memory architecture that organizes the spatial structure of its memory in the form of a 2D map, and allows sparse writes to this memory where the memory address of the write is in a correspondence to the agent’s current position in the environment. We showed its ability to learn, using a reinforcement signal, how to behave within challenging 2D and 3D maze tasks that required storing information over long time steps. The results demonstrated that our architecture surpassed baseline memories used in previous work. Additionally, we showed the benefit of certain design decisions made in our architecture: using GRU updates instead of hard writes, demonstrating that the ego-centric viewpoint does not diminish performance and that the Neural Map is robust to downsampling its memory. Finally, to show that our method can scale up to more difficult 3D environments, we implemented several new maze environments in Doom. Using a hybrid Neural $\mathbf { M a p } + \mathbf { L S T M }$ model, we were able to solve most of the scenarios at a performance higher than previous DRL memory-based architectures. Furthermore, we demonstrated the ability of the Neural Map to be robust to a certain level of drift noise in its localization estimate.
+
+# Acknowledgements
+
+This work was supported by Apple, DARPA award D17AP00001, the Google focused award. The authors would also like to thank NVidia NVAIL award for donating DGX-1 deep learning machine. This work used the Extreme Science and Engineering Discovery Environment (XSEDE), which is supported by National Science Foundation grant number OCI-1053575. Specifically, it used the Bridges system, which is supported by NSF award number ACI-1445606, at the Pittsburgh Supercomputing Center (PSC).
+
+# REFERENCES
+
+D. Bahdanau, K. H. Cho, and Y. Bengio. Neural machine translation by jointly learning to align and translate. In Proceedings of the 3rd International Conference on Learning Representations 2015, 2015.
+
+J. Chung, C. Gulcehre, K. Cho, and Y. Bengio. Empirical evaluation of gated recurrent neural networks on sequence modeling. CoRR, abs/1412.3555, 2014. URL https://arxiv.org/ abs/1412.3555.
+
+A. Graves, G. Wayne, and I. Danihelka. Neural turing machines. CoRR, abs/1410.5401, 2014. URL https://arxiv.org/abs/1410.5401.
+
+A. Graves, G. Wayne, M. Reynolds, T. Harley, I. Danihelka, A. Grabska-Barwiska, S. G. Colmenarejo, E. Grefenstette, T. Ramalho, J. Agapiou, A. P. Badia, K. M. Hermann, Y. Zwols, G. Ostrovski, A. Cain, H. King, C. Summerfield, P. Blunsom, K. Kavukcuoglu, and D. Hassabis. Hybrid computing using a neural network with dynamic external memory. Nature, 538: 471–476, 2016.
+
+S. Gupta, J. Davidson, S. Levine, R. Sukthankar, and J. Malik. Cognitive mapping and planning for visual navigation. CoRR, abs/1702.03920, 2017. URL https://arxiv.org/abs/1702. 03920.
+
+M. Hausknecht and P. Stone. Deep recurrent q-learning for partially observable mdps. CoRR, abs/1507.06527, 2015. URL https://arxiv.org/abs/1507.06527.
+
+Michał Kempka, Marek Wydmuch, Grzegorz Runc, Jakub Toczek, and Wojciech Jaskowski. ViZ- ´ Doom: A Doom-based AI research platform for visual reinforcement learning. In IEEE Conference on Computational Intelligence and Games, pp. 341–348, Santorini, Greece, Sep 2016. IEEE.
+
+A. Khan, C. Zhang, N. Atanasov, K. Karydis, V. Kumar, and D. D. Lee. Memory augmented control networks. In Proceedings of the 6th International Conference on Learning Representations, 2018.
+
+G. Lample and D. S. Chaplot. Playing fps games with deep reinforcement learning. CoRR, abs/1609.05521, 2016. URL https://arxiv.org/abs/1609.05521.
+
+Sergey Levine, Chelsea Finn, Trevor Darrell, and Pieter Abbeel. End-to-end training of deep visuomotor policies. Journal of Machine Learning Research, 17(39):1–40, 2016.
+
+V. Mnih, K. Kavukcuoglu, D. Silver, A. A. Rusu, J. Veness, M. G. Bellemare, A. Graves, M. Riedmiller, A. K. Fidjeland, G. Ostrovski, S. Petersen, C. Beattie, A. Sadik, I. Antonoglou, H. King, D. Kumaran, D. Wierstra, S. Legg, and D. Hassabis. Human-level control through deep reinforcement learning. Nature, 518:529–533, 2015.
+
+V. Mnih, A. P. Badia, M. Mirza, A. Graves, T. Harley, T. P. Lillicrap, D. Silver, and K. Kavukcuoglu. Asynchronous methods for deep reinforcement learning. In Proceedings of the 33rd International Conference on Machine Learning (ICML), 2016.
+
+J. Oh, V. Chockalingam, S. Singh, and H. Lee. Control of memory, active perception, and action in minecraft. In Proceedings of the 33rd International Conference on Machine Learning (ICML), 2016.
+
+J. W. Rae, J. J. Hunt, T. Harley, I. Danihelka, A. Senior, G. Wayne, A. Graves, and T. Lillicrap. Scaling memory-augmented neural networks with sparse reads and writes. CoRR, abs/1610.09027, 2016. URL https://arxiv.org/abs/1610.09027.
+
+Stephane Ross, Geoffrey J Gordon, and Drew Bagnell. A reduction of imitation learning and struc-´ tured prediction to no-regret online learning. In AISTATS, volume 1, pp. 6, 2011.
+
+John Schulman, Philipp Moritz, Sergey Levine, Michael Jordan, and Pieter Abbeel. Highdimensional continuous control using generalized advantage estimation. In Proceedings of the 4th International Conference on Learning Representations 2016, 2015.
+
+S. Sukhbaatar, A. Szlam, J. Weston, and R. Fergus. End-to-end memory networks. In Advances in Neural Information Processing Systems, pp. 2440–2448, 2015.   
+R. Sutton and A. Barto. Reinforcement Learning: an Introduction. MIT Press, 1998.   
+Aviv Tamar, Yi Wu, Garrett Thomas, Sergey Levine, and Pieter Abbeel. Value iteration networks. In Advances in Neural Information Processing Systems, pp. 2146–2154, 2016.   
+R. J. Williams. Simple statistical gradient-following algorithms for connectionist reinforcement learning. Machine Learning, 8(3):229–256, 1992.   
+J. Zhang, L. Tai, J. Boedecker, W. Burgard, and M. Liu. Neural slam: Learning to explore with external memory. CoRR, abs/1706.09520, 2017. URL https://arxiv.org/abs/1706. 09520.
+
+# A CONTROLLER (EGO-)NEURAL MAP
+
+Here we describe the modification to the Neural Map we utilized for the 3D maze tasks. We include an extra state $h$ that represents the hidden and cell state of an LSTM. The Neural Map equations are therefore:
+
+$$
+\begin{array} { r l } & { r _ { t } = r e a d ( M _ { t } ) , } \\ & { h _ { t } = L S T M ( s _ { t } , r _ { t } , c _ { t - 1 } , h _ { t - 1 } ) , } \\ & { c _ { t } = c o n t e x t ( M _ { t } , h _ { t } ) , } \\ & { w _ { t + 1 } ^ { ( x _ { t } , y _ { t } ) } = w r i t e ( s _ { t } , r _ { t } , c _ { t } , M _ { t } ^ { ( x _ { t } , y _ { t } ) } ) , } \\ & { M _ { t + 1 } = w p d a t e ( M _ { t } , w _ { t + 1 } ^ { ( x _ { t } , y _ { t } ) } ) , } \\ & { \qquad o _ { t } = [ r _ { t } , c _ { t } , w _ { t + 1 } ^ { ( x _ { t } , y _ { t } ) } ] , } \\ & { \pi _ { t } ( a | s ) = \mathrm { S o f t m a x } ( f ( o _ { t } ) ) , } \end{array}
+$$
+
+# B 2D ENVIRONMENT DETAILS
+
+The state input for the 2D environment is a $5 \times 1 5 \times 3$ subsample of the complete maze so that the agent is able to see 15 pixel forward and 3 pixels on the side (center pixel $^ +$ one pixel on each side of the agent) which is depicted in Fig.1b. This view is obscured so the agent is prevented from seeing the identity of anything behind walls. The 5 binary channels in the observation represent object identities: channel 1 represents presence of walls, 2 represents the green indicator, 3 the blue indicator, 4 the red goal, and 5 the teal goal. The LSTM and MemNN networks were given auxiliary information such as the one-hot encoding of the current agent’s true position in the maze. Neural Map variants were not given position information in an auxiliary state unless specified by the $^ { 6 6 } +$ Pos” modifier in Table 1. Actions in the environment included moving forward and turning left/right 90 degrees.
+
+For optimization, all architectures used the RMSprop optimization algorithm with gradients thresholded to norm 20 for LSTM, 100 for Neural Map variants, and no thresholding for memory networks. We used an auxiliary weighted entropy loss on the Synchronous Actor-Critic with weight 0.01. The learning rates for LSTM models was 0.0025, 0.005 for Neural Map variants, and 0.001 for memory networks. We obtained the hyperparameters during a limited hyperparameter sweep on a simpler version of the environment. We used A2C with number of time steps equal to 5. We trained for 10 million updates.
+
+The mazes were generated using an algorithm based on Depth-First Search to form a fully-connected maze. Afterwards each wall was deleted with probability $p . p$ was sampled uniformly from between $[ 0 , 0 . 7 5 ]$ at maze generation time. Each episode, a random maze width was sampled uniformly from between [7, 15].
+
+(Ego-)Neural Map Agent Details: For the global read operation, we used a convolutional network with 3 layers of 8 channels and kernel size 3. The strides were set to 1 on the first layer, and 2 to the second and third layers. Padding was 1 on the first layer and 0 on other layers. The 3 convolutional layers were then followed by a fully-connected layer of dimension 256 and then another fullyconnected layer of size 32. All activations were relu except the 32 dimension layer, which was set to tanh. Positions were normalized so that the largest map size used all positions, while smaller mazes used a subset of the map.
+
+LSTM Agent Details: The LSTM agent had a single 128-dimension LSTM layer on top of the state embedding. The auxiliary state information was first processed into a 256-dimension embedding.
+
+MQN Agent Details: Each past history state was 512-dimensional (256-dimensional key $+ \ 2 5 6$ - dimensional value feature). The input state was processed by a convolutional network with 32 channels, filter size 3, stride 1 and padding 1.
+
+# C 3D ENVIRONMENT DETAILS
+
+The state input for all 3D environments was a $1 0 0 \mathrm { x } 6 0 \ \mathrm { R G B + D }$ image. This was passed through a convolution network that was the same for all architectures. It first consists of a 2D convolution with 32 channels of filter size 8 with stride 4. This was then passed to another 2D convolution with 64 channels of filter size 4 and stride 2. Finally, the result was passed through a fully-connected layer with 512 features, which represented the current frame embedding. The frame embedding was then augmented with some auxiliary information about the map, which in the case of Neural Map, FRMQN and LSTM architectures was 1) a one-hot encoding of the current time step, 2) the current orientation (North/East/West/South), 3) the 2D velocity (change in x/y position in a top-down 2D quantized grid of possible environment positions), and 4) a one-hot encoding of the agent’s current quantized position. For Ego Neural Map, only 1, 2, 3 are used (i.e. it has no input of the agent’s current true position given by an oracle). The 512 frame encoding is concatenated with the auxiliary state information to form the complete state embedding. Actions in the maze consist of moving forward and turning left or right.
+
+For optimization, all architectures used the Adam optimization algorithm with gradients thresholded to a norm of 40. We used an auxiliary weighted entropy loss on the Synchronous Actor-Critic with weight 0.01. The learning rate for LSTM models was 0.0005, while for other architectures it was set to 0.00075. The hyperparameters were obtained during a limited hyperparameter sweep on a simpler version of the Indicator Maze environment. We trained A2C with a number of steps equal to the episode length (no truncated backprop). We trained the agent for 3000 steps, where each step consisted of a gradient obtained from 100 full episodes. The effective batch size was thus upper bounded by $5 0 0 * 1 0 0 = 5 0 0 0 0$ . We used multithreading to calculate the batch gradients efficiently. Each update step took on the order of 1-3 minutes depending on the number of threads available, meaning each agent took on the order of a week to train.
+
+The mazes were generated using an algorithm based on Depth-First Search. Once the completed fully-connected maze was generated, random walls were deleted with a probability $p$ . This $p$ probability was chosen at maze creation time and was sampled uniformly from between 0.0 and 0.6. Mazes were between size 4 to size 8. The size of a maze represents how many “cells” there are in the maze, where a cell is an area which can potentially have walls on each side. A set of 50 test maze geometries were sampled to act as a test set, and were made sure to never be sampled during training. These 50 test mazes were generated with $p = 0$ , so they represent the most difficult mazes seen during training due to their higher degree of partial-observability. Goal locations were sampled uniformly at random when the mazes are generated.
+
+Indicator Maze Details: The indicator mazes used a curriculum approach to accelerate learning. In $50 \%$ of the episodes sampled, only one goal existed in the environment and the indicator color matched the single goal color, making entering an incorrect goal impossible. This curriculum prevented the agents from learning to always enter a single color goal, which happened often when learning on only double goal environments. The test environments only used double goals. A reward of $+ 1$ was given to correct goal entry, and a negative reward of -1 was given to incorrect goal entry or episode terminating after a maximum number of time steps. These time steps depended on the maze size and were [150, 250, 300, 400, 500] for maze sizes [4, 5, 6, 7, 8]. At test time, the maximum time steps were extended to [300, 500, 600, 800, 1000].
+
+Repeating Maze Details We included the same curriculum as the indicator maze. Rewards were the same as the indicator maze. After the first time the agent reaches a goal, the red torch is shown at each subsequent episode (regardless of what the correct indicator was). Maximum time steps were again [150, 250, 300, 400, 500] for maze sizes [4, 5, 6, 7, 8]. At test time, the maximum time steps were extended to [300, 500, 600, 800, 1000].
+
+Minotaur Maze Details: For minotaur maze, a reward of $+ 0 . 5$ was given when reaching the randomly located goal and a reward of $+ 1 . 0$ was given when returning to the initial position. Episodes are terminated once the agent completes the return path, otherwise a negative reward of -1 is given if the agent exceeds the maximum number of steps. The maximum time steps were again [150, 250, 300, 400, 500] for maze sizes [4, 5, 6, 7, 8]. At test time, the maximum time steps were extended to [300, 500, 600, 800, 1000].
+
+<table><tr><td rowspan="2" colspan="2">Agent Maze Size</td><td colspan="3">Indicator</td><td colspan="3">Repeating</td><td colspan="3">Minotaur</td></tr><tr><td>4</td><td>5</td><td>6</td><td>4</td><td>5</td><td>6</td><td>4</td><td>5</td><td>6</td></tr><tr><td rowspan="2">σ=0</td><td>Acc</td><td>88.4</td><td>84.4</td><td>79.3</td><td>1</td><td>1</td><td>1</td><td>97.3</td><td>89.0</td><td>62.0</td></tr><tr><td>Rew</td><td>-</td><td>1</td><td>1</td><td>9.47</td><td>9.91</td><td>5.91</td><td>1.46</td><td>1.34</td><td>0.93</td></tr><tr><td rowspan="2">σ = 0.01</td><td>Acc</td><td>92.4</td><td>91.9</td><td>84.3</td><td>1</td><td>1</td><td>1</td><td>96.7</td><td>86.2</td><td>66.1</td></tr><tr><td>Rew</td><td>1</td><td>1</td><td>1</td><td>12.4</td><td>12.9</td><td>10.9</td><td>1.45</td><td>1.29</td><td>0.99</td></tr></table>
+
+Table 3: Results on the three 3D Doom maze tasks for the fixed-frame Neural Map with Controller LSTM. We can see that adding small compounding error does not largely affect the ability of the Neural Map to learn memory tasks and even has a beneficial effect for some tasks. Hyperparameters and architectures used were the same as presented in the main results.
+
+(Ego-)Neural Map Agent Details: For the global read operation, we used a convolutional network with 3 layers of 8 channels and kernel size 3. The strides were set to 1 on the first layer, and 2 to the second and third layers. Padding was 1 on the first layer and 0 on other layers. The 3 convolutional layers were then followed by a fully-connected layer of dimension 256 and then another fullyconnected layer of size 32. All activations were relu except the 32 dimension layer, which was set to tanh. The Neural Map itself was size $3 2 \mathrm { x } 1 5 \mathrm { x } 1 5$ . Positions were normalized so that the largest map size used all $1 5 \mathrm { x } 1 5$ positions, while smaller mazes used a subset of the map. Additionally, during writing we split the 32 channels of the map into 8 channels per orientation (so if the agent is facing north, it writes only to the first 8 dimensions, if south, the next 8, and so on).
+
+LSTM Agent Details: The LSTM agent had a single 256-dimension LSTM layer on top of the state embedding.
+
+FRMQN Agent Details: Each past history state was 64-dimensional (32-dimensional key $\pm \ 3 2 .$ - dimensional value feature). Due to large matrix multiplies from storing the entire episode history, having larger feature sizes causes the attention operation to start becoming prohibitively expensive.
+
+# D NEURAL MAP WITH DRIFT NOISE MODEL
+
+We did an additional experiment on the Neural Map that featured drift noise to simulate the effects of the agent using a local visual odometry model that had small error in predicting each frame-by-frame transformation. This is meant to represent a more realistic scenario (e.g. robotic navigation) where perfect localization is not feasible but a relatively accurate estimate can be provided, demonstrating the robustness of the architecture to noise. For example, we could assume the Neural Map is run in parallel with a SLAM algorithm which provides an estimate of the agent’s current position.
+
+To model this noise, we add a zero-mean gaussian random variable to the oracle position with a variance that depends on the current time-step. In more detail, the noise-corrupted positions $( \hat { x } , \hat { y } )$ in an $W \times W$ size map provided to the Neural Map are:
+
+$$
+\begin{array} { r l } & { ( \hat { x } , \hat { y } ) = ( \operatorname* { m a x } \{ \operatorname* { m i n } \{ \lfloor x + \epsilon _ { x } \rfloor , W - 1 \} , 0 \} , \operatorname* { m a x } \{ \operatorname* { m i n } \{ \lfloor y + \epsilon _ { y } \rfloor , W - 1 \} , 0 \} ) , } \\ & { \epsilon _ { x } , \epsilon _ { y } \sim \mathcal { N } ( 0 , \sigma ^ { 2 } t ) } \end{array}
+$$
+
+This simulates the effect of an odometry algorithm which has independent zero-mean gaussian error with equal variance. This error compounds over time causing the variance to grow with the time step. We evaluate the Neural Map with noise $\sigma = 1 / 1 0 0$ on smaller versions of the 3D Doom maze tasks (maze sizes [4, 5, 6]) and compare it to the version with perfect odometry. We train for 1500 steps of 100 episodes each step. Results are shown in Table 3. We can see that adding a small amount of error at each time step does not largely affect the results of the memory and can even benefit it, with some noticeable improvements on Indicator and Repeating tasks. It’s possible that the noise acts as a regularizer to speed up learning. For the Minotaur task, since positional information is important because the agent must remember the entire path taken, adding noise causes slight decrease in reward in mazes of size 4 and 5, but otherwise performance is very similar. Therefore this means that the Neural Map is likely to work in the case where a localization oracle is not available and instead only error-prone odometry is.
+
+We also plot some example trajectories to compare the effect of noise. We can see that the noise causes some slight aliasing in the position, which increases as time passes. The positions are quantized to a $1 5 \times 1 5$ grid.
+
+![](images/84779dc3af0ef8cc2512e5669cc80a83b8ac4eb6133c3594bfb79ca023c9ef39.jpg)  
+Figure 3: Top: Noisy v.s. Groundtruth Position trajectory (quantized to a $1 5 \times 1 5$ grid). As time progresses, the colors get lighter. Center: Neural Map cells addressed by the write operator under the noisy positions. Bottom: Neural Map cells that would have been written to under perfect position estimates.
+
+# E SAMPLES OF CONTEXT READ DISTRIBUTION
+
+# E.1 2D ENVIRONMENT
+
+To provide some insight into what the Neural Map learns, we show samples of the probability distribution given by the context read operation in a 2D maze example. We ran it on an example maze shown in Figure 4. In this figure, the top row of images are the agent observations, the center row are the fully observable mazes and the bottom row are the probability distributions over locations from the context operation, e.g. the $\alpha _ { t } ^ { ( x , y ) }$ values defined by Eq. 2. In this maze, the indicator is blue, which indicates that the teal goal should be visited. We can see that once the agent sees the incorrect red goal, the context distribution faintly focuses on the map location where the agent had observed the indicator. On the other hand, when the agent first observes the correct teal goal, the location where the agent observed the indicator lights up brightly. This means that the agent is using its context retrieval operation to keep track of the landmark (the indicator) that it has previously seen.
+
+![](images/f37c3d73963f794f333ce8aac652a9c3718f675657d2129200e4ba1807da78c9.jpg)  
+Figure 4: A few sampled states from an example episode demonstrating how the agent learns to use the context addressing operation of the Neural Map. The top row of images is the observations made by the agent, the center is the fully observable mazes and the bottom image is the probability distributions over locations induced by the context operation at that step.
+
+# E.2 3D ENVIRONMENT
+
+We draw some examples of the context addressing probability distribution in the 3D Doom environment in Figure 5 (allocentric) and Figure 6 (egocentric). We can see that the Neural Map learns to use its context addressing operator to retrieve the indicator torch identity, until it sees the correct corresponding tower. Once it sees the correct tower there is a shift in how the agent uses the map and the probability map seems to invert, addressing the parts of the map that were unexplored. This effect is consistent in both allocentric and egocentric variants. This might be because the Neural Map variant used on Doom had an internal LSTM which could enable it to remember the indicator identity for the short amount of time it took to walk up to the goal.
+
+Indicator Prediction To determine whether the Neural Map was accurately storing the indicator identity within its memory, we train a logistic regression model on memory vectors sampled over 75 episodes. We then attempt to predict the indicator on a held-out set of 25 episodes by taking the max prediction over all positions of the memory at the end of the episode. We can see that a simple logistic regression is capable of recovering the indicator in $100 \%$ of the episodes, showing that the indicator identity can be easily extracted from, e.g., the context operator.
+
+<table><tr><td>Agent</td><td>Indicator Accuracy</td></tr><tr><td>Controller NMap</td><td>100%</td></tr><tr><td>Controller Ego-NMap</td><td>100%</td></tr></table>
+
+Table 4: Figure showing accuracy of a logistic model to determine indicator identity from the stored Neural Map features.
+
+![](images/c8737215b5e2340ede5c54756af4aab06bafee71e94f71c7ba6af7ecd67225c8.jpg)  
+Figure 5: Three example episodes of the (allocentric) context addressing operator on Doom mazes. The top images of each row are the RGB inputs the agent sees, the center images are a top-down representation of the maze, and the bottom images are the $\alpha _ { t } ^ { ( x , y ) }$ of the context operation.
+
+![](images/757865053b472780e55b9e68d9a4bc5550b3e2745354499fdbcb397ce5c372ae.jpg)  
+Figure 6: Three example episodes of the (egocentric) context addressing operator on Doom mazes. The top images of each row are the RGB inputs the agent sees, the center images are a top-down representation of the maze, and the bottom images are the (egocentric) $\alpha _ { t } ^ { ( x , y ) }$ of the context operation.
+
+# F BACKTRACKING
+
+We also explored whether the allocentric and egocentric Neural Maps were capable of using their memories in order to do backtracking, i.e. re-visiting unexplored areas of the maze. To measure this, we developed a variant of the Indicator Maze where the goal states were removed. We want to measure how much of the maze is explored by the agent under this setting where there are no terminal states. To measure how much of the maze was explored, we quantized the 50 test mazes into 11 discrete positions and counted how many of the quantized positions the agent visited. We report results below in Table 5
+
+<table><tr><td>Agent</td><td>Visitation Score</td></tr><tr><td>Controller NMap</td><td>71.6%</td></tr><tr><td>Controller Ego-NMap LSTM</td><td>77.6% 68.5%</td></tr></table>
+
+Table 5: Visitation scores of the Neural Map models which measure how much of a maze is explored within a set time limit. We can see that the egocentric neural map explores more of the mazes than the allocentric model, exploring on average $7 7 . 6 \%$ of the test mazes. The allocentric neural map explores $7 1 . 6 \%$ of the test mazes. The LSTM is reported to provide a point of comparison.

parse/train/Bk9zbyZCZ/Bk9zbyZCZ_content_list.json

@@ -0,0 +1,1634 @@
+[
+    {
+        "type": "text",
+        "text": "NEURAL MAP: STRUCTURED MEMORY FOR DEEP REINFORCEMENT LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            821,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Emilio Parisotto & Ruslan Salakhutdinov   \nDepartment of Machine Learning   \nCarnegie Mellon University   \nPittsburgh, PA 15213, USA   \n{eparisot,rsalakhu}@cs.cmu.edu ",
+        "bbox": [
+            184,
+            170,
+            477,
+            239
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            276,
+            544,
+            291
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "A critical component to enabling intelligent reasoning in partially observable environments is memory. Despite this importance, Deep Reinforcement Learning (DRL) agents have so far used relatively simple memory architectures, with the main methods to overcome partial observability being either a temporal convolution over the past $k$ frames or an LSTM layer. More recent work (Oh et al., 2016) has went beyond these architectures by using memory networks which can allow more sophisticated addressing schemes over the past $k$ frames. But even these architectures are unsatisfactory due to the reason that they are limited to only remembering information from the last $k$ frames. In this paper, we develop a memory system with an adaptable write operator that is customized to the sorts of 3D environments that DRL agents typically interact with. This architecture, called the Neural Map, uses a spatially structured 2D memory image to learn to store arbitrary information about the environment over long time lags. We demonstrate empirically that the Neural Map surpasses previous DRL memories on a set of challenging 2D and 3D maze environments and show that it is capable of generalizing to environments that were not seen during training. ",
+        "bbox": [
+            233,
+            309,
+            764,
+            530
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            549,
+            336,
+            564
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Memory is a crucial aspect of an intelligent agent’s ability to plan and reason in partially observable environments. Without memory, agents must act reflexively according only to their immediate percepts and cannot execute plans that occur over an extended time interval. Recently, Deep Reinforcement Learning agents have been capable of solving many challenging tasks such as Atari Arcade Games (Mnih et al., 2015), robot control (Levine et al., 2016) and 3D games such as Doom (Lample & Chaplot, 2016), but successful behaviours in these tasks have often only been based on a relatively short-term temporal context or even just a single frame. On the other hand, many tasks require long-term planning, such as a robot gathering objects or an agent searching a level to find a key in a role-playing game. ",
+        "bbox": [
+            174,
+            575,
+            825,
+            702
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Neural networks that utilized external memories have recently had an explosion in variety, which can be distinguished along two main axes: memories with write operators and those without. Writeless external memory systems, often referred to as “Memory Networks” (Sukhbaatar et al., 2015; Oh et al., 2016), typically fix which memories are stored. For example, at each time step, the memory network would store the past M states seen in an environment. What is learnt by the network is therefore how to access or read from this fixed memory pool, rather than what contents to store within it. ",
+        "bbox": [
+            174,
+            708,
+            825,
+            805
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The memory network approach has been successful in language modeling, question answering (Sukhbaatar et al., 2015) and was shown to be a sucessful memory for deep reinforcement learning agents in complex 3D environments (Oh et al., 2016). By side-steping the difficulty involved in learning what information is salient enough to store in memory, the memory network introduces two main disadvantages. The first disadvantage is that a potentially significant amount of redundant information could be stored. The second disadvantage is that a domain expert must choose what to store in the memory, e.g. for the DRL agent, the expert must set M to a value that is larger than the time horizon of the currently considered task. ",
+        "bbox": [
+            174,
+            813,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "On the other hand, external neural memories having write operations are potentially far more efficient, since they can learn to store salient information for unbounded time steps and ignore any other useless information, without explicitly needing any a priori knowledge on what to store. One prominent research direction within write-based architectures has been neural memories based on the types of memory structures that are found in computers, such as tapes, RAM, and GPUs. In contrast to typical recurrent neural networks, these neural computer emulators have far more structured memories which follow many of the same design paradigms that digital computers have traditionally utilized. One such model, the Differentiable Neural Computer (DNC) (Graves et al., 2016) and its predecessor the Neural Turing Machine (NTM) (Graves et al., 2014), structure the architecture to explicitly separate memory from computation. The DNC has a recurrent neural controller that can access an external memory resource by executing differentiable read and write operations. This allows the DNC to act and memorize in a structured manner resembling a computer processor, where read and write operations are sequential and data is store distinctly from computation. The DNC has been used sucessfully to solve complicated algorithmic tasks, such as finding shortest paths in a graph or querying a database for entity relations. ",
+        "bbox": [
+            174,
+            104,
+            825,
+            311
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Building off these previous external memories, we introduce a new architecture called the Neural Map, a structured memory designed specifically for reinforcement learning agents in 3D environments. The Neural Map architecture overcomes some of the shortcomings of the previously mentioned neural memories. First, it uses an adaptable write operation and so its size and computational cost does not grow with the time horizon of the environment as it does with memory networks. Second, we impose a particular inductive bias on the write operation so that it is 1) well suited to 3D environments where navigation is a core component of sucessful behaviours, and 2) uses a sparse write operation that prevents frequent overwriting of memory locations that can occur with NTMs and DNCs. To accomplish this, we structure a DNC-style external memory in the form of a 2-dimensional map, where each position in the map is a distinct memory. ",
+        "bbox": [
+            174,
+            319,
+            825,
+            458
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To demonstrate the effectiveness of the neural map, we run it on a variety of 2D partially-observable maze-based environments and test it against LSTM and memory network policies. Finally, to establish its scalability, we run a Neural Map agent on a set of challenging 3D maze environments based on the video game Doom. ",
+        "bbox": [
+            174,
+            464,
+            825,
+            520
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 BACKGROUND ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            561,
+            326,
+            578
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "A Markov Decision Process (MDP) is defined as a tuple $( S , { \\mathcal { A } } , { \\mathcal { T } } , \\gamma , { \\mathcal { R } } )$ where $s$ is a finite set of states, $\\mathcal { A }$ is a finite set of actions, $\\boldsymbol { \\mathcal { T } } ( s ^ { \\prime } | s , a )$ is the transition probability of arriving in state $s ^ { \\prime }$ when executing action $a$ in initial state $s$ , $\\gamma$ is a discount factor, and $\\mathcal { R } ( s , a , s ^ { \\prime } )$ is the reward function of executing action $a$ in state $s$ and ending up at state $s ^ { \\prime }$ . We define a policy $\\pi ( \\cdot | s )$ as a mapping from a state $s$ to a distribution over actions, where $\\pi ( a _ { i } | s )$ denotes the probability of action $a _ { i }$ given that we are in state $s$ . The value of a policy $V ^ { \\pi } ( s )$ is the expected discounted cumulative reward when starting from state $s$ and sampling actions according to $\\pi$ , i.e.: $\\begin{array} { r } { V ^ { \\pi } ( s ) = \\mathbb { E } _ { \\pi } \\left[ \\sum _ { t = 0 } ^ { \\infty } \\gamma ^ { t } R _ { t } | s _ { 0 } = s \\right] } \\end{array}$ . ",
+        "bbox": [
+            174,
+            601,
+            825,
+            700
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "An optimal value function, denoted $V ^ { * } ( s )$ , is the maximum value we can get from state $s$ according   \nto any policy, i.e. $V ^ { * } ( s ) = \\operatorname* { m a x } _ { \\pi } V ^ { \\pi } ( s )$ . An optimal policy $\\pi ^ { * }$ is defined as a policy which achieves   \noptimal value at each state, i.e. $V ^ { \\pi ^ { * } } ( s ) = V ^ { * } ( s )$ . An optimal policy is guaranteed to exist (Sutton &   \nBarto, 1998). The REINFORCE algorithm (Williams, 1992) iteratively updates a given policy $\\pi$ in the optimal policy. This update direction is defined by being the future cumulated reward for a particular ep $\\nabla _ { \\pi } \\log \\pi ( a _ { t } | s _ { t } ) G _ { t }$ with varia $G _ { t } =$   \n$\\scriptstyle \\sum _ { k = 0 } ^ { \\infty } \\gamma ^ { k } R _ { t + k }$ $b _ { t } ( s _ { t } )$   \nof the current state. Therefore the baseline-augmented update equation is $\\begin{array} { r } { \\nabla _ { \\pi } \\log \\pi ( { a } _ { t } | { s } _ { t } ) ( G _ { t } - } \\end{array}$   \n$b _ { t } ( s _ { t } ) )$ . The typically used baseline is the value function, $b _ { t } ( s _ { t } ) \\stackrel { \\textstyle - } { = } V ^ { \\pi } ( s _ { t } )$ . This combination of   \nREINFORCE with value function baseline is commonly termed the “Actor-Critic” algorithm. ",
+        "bbox": [
+            174,
+            705,
+            825,
+            847
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we utilize Advantage Actor-Critic (A2C) (Mnih et al., 2016) with Generalized Advantage Estimation (Schulman et al., 2015), which can be seen as a specialization of the actor-critic framework when using deep networks to parameterize the policy and value function. The policy is a function of the state, parameterized as a deep neural network: ${ \\dot { \\pi } } ( a | s ) = f _ { \\theta } ( s , a )$ , where f is a deep neural network with parameter vector $\\theta$ . ",
+        "bbox": [
+            174,
+            853,
+            823,
+            922
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3 NEURAL MAP ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            323,
+            118
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section, we will describe the details of the neural map. We assume we want our agent to act within some 2- or 3-dimensional environment. The neural map is the agent’s internal memory storage that can be read from and written to during interaction with its environment, but where the write operator is selectively limited to affect only the part of the neural map that represents the area where the agent is currently located. For this paper, we assume for simplicity that we are dealing with a 2-dimensional map. This can easily be extended to 3-dimensional or even higher-dimensional maps (i.e. a 4D map with a 3D sub-map for each cardinal direction the agent can face). ",
+        "bbox": [
+            173,
+            127,
+            825,
+            227
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Let the agent’s position be $( x , y )$ with $x \\in \\mathbb { R }$ and $y \\in \\mathbb { R }$ and let the neural map $M$ be a $C \\times H \\times W$ feature block, where $C$ is the feature dimension, $H$ is the vertical extent of the map and $W$ is the horizontal extent. Assume there exists some coordinate normalization function $\\psi ( x , y )$ such that every unique $( x , y )$ can be mapped into $( x ^ { \\prime } , y ^ { \\prime } )$ , where $x ^ { \\prime } \\in \\{ 0 , \\ldots , W { - } 1 \\}$ and $y ^ { \\prime } \\in \\{ 0 , \\ldots , H { - } 1 \\}$ . For ease of notation, suppose in the sequel that all coordinates have been normalized by $\\psi$ into neural map space. ",
+        "bbox": [
+            173,
+            232,
+            825,
+            318
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Let $s _ { t }$ be the current state embedding, $M _ { t }$ be the current neural map, and $( x _ { t } , y _ { t } )$ be the current position of the agent. The Neural Map is defined by the following set of equations: ",
+        "bbox": [
+            173,
+            323,
+            823,
+            353
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/62ead24f1abbe29b7c9c3c326c4cdb5ea35ff00a96226c7199ab10eb752a47c6.jpg",
+        "text": "$$\n\\begin{array} { r l } & { { r _ { t } } = r e a d ( M _ { t } ) , ~ { c _ { t } } = c o n t e x t ( M _ { t } , s _ { t } , r _ { t } ) , } \\\\ & { } \\\\ { w _ { t + 1 } ^ { ( x _ { t } , y _ { t } ) } = w r i t e ( s _ { t } , r _ { t } , c _ { t } , M _ { t } ^ { ( x _ { t } , y _ { t } ) } ) , ~ M _ { t + 1 } = u p d a t e ( M _ { t } , w _ { t + 1 } ^ { ( x _ { t } , y _ { t } ) } ) , } \\\\ & { } \\\\ { o _ { t } = [ { r _ { t } } , c _ { t } , w _ { t + 1 } ^ { ( x _ { t } , y _ { t } ) } ] , ~ \\pi _ { t } ( a | s ) = \\mathrm { S o f t m a x } ( f ( o _ { t } ) ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            264,
+            357,
+            732,
+            424
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $w _ { t } ^ { ( x _ { t } , y _ { t } ) }$ represents the feature at position $( x _ { t } , y _ { t } )$ at time $t$ , $[ x _ { 1 } , \\ldots , x _ { k } ]$ represents a concatenation operation, and $o _ { t }$ is the output of the neural map at time $t$ which is then processed by another deep network $f$ to get the policy outputs $\\pi _ { t } ( a | s )$ . We will now separately describe each of the above operations in more detail: ",
+        "bbox": [
+            178,
+            429,
+            820,
+            487
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Global Read Operation: The read operation passes the current neural map $M _ { t }$ through a deep convolutional network and produces a $C$ -dimensional feature vector $r _ { t }$ . The global read vector $r _ { t }$ summarizes information about the entire map. ",
+        "bbox": [
+            174,
+            493,
+            825,
+            536
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Context Read Operation: The context operation performs context-based addressing to check whether certain features are stored in the map. It takes as input the current state embedding $s _ { t }$ and the current global read vector $r _ { t }$ and first produces a query vector $q _ { t }$ . The inner product of the query vector and each feature $M _ { t } ^ { ( x , y ) }$ in the neural map is then taken to get scores $a _ { t } ^ { ( x , y ) }$ at all positions $( x , y )$ . The scores are then normalized to get a probability distribution $\\alpha _ { t } ^ { ( x , y ) }$ over every position in the map, also known as “soft attention” (Bahdanau et al., 2015). This probability distribution is used to compute a weighted average $c _ { t }$ over all features $M _ { t } ^ { ( x , y ) }$ . To summarize: ",
+        "bbox": [
+            173,
+            541,
+            825,
+            651
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9c8eab6fac19b6fa6dc83e26923fbeb7ca6354d64c2a0793cd2089ef3b37a842.jpg",
+        "text": "$$\n\\begin{array} { r c l } { { } } & { { } } & { { q _ { t } = W [ s _ { t } , r _ { t } ] , a _ { t } ^ { ( x , y ) } = q _ { t } \\cdot M _ { t } ^ { ( x , y ) } , } } \\\\ { { } } & { { } } & { { \\alpha _ { t } ^ { ( x , y ) } = \\displaystyle \\frac { e ^ { a _ { t } ^ { ( x , y ) } } } { \\sum _ { ( w , z ) } e ^ { a _ { t } ^ { ( w , z ) } } } , c _ { t } = \\sum _ { ( x , y ) } \\alpha _ { t } ^ { ( x , y ) } M _ { t } ^ { ( x , y ) } , } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            330,
+            656,
+            666,
+            724
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $W$ is a weight matrix. The context read operation allows the neural map to operate as an associative memory: the agent provides some possibly incomplete memory (the query vector $q _ { t } \\mathrm { ~ . ~ }$ ) and the operation will return the completed memory that most closely matches $q _ { t }$ . So, for example, the agent can query whether it has seen something similar to a particular landmark that is currently within its view. ",
+        "bbox": [
+            173,
+            729,
+            825,
+            800
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Local Write Operation: Given the agent’s current position $( x _ { t } , y _ { t } )$ at time $t$ , the write operation takes as input the current state embedding $s _ { t }$ , the global read output $r _ { t }$ , the context read vector $c _ { t }$ and the current feature at position $( x _ { t } , y _ { t } )$ in the neural map $M _ { t } ^ { ( x _ { t } , y _ { t } ) }$ and produces, using a deep neural network fw, a new C-dimensional vector w(xt,yt+1 . This vector functions as the new local write candidate vector at the current position $( x _ { t } , y _ { t } )$ : $w _ { t + 1 } ^ { ( x _ { t } , y _ { t } ) } = f _ { w } ( [ s _ { t } , r _ { t } , c _ { t } , M _ { t } ^ { ( x _ { t } , y _ { t } ) } ] )$ ",
+        "bbox": [
+            173,
+            806,
+            825,
+            891
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "GRU-based Local Write Operation As previously defined, the write operation simply replaces the vector at the agent’s current position with a new feature produced by a deep network. Instead of this hard rewrite of the current position’s feature vector, we can use a gated write operation based on the recurrent update equations of the Gated Recurrent Unit (GRU) (Chung et al., 2014). Gated write operations have a long history in unstructured recurrent networks and they have shown a superior ability to maintain information over long time lags versus ungated networks. The GRU-based write operation is defined as: ",
+        "bbox": [
+            173,
+            895,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5b64bca7ddb519824bffec84ae1a856e9b7144f81e0941274a37d8b5a1e1865e.jpg",
+        "text": "$$\n\\begin{array} { r l } & { r _ { t + 1 } ^ { ( x _ { t } , y _ { t } ) } = \\sigma ( W _ { r } [ s _ { t } , r _ { t } , c _ { t } , M _ { t } ^ { ( x _ { t } , y _ { t } ) } ] ) } \\\\ & { \\hat { w } _ { t + 1 } ^ { ( x _ { t } , y _ { t } ) } = \\operatorname { t a n h } ( W _ { \\hat { h } } [ s _ { t } , r _ { t } , c _ { t } ] + U _ { \\hat { h } } ( r _ { t + 1 } ^ { ( x _ { t } , y _ { t } ) } \\odot M _ { t } ^ { ( x _ { t } , y _ { t } ) } ) ) } \\\\ & { z _ { t + 1 } ^ { ( x _ { t } , y _ { t } ) } = \\sigma ( W _ { z } [ s _ { t } , r _ { t } , c _ { t } , M _ { t } ^ { ( x _ { t } , y _ { t } ) } ] ) } \\\\ & { w _ { t + 1 } ^ { ( x _ { t } , y _ { t } ) } = ( 1 - z _ { t + 1 } ^ { ( x _ { t } , y _ { t } ) } ) \\odot M _ { t } ^ { ( x _ { t } , y _ { t } ) } + z _ { t + 1 } ^ { ( x _ { t } , y _ { t } ) } \\odot \\hat { w } _ { t + 1 } ^ { ( x _ { t } , y _ { t } ) } , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            303,
+            179,
+            692,
+            270
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $x { \\odot } y$ is the Hadamard product between vectors $x$ and $y , \\sigma ( \\cdot )$ is the sigmoid activation function and W∗ and U∗ are weight matrices. Using GRU terminology, r(xt,yt+1 ) is the reset gate, wˆ(xt,t+1 $\\hat { w } _ { t + 1 } ^ { ( x _ { t } , y _ { t } ) }$ is the candidate activation and the GRU-based update can $z _ { t + 1 } ^ { ( x _ { t } , y _ { t } ) }$ is the update gate. By making use of the reset and update gates,e how much the new write vector should differ from the currently stored feature. ",
+        "bbox": [
+            173,
+            273,
+            826,
+            352
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Map Update Operation: The update operation creates the neural map for the next time step. The new neural map $M _ { t + 1 }$ is equal to the old neural map $M _ { t }$ , except at the current agent position $( x _ { t } , y _ { t } )$ , where the current write candidate vector w(xt,yt+1 is stored: ",
+        "bbox": [
+            174,
+            358,
+            825,
+            406
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/897b73aebafa41c72f7158b75f63a4e8454eb64b35ec1c25d9850bf9668eaf26.jpg",
+        "text": "$$\n\\begin{array} { r } { M _ { t + 1 } ^ { ( a , b ) } = \\left\\{ \\begin{array} { l l } { w _ { t + 1 } ^ { ( x _ { t } , y _ { t } ) } , } & { \\mathrm { f o r } ( a , b ) = ( x _ { t } , y _ { t } ) } \\\\ { M _ { t } ^ { ( a , b ) } , } & { \\mathrm { f o r } ( a , b ) \\neq ( x _ { t } , y _ { t } ) } \\end{array} \\right. } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            346,
+            412,
+            642,
+            455
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 EGO-CENTRIC NEURAL MAP ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            469,
+            447,
+            487
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "A major disadvantage of the neural map as previously described is that it requires some oracle to provide the current $( x , y )$ position of the agent. This is a difficult problem in and of itself, and, despite being well studied, it is far from solved. The alternative to using absolute positions within the map is to use relative positions. That is, whenever the agent moves between time steps with some velocity $( u , v )$ , the map is counter-transformed by $\\left( - u , - v \\right)$ , i.e. each feature in the map is shifted in the $H$ and $W$ dimensions. This will mean that the map will be ego-centric, i.e. the agent’s position will stay stationary in the center of the neural map while the world as defined by the map moves around them. Therefore in this setup we only need some way of extracting the agent’s velocity, which is typically a simpler task in real environments (for example, animals have inner ears and robots have accelerometers). Here we assume that there is some function $ { \\boldsymbol { \\xi } } ( u ^ { \\prime } , v ^ { \\prime } )$ that discretizes the agent velocities $( u ^ { \\prime } , v ^ { \\prime } )$ so that they represent valid velocities within the neural map $( u , v )$ . In the sequel, we assume that all velocies have been properly normalized by $\\xi$ into neural map space. ",
+        "bbox": [
+            173,
+            501,
+            826,
+            683
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Let $( p w , p h )$ be the center position of the neural map. The updated ego-centric neural map operations are shown below: ",
+        "bbox": [
+            171,
+            689,
+            823,
+            718
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3fff251d6ca8af0228c6bd66d096477c27bc8e4d6c492038ba86706e06fc8598.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\overline { { M } } _ { t } = C o u n t e r T r a n s f o r m ( M _ { t } , ( u _ { t } , v _ { t } ) ) } \\\\ & { \\qquad r _ { t } = r e a d ( \\overline { { M } } _ { t } ) \\quad c _ { t } = c o n t e x t ( \\overline { { M } } _ { t } , s _ { t } , r _ { t } ) } \\\\ & { w _ { t + 1 } ^ { ( p w , p h ) } = w r i t e \\big ( s _ { t } , r _ { t } , c _ { t } , \\overline { { M } } _ { t } ^ { ( p w , p h ) } \\big ) \\quad M _ { t + 1 } = e g o u p d a t e ( \\overline { { M } } _ { t } , w _ { t + 1 } ^ { ( p w , p h ) } ) } \\\\ & { \\qquad \\quad o _ { t } = \\big [ r _ { t } , c _ { t } , w _ { t + 1 } ^ { ( p w , p h ) } \\big ] \\quad \\pi _ { t } = \\mathrm { S o f t m a x } ( f ( o _ { t } ) ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            243,
+            722,
+            753,
+            810
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Where $\\overline { { M } } _ { t }$ is the current neural map $M _ { t }$ reverse transformed by the current velocity $\\left( { { u } _ { t } } , { { v } _ { t } } \\right)$ so that the agents map position remains in the center $( p w , p h )$ . ",
+        "bbox": [
+            169,
+            816,
+            825,
+            845
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Counter Transform Operation: The CounterT ransform operation transforms the current neural map $M _ { t }$ by the inverse of the agent’s current velocity $\\left( { { u } _ { t } } , { { v } _ { t } } \\right)$ . Written formally: ",
+        "bbox": [
+            169,
+            852,
+            821,
+            881
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a423fb13d38037b0b21541c29a239e271554c6ddb771986bb9ef8a66defb6899.jpg",
+        "text": "$$\n\\overline { { { M } } } _ { t } ^ { ( a , b ) } = \\left\\{ \\begin{array} { l r } { { M _ { t } ^ { ( a - u , b - v ) } , } } & { { \\mathrm { f o r ~ } ( a - u ) \\in \\{ 1 , . . . , W \\} \\wedge ( b - v ) \\in \\{ 1 , . . . , H \\} } } \\\\ { { 0 , } } & { { \\mathrm { e l s e } } } \\end{array} \\right.\n$$",
+        "text_format": "latex",
+        "bbox": [
+            285,
+            886,
+            700,
+            921
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/48b8373f7563b8c9f4e3fc95fa0ca6cc4755cc7ad4e7b8acb7bb536536aa4e7b.jpg",
+        "image_caption": [
+            "Figure 1: Left: Images showing the 2D maze environment. The left side (Fig. 1a) represents the fully observable maze while the right side (Fig. 1b) represents the agent observations. The agent is represented by the yellow pixel with its orientation indicated by the black arrow within the yellow block. The starting position is always the topmost position of the maze. The red bounding box represents the area of the maze that is subsampled for the agent observation. In “Goal-Search”, the goal of the agent is to find a certain color block (either red or teal), where the correct color is provided by an indicator (either green or blue). This indicator has a fixed position near the start position of the agent. Right: State observations from the “Indicator” Doom maze environment. The agent starts in the middle of a maze looking in the direction of a torch indicator. The torch can be either green (top-left image) or red (bottom-left image) and indicates which of the goals to search for. The goals are two towers which are randomly located within the maze and match the indicator color. The episode ends whenever the agent touches a tower, whereupon it receives a positive reward if it reached the correct tower, while a negative reward otherwise. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            254,
+            90,
+            761,
+            258
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "While here we only deal with reverse translation, it is possible to handle rotations as well if the agent can measure it’s angular velocity. ",
+        "bbox": [
+            173,
+            441,
+            823,
+            470
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Map Egoupdate Operation: The egoupdate operation is functionally equivalent to the update operation except only the center position $( p w , p h )$ is ever written to: ",
+        "bbox": [
+            171,
+            477,
+            823,
+            506
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4a7071f2093fb0551f73da23be6bc48082c91df71bb96cfd99b7eea6bc30fc18.jpg",
+        "text": "$$\nM _ { t + 1 } ^ { \\left( a , b \\right) } = \\left\\{ \\begin{array} { l l } { w _ { t + 1 } ^ { \\left( p w , p h \\right) } , } & { \\mathrm { f o r } \\left( a , b \\right) = \\left( p w , p h \\right) } \\\\ { \\overline { { M } } _ { t } ^ { \\left( a , b \\right) } , } & { \\mathrm { f o r } \\left( a , b \\right) \\neq \\left( p w , p h \\right) } \\end{array} \\right.\n$$",
+        "text_format": "latex",
+        "bbox": [
+            339,
+            513,
+            648,
+            556
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "5 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            574,
+            326,
+            590
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To demonstrate the effectiveness of the Neural Map, we run it on 2D and 3D maze-based environments where memory is crucial to optimal behaviour. We compare to previous memory-based DRL agents, namely a simple LSTM-based agent which consists of a single pre-output LSTM layer as well as MemNN (Oh et al., 2016) agents. ",
+        "bbox": [
+            174,
+            606,
+            825,
+            662
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "5.1 2D GOAL-SEARCH ENVIRONMENT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            681,
+            455,
+            695
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The “Goal-Search” environment is adapted from Oh et al. (2016). Here the agent starts in a fixed starting position within some randomly generated maze with two randomly positioned goal states. It then observes an indicator at a fixed position near the starting state (i.e. the green tile at the top of the maze in Fig. 1a). This indicator will tell the agent which of the two goals it needs to go to (blue indicator teal goal, green indicator red goal). If the agent goes to the correct goal, it gains a positive reward while if it goes to the incorrect goal it gains a negative reward. Therefore the agent needs to remember the indicator as it searches for the correct goal state. In depth details of the 2D environment are given in Appendix B. The mazes during training are generated using a random generator. A held-out set of 1000 random mazes is kept for testing. This test set therefore represents maze geometries that have never been seen during training, and measure the agent’s ability to generalize to new environments. ",
+        "bbox": [
+            174,
+            707,
+            825,
+            861
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The first baseline agent we evaluate is a recurrent network with 128 LSTM units. The other baseline is the MQN, which is a memory-network-based architecture that performs attention over the past K states it has seen (Oh et al., 2016). Both LSTM and MQN models receive a one-hot encoding of the agent’s current location, previous velocity, and current orientation at each time step, in order to make the comparison to the fixed-frame Neural Map fair. We test these baselines against several Neural Map architectures, with each architecture having a different design choice. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/c86681208ae12052207e3d09248a2dc4e6a11a7fe07a745063b81c9a1d1b2d86.jpg",
+        "table_caption": [
+            "2D Goal-Search ",
+            "Table 1: Results of several different agent architectures on the “Goal-Search” environment. The “train” columns represents the number of mazes solved (in $\\%$ ) when sampling from the same distribution as used during training. The “test” columns represents the number of mazes solved when run on a set of held-out maze samples which are guaranteed not to have been sampled during training. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Agent</td><td colspan=\"3\">Train</td><td colspan=\"3\">Test</td></tr><tr><td>7-11</td><td>13-15</td><td>Total</td><td>7-11</td><td>13-15</td><td>Total</td></tr><tr><td>Random</td><td>41.9%</td><td>25.7%</td><td>38.1%</td><td>46.0%</td><td>29.6%</td><td>38.8%</td></tr><tr><td>LSTM</td><td>84.7%</td><td>74.1%</td><td>87.4%</td><td>96.3%</td><td>83.4%</td><td>91.4%</td></tr><tr><td>MQN-32</td><td>80.2%</td><td>64.4%</td><td>83.3%</td><td>95.9%</td><td>74.6%</td><td>87.4%</td></tr><tr><td>MQN-64</td><td>83.2%</td><td>69.6%</td><td>85.8%</td><td>96.5%</td><td>76.7%</td><td>88.3%</td></tr><tr><td>Neural Map (15x15)</td><td>92.4%</td><td>80.5%</td><td>89.2%</td><td>93.5%</td><td>87.9%</td><td>91.7%</td></tr><tr><td>Neural Map + GRU (15x15)</td><td>97.0%</td><td>89.2%</td><td>94.9%</td><td>97.7%</td><td>94.0%</td><td>96.4%</td></tr><tr><td>Neural Map + GRU(8x8)</td><td>94.9%</td><td>90.7%</td><td>95.6%</td><td>98.0%</td><td>95.8%</td><td>97.3%</td></tr><tr><td>Neural Map +GRU + Pos (8x8)</td><td>95.0%</td><td>91.0%</td><td>95.9%</td><td>98.3%</td><td>94.3%</td><td>96.5%</td></tr><tr><td>Neural Map + GRU + Pos (6x6)</td><td>90.9%</td><td>83.2%</td><td>91.8%</td><td>97.1%</td><td>90.5%</td><td>94.0%</td></tr><tr><td>Ego Neural Map + GRU (15x15)</td><td>94.6%</td><td>91.1%</td><td>95.4%</td><td>97.7%</td><td>92.1%</td><td>95.5%</td></tr><tr><td>Ego Neural Map +GRU + Pos (15x15)</td><td>74.6%</td><td>63.9%</td><td>78.6%</td><td>87.8%</td><td>73.2%</td><td>82.7%</td></tr></table>",
+        "bbox": [
+            199,
+            113,
+            799,
+            281
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            443,
+            823,
+            470
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The results are reported in Table 1. During testing, we extend the maximum episode length from 100 to 500 steps so that the agent is given more time to solve the maze. The brackets next to the model name represent the Neural Map dimensions of that particular model. From the results we can see that the Neural Map architectures solve the most mazes in both the training and test distributions compared to both LSTM and MQN baselines. ",
+        "bbox": [
+            174,
+            477,
+            825,
+            547
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The results also demonstrate the effect of certain design decisions. One thing that can be observed is that using GRU updates adds several percentage points to the success rate (“Neural Map (15x15)” v.s. “Neural $\\mathrm { M a p } + \\mathrm { G R U } \\left( 1 5 \\mathrm { x } 1 5 \\right) ^ { \\circ } )$ . We also tried downsampled Neural Maps, such that a pixel in the memory map represents several discrete locations in the environment. The Neural Map seems quite robust to this downsampling, with a downsampling of around 3 (6x6 v.s. 15x15) doing just a few percentage points worse, and still beating all baseline models. The 6x6 model has approximately the same number of memory cells as “MQN- $. 3 2 ^ { \\circ }$ , but its performance is much better, showing the benefit of having learnable write operations. For the egocentric model, in order to cover the entire map we set the pixels to be $2 \\mathbf { x }$ smaller in each direction, so each pixel is only a quarter of a pixel in the fixed-frame map. Even with this coarser representation, the egocentric model did similarly to the fixed frame one. We demonstrate an example of what the Neural Map learned to address using its context operator in Appendix E. ",
+        "bbox": [
+            173,
+            554,
+            825,
+            720
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Finally, we tried adding the one-hot position encoding as a state input to the Neural Map, as is done for the baselines. We can see that there is a small improvement, but it is largely marginal, with the Neural Map doing a decent job of learning how to represent its own position without needing to be told explicitly. One interesting thing that we observed is that having the one-hot position encoding as an input to the egocentric map decreased performance, perhaps because it is difficult for the network to learn a mapping between fixed and egocentric frames. ",
+        "bbox": [
+            174,
+            728,
+            825,
+            813
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Note that sometimes the percentage results are lower for the training distribution. This is mainly because the training set encompases almost all random mazes except the fixed 1000 of the test set, thus making it likely that the agent sees each training map only once. ",
+        "bbox": [
+            174,
+            819,
+            823,
+            861
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Beyond train/test splits, the results are further separated by maze size. This information reveals that the memory networks are hardest hit by increasing maze size with sometimes a $20 \\%$ drop in success on 13-15 v.s. 7-11. This is perhaps unsurprising given the inherent fixed time horizon of memory netwoks, and further reveals the benefit of using write-based memories. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/4214ed9336fcb3cd9e922057d42b4aa5a46c785d9a82e03be29dbdf15a3a7649.jpg",
+        "image_caption": [
+            "Figure 2: Top-down views showing succesful episodes in each of the 3 Doom maze tasks. The red lines indicate the path traveled by the agent. Indicator is shown in Fig. 2a, where the agent receives positive reward when entering the corresponding tower that matches the torch color it saw at the start of the episode and a negative reward otherwise. The episode terminates once the agent has reached a tower. Repeating, shown in Fig. 2b, has the same underlying mechanics except (1) the episode persists for $T$ time steps regardless of towers entered and (2) the torch indicator is removed from the maze after the agent has reached a tower once. Therefore the agent needs to find the correct tower and then optimize its path to that tower. Minotaur shown in Fig. 2c requires the agent to reach the red goal and then return to the green goal that is at its starting position. Here the torch does not have any function. This fully-observable top-down view was not made available to the agent and is only used for visualization. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            99,
+            810,
+            223
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.2 3D DOOM ENVIRONMENT DESCRIPTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            393,
+            495,
+            409
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To demonstrate that our method can work in much more complicated 3D environments with longer time lags, we implemented three 3D maze environments using the ViZDoom (Kempka et al., 2016) API and a random maze generator. Examples of all three environments are given in Figure 2. ",
+        "bbox": [
+            176,
+            426,
+            821,
+            469
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Indicator Maze: The first environment is a recreation of the 2D indicator maze task, where an indicator is positioned in view of the player’s starting state which is either a torch of red or green color. The goals are corresponding red/green towers that are randomly positioned throughout the maze that the player must locate. ",
+        "bbox": [
+            173,
+            477,
+            825,
+            532
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Repeating Maze: The second environment is a variant of this indicator maze but whenever the player enters a goal state, it is teleported back to the beginning of the maze without terminating the episode (i.e. it retains its memory of the current maze). It gains a positive reward if it reaches the correct goal and a negative reward if it reaches the incorrect goal. After the first goal is reached, the correct indicator color is no longer displayed within the maze and a red indicator is displayed afterwards instead (regardless if the correct goal is green). An episode ends after a predetermined number of steps which depends on the maze size. The goal is therefore to find a path to the correct goal, and then optimize that path so that it can reach it as many times as possible. ",
+        "bbox": [
+            173,
+            539,
+            825,
+            651
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Minotaur Maze: The third environment has the agent start in a fixed starting position next to the green tower, while the red tower is randomly placed somewhere in the maze. The agent receives a small positive reward if it reaches the red tower, and a larger positive reward if after reaching the red tower it returns to the green tower. Therefore the agent must efficiently navigate to the red goal while accurately remember its entire path it so that it can backtrack to the start. ",
+        "bbox": [
+            174,
+            657,
+            825,
+            728
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "All three environments used a $\\mathrm { R G B + D }$ image of size $1 0 0 \\mathrm { x } 6 0$ as input. We generate maze geometries randomly at train time but make sure to exclude a test set of 10 mazes for each size [4, 5, 6, 7, 8] (50 total). For these environments, we tested out four architectures (see Appendix C for more details on both environments and architectures): ",
+        "bbox": [
+            174,
+            734,
+            823,
+            790
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Neural Map with Controller LSTM: Standard Neural Map with fixed frame addressing and GRU updates. We combine the neural map design with an LSTM that aggregates past state, read and context vectors and produces the query vector for the next time step’s context read operation. See Appendix A for the modified Neural Map equations. ",
+        "bbox": [
+            174,
+            796,
+            825,
+            853
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Ego Neural Map with Controller LSTM: Same as previous but with ego-centric addressing. The other difference is that the Ego Neural Map does not receive any positional input unlike the other 3 models, only receiving frame-by-frame ego-motion (quantized to a coarse grid). ",
+        "bbox": [
+            174,
+            859,
+            825,
+            902
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "LSTM: Single pre-output 256-dimensional LSTM layer. ",
+        "bbox": [
+            173,
+            909,
+            545,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/614a33b65358de9058b70a8d990532802444c83ce1eed5f800b875855b28cce1.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Agent Maze Size</td><td colspan=\"6\">Indicator</td><td colspan=\"6\">Repeating</td><td colspan=\"4\">Minotaur</td></tr><tr><td>4</td><td></td><td>5</td><td>6</td><td>8</td><td></td><td>4</td><td>5</td><td>6</td><td>7</td><td>8</td><td>4</td><td>5</td><td>6</td><td>7</td><td>8</td></tr><tr><td rowspan=\"2\">LSTM</td><td>Acc</td><td>95.7</td><td>87.5</td><td>81.1</td><td>71.4</td><td>60.3</td><td>-</td><td>-</td><td>-</td><td>1</td><td>-</td><td>90.0</td><td>71.5</td><td>48.0</td><td>34.2</td><td>29.4</td></tr><tr><td>Rew</td><td>-</td><td>1</td><td>1</td><td>1</td><td>-</td><td>7.26</td><td>7.58</td><td>6.065.32</td><td></td><td>4.98</td><td>1.35</td><td>1.07</td><td>0.72</td><td>0.51</td><td>0.44</td></tr><tr><td rowspan=\"2\">FRMQN</td><td>Acc</td><td>87.3</td><td>82.9</td><td>78.0</td><td>72.0</td><td>59.8</td><td>-</td><td>-</td><td>1</td><td>1</td><td>1</td><td>72.7</td><td>54.5</td><td>38.8</td><td>28.8</td><td>23.7</td></tr><tr><td>Rew</td><td>-</td><td>-</td><td>-</td><td>1</td><td>-</td><td>1.45</td><td>1.65</td><td>1.51</td><td>1.37</td><td>1.09</td><td>1.09</td><td>0.82</td><td>0.58</td><td>0.43</td><td>0.36</td></tr><tr><td rowspan=\"2\">Controller</td><td>Acc</td><td>95.8</td><td>90.3</td><td>81.8</td><td>80.4</td><td>70.3</td><td>-</td><td>1</td><td>1</td><td></td><td></td><td>99.7</td><td>92.2</td><td>67.5</td><td>37.9</td><td>30.2</td></tr><tr><td>Rew</td><td>-</td><td>1</td><td>-</td><td>1</td><td>-</td><td>17.4</td><td>17.1</td><td>12.0</td><td>1 11.4</td><td>1 12.3</td><td>1.50</td><td>1.38</td><td>1.01</td><td>0.57</td><td>0.45</td></tr><tr><td>NMap Controller</td><td>Acc</td><td>94.6</td><td>91.0</td><td>87.6</td><td>85.8</td><td>72.2</td><td></td><td>-</td><td></td><td></td><td></td><td>98.6</td><td>90.0</td><td>65.2</td><td>44.7</td><td>33.8</td></tr><tr><td>Ego-NMap</td><td>Rew</td><td>1</td><td>-</td><td>-</td><td>1</td><td>1</td><td>- 12.8</td><td>14.1</td><td>1 11.0</td><td>- 10.4</td><td>- 9.72</td><td>1.48</td><td>1.35</td><td>0.98</td><td>0.67</td><td>0.51</td></tr></table>",
+        "bbox": [
+            156,
+            102,
+            838,
+            233
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 2: Doom results on mazes not observed during training for the three tasks: Indicator, Repeating and Minotaur. Acc stands for Accuracy and Rew for Reward. Accuracy for Indicator means $\\%$ of correct goals reached, while for Minotaur it means $\\%$ of episodes where the agent successfully reached the goal and then backtracked to the beginning. Reward for Repeating is number of times correct goal was visited within the allotted time steps $_ { + 1 }$ for correct goal, -1 for incorrect goal). Reward for Minotaur is $+ 0 . 5$ for reaching the goal and then $+ 1 . 0$ for backtracking to start after reaching goal (max episode reward is $+ 1 . 5$ ). We tested on maze sizes between [4,8] with 10 test mazes for each size. For each of the 50 total test mazes we ran 100 episodes with random goal locations and averaged the result. ",
+        "bbox": [
+            173,
+            244,
+            825,
+            347
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "FRMQN (Oh et al., 2016): Memory network with LSTM feedback. This design uses an LSTM to make recurrent context queries to the memory network database. In addition, for the memory network baselines we did not set a fixed $\\mathbf { k }$ but instead let it access any state from its entire episode. This means no information is lost to the memory network, it only needs to process its history. ",
+        "bbox": [
+            174,
+            363,
+            823,
+            420
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The results are shown in Table 2. We can see that the Neural Map architectures work better than the baseline models, even though the memory network has access to its entire episode history at every time step. The ego-centric Neural Map beats the fixed frame map at Indicator, and gets similar performance on both Repeating and Minotaur environments, showing the ability of the Neural Map to function effectively even without global position information. It is possible that having a fixed frame makes path optimization easier, which would explain the larger rewards that the fixed-frame model got in the Repeating task. We also investigated whether the neural map is robust to localization noise, which would be the case in a real world setting where we do not have access to a localization oracle and must instead rely on an error-prone odometry or SLAM-type algorithm to do localization. These results are presented in Appendix D. ",
+        "bbox": [
+            174,
+            426,
+            825,
+            565
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "For the baselines, we can see that FRMQN has difficulty learning on Repeating, only reaching the goal on average once. This could be because the indicator is only shown before the first goal is reached and so afterwards it needs to remember increasingly longer time horizons. Furthermore, because the red indicator is always shown after the first goal is reached, it might be difficult for the model to learn to do retrieval since the original correct indicator must be indexed by time and not image similarity. The FRMQN also has difficulty on Minotaur, probably due to needing to remember and organize a lot of spatial information (i.e. what actions were taken along the path). For Indicator, the FRMQN does similarly to the LSTM. We can see that the spatial structure of the Neural Map aids in optimizing the path in Repeating, averaging 12 goal reaches even in the largest maze size. ",
+        "bbox": [
+            174,
+            571,
+            825,
+            699
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            718,
+            343,
+            734
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Other than the straightforward architectures of combining an LSTM with Deep Reinforcement Learning (DRL) (Mnih et al., 2016; Hausknecht & Stone, 2015), there has also been work on using more advanced external memory systems with DRL agents to handle partial observability. Oh et al. (2016) used a memory network (MemNN) to solve maze-based environments similar to the ones presented in this paper. MemNN keeps the last $M$ states in memory and encodes them into (key, value) feature pairs. It then queries this memory using a soft attention mechanism similar to the context operation of the Neural Map, except in the Neural Map the key/value features were written by the agent and aren’t just a stored representation of the last $M$ frames seen. Oh et al. (2016) tested a few variants of this basic model, including ones which combined both LSTM and memory-network style memories. ",
+        "bbox": [
+            174,
+            750,
+            825,
+            888
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In contrast to memory networks, another research direction is to design recurrent architectures that mimic computer memory systems. These architectures explicitly separate computation and memory in a way anagolous to a modern digital computer, in which some neural controller (akin to a CPU) interacts with an external memory (RAM). One recent model is similar to the Neural Map, called the Differentiable Neural Computer (DNC) (Graves et al., 2016), which combines a recurrent controller with an external memory system that allows several types of read/write access. In addition to defining an unconstrained write operator (in contrast to the neural map’s write location being fixed), the DNC has a selective read operation that reads out the memory either by content or in the order that it was written. While the DNC is more specialized to solving algorithmic problems, the Neural Map can be seen as an extension of this Neural Computer framework to 3D environments, with a specific inductive bias on its write operator that allows sparse writes. Recently work has also been done toward sparsifying the read and write operations of the DNC (Rae et al., 2016). This work was not focused on 3D environments and did not make any use of task-specific biases like agent location, but instead used more general biases like “Least-Recently-Used” memory addresses to force sparsity. More recently, the DNC, in conjunction with a VIN planning network (Tamar et al., 2016), has been applied to the task of navigating partially-observable environments (Khan et al., 2018) although it still relied on supervised learning in order to train the complete system. ",
+        "bbox": [
+            173,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            104,
+            825,
+            311
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Gupta et al. (2017) designed a similar 2D map structured memory, with the aim to do robot navigation in 3D environments. These environments were based off image scans of real office buildings, and they were preprocessed into a grid-world by quantizing the possible positions and orientations the agent could assume. In contrast to our paper, which presents the Neural Map more as a general memory architecture for DRL agents, Gupta et al. (2017) focuses mainly on solving the task of robot navigation, with the internal map’s representation mainly used to represent free space around the robot. More concretely, the task in these environments was to navigate to a goal state, with the goal position either stated semantically (find a chair) or stated in terms of the position relative to the robot’s coordinate frame. Another key difference was that their formulation lacked a context addressing operation. Finally, their method used DAGGER (Ross et al., 2011), an imitation learning algorithm, to train their agent. Since Doom actions affect translational/rotational accelerations, training using imitation learning is more difficult since a search algorithm cannot be used directly as supervision. An interesting addition they made was the use of a multi-scale map representation and a Value Iteration network (Tamar et al., 2016) to do better path planning. Another related work, Neural SLAM (Zhang et al., 2017) extends spatial memories to settings where localization/odometry is not provided a priori, but instead has to be completed in tandem with the mapping of the environment. In order to accomplish that, a grid-based localization system was combined with a Neural Map-style memory in order to do differentiable SLAM-like combined localization and mapping. ",
+        "bbox": [
+            174,
+            318,
+            825,
+            568
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "7 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            580,
+            318,
+            595
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this paper we developed a neural memory architecture that organizes the spatial structure of its memory in the form of a 2D map, and allows sparse writes to this memory where the memory address of the write is in a correspondence to the agent’s current position in the environment. We showed its ability to learn, using a reinforcement signal, how to behave within challenging 2D and 3D maze tasks that required storing information over long time steps. The results demonstrated that our architecture surpassed baseline memories used in previous work. Additionally, we showed the benefit of certain design decisions made in our architecture: using GRU updates instead of hard writes, demonstrating that the ego-centric viewpoint does not diminish performance and that the Neural Map is robust to downsampling its memory. Finally, to show that our method can scale up to more difficult 3D environments, we implemented several new maze environments in Doom. Using a hybrid Neural $\\mathbf { M a p } + \\mathbf { L S T M }$ model, we were able to solve most of the scenarios at a performance higher than previous DRL memory-based architectures. Furthermore, we demonstrated the ability of the Neural Map to be robust to a certain level of drift noise in its localization estimate. ",
+        "bbox": [
+            174,
+            612,
+            825,
+            791
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgements ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            799,
+            310,
+            813
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "This work was supported by Apple, DARPA award D17AP00001, the Google focused award. The authors would also like to thank NVidia NVAIL award for donating DGX-1 deep learning machine. This work used the Extreme Science and Engineering Discovery Environment (XSEDE), which is supported by National Science Foundation grant number OCI-1053575. Specifically, it used the Bridges system, which is supported by NSF award number ACI-1445606, at the Pittsburgh Supercomputing Center (PSC). ",
+        "bbox": [
+            174,
+            820,
+            825,
+            904
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            287,
+            117
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "D. Bahdanau, K. H. Cho, and Y. Bengio. Neural machine translation by jointly learning to align and translate. In Proceedings of the 3rd International Conference on Learning Representations 2015, 2015. ",
+        "bbox": [
+            174,
+            126,
+            823,
+            167
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "J. Chung, C. Gulcehre, K. Cho, and Y. Bengio. Empirical evaluation of gated recurrent neural networks on sequence modeling. CoRR, abs/1412.3555, 2014. URL https://arxiv.org/ abs/1412.3555. ",
+        "bbox": [
+            173,
+            178,
+            821,
+            220
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "A. Graves, G. Wayne, and I. Danihelka. Neural turing machines. CoRR, abs/1410.5401, 2014. URL https://arxiv.org/abs/1410.5401. ",
+        "bbox": [
+            168,
+            229,
+            825,
+            260
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "A. Graves, G. Wayne, M. Reynolds, T. Harley, I. Danihelka, A. Grabska-Barwiska, S. G. Colmenarejo, E. Grefenstette, T. Ramalho, J. Agapiou, A. P. Badia, K. M. Hermann, Y. Zwols, G. Ostrovski, A. Cain, H. King, C. Summerfield, P. Blunsom, K. Kavukcuoglu, and D. Hassabis. Hybrid computing using a neural network with dynamic external memory. Nature, 538: 471–476, 2016. ",
+        "bbox": [
+            173,
+            268,
+            825,
+            338
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "S. Gupta, J. Davidson, S. Levine, R. Sukthankar, and J. Malik. Cognitive mapping and planning for visual navigation. CoRR, abs/1702.03920, 2017. URL https://arxiv.org/abs/1702. 03920. ",
+        "bbox": [
+            173,
+            348,
+            821,
+            391
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "M. Hausknecht and P. Stone. Deep recurrent q-learning for partially observable mdps. CoRR, abs/1507.06527, 2015. URL https://arxiv.org/abs/1507.06527. ",
+        "bbox": [
+            171,
+            400,
+            821,
+            430
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Michał Kempka, Marek Wydmuch, Grzegorz Runc, Jakub Toczek, and Wojciech Jaskowski. ViZ- ´ Doom: A Doom-based AI research platform for visual reinforcement learning. In IEEE Conference on Computational Intelligence and Games, pp. 341–348, Santorini, Greece, Sep 2016. IEEE. ",
+        "bbox": [
+            174,
+            438,
+            823,
+            494
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "A. Khan, C. Zhang, N. Atanasov, K. Karydis, V. Kumar, and D. D. Lee. Memory augmented control networks. In Proceedings of the 6th International Conference on Learning Representations, 2018. ",
+        "bbox": [
+            169,
+            505,
+            823,
+            535
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "G. Lample and D. S. Chaplot. Playing fps games with deep reinforcement learning. CoRR, abs/1609.05521, 2016. URL https://arxiv.org/abs/1609.05521. ",
+        "bbox": [
+            174,
+            542,
+            823,
+            573
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sergey Levine, Chelsea Finn, Trevor Darrell, and Pieter Abbeel. End-to-end training of deep visuomotor policies. Journal of Machine Learning Research, 17(39):1–40, 2016. ",
+        "bbox": [
+            174,
+            582,
+            820,
+            611
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "V. Mnih, K. Kavukcuoglu, D. Silver, A. A. Rusu, J. Veness, M. G. Bellemare, A. Graves, M. Riedmiller, A. K. Fidjeland, G. Ostrovski, S. Petersen, C. Beattie, A. Sadik, I. Antonoglou, H. King, D. Kumaran, D. Wierstra, S. Legg, and D. Hassabis. Human-level control through deep reinforcement learning. Nature, 518:529–533, 2015. ",
+        "bbox": [
+            174,
+            619,
+            823,
+            678
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "V. Mnih, A. P. Badia, M. Mirza, A. Graves, T. Harley, T. P. Lillicrap, D. Silver, and K. Kavukcuoglu. Asynchronous methods for deep reinforcement learning. In Proceedings of the 33rd International Conference on Machine Learning (ICML), 2016. ",
+        "bbox": [
+            174,
+            686,
+            823,
+            729
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "J. Oh, V. Chockalingam, S. Singh, and H. Lee. Control of memory, active perception, and action in minecraft. In Proceedings of the 33rd International Conference on Machine Learning (ICML), 2016. ",
+        "bbox": [
+            171,
+            738,
+            823,
+            781
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "J. W. Rae, J. J. Hunt, T. Harley, I. Danihelka, A. Senior, G. Wayne, A. Graves, and T. Lillicrap. Scaling memory-augmented neural networks with sparse reads and writes. CoRR, abs/1610.09027, 2016. URL https://arxiv.org/abs/1610.09027. ",
+        "bbox": [
+            174,
+            790,
+            823,
+            834
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Stephane Ross, Geoffrey J Gordon, and Drew Bagnell. A reduction of imitation learning and struc-´ tured prediction to no-regret online learning. In AISTATS, volume 1, pp. 6, 2011. ",
+        "bbox": [
+            171,
+            843,
+            823,
+            872
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "John Schulman, Philipp Moritz, Sergey Levine, Michael Jordan, and Pieter Abbeel. Highdimensional continuous control using generalized advantage estimation. In Proceedings of the 4th International Conference on Learning Representations 2016, 2015. ",
+        "bbox": [
+            174,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "S. Sukhbaatar, A. Szlam, J. Weston, and R. Fergus. End-to-end memory networks. In Advances in Neural Information Processing Systems, pp. 2440–2448, 2015.   \nR. Sutton and A. Barto. Reinforcement Learning: an Introduction. MIT Press, 1998.   \nAviv Tamar, Yi Wu, Garrett Thomas, Sergey Levine, and Pieter Abbeel. Value iteration networks. In Advances in Neural Information Processing Systems, pp. 2146–2154, 2016.   \nR. J. Williams. Simple statistical gradient-following algorithms for connectionist reinforcement learning. Machine Learning, 8(3):229–256, 1992.   \nJ. Zhang, L. Tai, J. Boedecker, W. Burgard, and M. Liu. Neural slam: Learning to explore with external memory. CoRR, abs/1706.09520, 2017. URL https://arxiv.org/abs/1706. 09520. ",
+        "bbox": [
+            171,
+            101,
+            828,
+            284
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A CONTROLLER (EGO-)NEURAL MAP ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            508,
+            118
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Here we describe the modification to the Neural Map we utilized for the 3D maze tasks. We include an extra state $h$ that represents the hidden and cell state of an LSTM. The Neural Map equations are therefore: ",
+        "bbox": [
+            174,
+            143,
+            825,
+            185
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e3c3aacfc80291999f04a9e7e9b01fabc5ae7d00930ec2369e54acd628f00154.jpg",
+        "text": "$$\n\\begin{array} { r l } & { r _ { t } = r e a d ( M _ { t } ) , } \\\\ & { h _ { t } = L S T M ( s _ { t } , r _ { t } , c _ { t - 1 } , h _ { t - 1 } ) , } \\\\ & { c _ { t } = c o n t e x t ( M _ { t } , h _ { t } ) , } \\\\ & { w _ { t + 1 } ^ { ( x _ { t } , y _ { t } ) } = w r i t e ( s _ { t } , r _ { t } , c _ { t } , M _ { t } ^ { ( x _ { t } , y _ { t } ) } ) , } \\\\ & { M _ { t + 1 } = w p d a t e ( M _ { t } , w _ { t + 1 } ^ { ( x _ { t } , y _ { t } ) } ) , } \\\\ & { \\qquad o _ { t } = [ r _ { t } , c _ { t } , w _ { t + 1 } ^ { ( x _ { t } , y _ { t } ) } ] , } \\\\ & { \\pi _ { t } ( a | s ) = \\mathrm { S o f t m a x } ( f ( o _ { t } ) ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            369,
+            209,
+            625,
+            351
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "B 2D ENVIRONMENT DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            386,
+            444,
+            402
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "The state input for the 2D environment is a $5 \\times 1 5 \\times 3$ subsample of the complete maze so that the agent is able to see 15 pixel forward and 3 pixels on the side (center pixel $^ +$ one pixel on each side of the agent) which is depicted in Fig.1b. This view is obscured so the agent is prevented from seeing the identity of anything behind walls. The 5 binary channels in the observation represent object identities: channel 1 represents presence of walls, 2 represents the green indicator, 3 the blue indicator, 4 the red goal, and 5 the teal goal. The LSTM and MemNN networks were given auxiliary information such as the one-hot encoding of the current agent’s true position in the maze. Neural Map variants were not given position information in an auxiliary state unless specified by the $^ { 6 6 } +$ Pos” modifier in Table 1. Actions in the environment included moving forward and turning left/right 90 degrees. ",
+        "bbox": [
+            173,
+            428,
+            825,
+            568
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "For optimization, all architectures used the RMSprop optimization algorithm with gradients thresholded to norm 20 for LSTM, 100 for Neural Map variants, and no thresholding for memory networks. We used an auxiliary weighted entropy loss on the Synchronous Actor-Critic with weight 0.01. The learning rates for LSTM models was 0.0025, 0.005 for Neural Map variants, and 0.001 for memory networks. We obtained the hyperparameters during a limited hyperparameter sweep on a simpler version of the environment. We used A2C with number of time steps equal to 5. We trained for 10 million updates. ",
+        "bbox": [
+            173,
+            574,
+            825,
+            672
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "The mazes were generated using an algorithm based on Depth-First Search to form a fully-connected maze. Afterwards each wall was deleted with probability $p . p$ was sampled uniformly from between $[ 0 , 0 . 7 5 ]$ at maze generation time. Each episode, a random maze width was sampled uniformly from between [7, 15]. ",
+        "bbox": [
+            174,
+            679,
+            825,
+            736
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "(Ego-)Neural Map Agent Details: For the global read operation, we used a convolutional network with 3 layers of 8 channels and kernel size 3. The strides were set to 1 on the first layer, and 2 to the second and third layers. Padding was 1 on the first layer and 0 on other layers. The 3 convolutional layers were then followed by a fully-connected layer of dimension 256 and then another fullyconnected layer of size 32. All activations were relu except the 32 dimension layer, which was set to tanh. Positions were normalized so that the largest map size used all positions, while smaller mazes used a subset of the map. ",
+        "bbox": [
+            174,
+            742,
+            825,
+            840
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "LSTM Agent Details: The LSTM agent had a single 128-dimension LSTM layer on top of the state embedding. The auxiliary state information was first processed into a 256-dimension embedding. ",
+        "bbox": [
+            174,
+            845,
+            821,
+            875
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "MQN Agent Details: Each past history state was 512-dimensional (256-dimensional key $+ \\ 2 5 6$ - dimensional value feature). The input state was processed by a convolutional network with 32 channels, filter size 3, stride 1 and padding 1. ",
+        "bbox": [
+            174,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "C 3D ENVIRONMENT DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            444,
+            117
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The state input for all 3D environments was a $1 0 0 \\mathrm { x } 6 0 \\ \\mathrm { R G B + D }$ image. This was passed through a convolution network that was the same for all architectures. It first consists of a 2D convolution with 32 channels of filter size 8 with stride 4. This was then passed to another 2D convolution with 64 channels of filter size 4 and stride 2. Finally, the result was passed through a fully-connected layer with 512 features, which represented the current frame embedding. The frame embedding was then augmented with some auxiliary information about the map, which in the case of Neural Map, FRMQN and LSTM architectures was 1) a one-hot encoding of the current time step, 2) the current orientation (North/East/West/South), 3) the 2D velocity (change in x/y position in a top-down 2D quantized grid of possible environment positions), and 4) a one-hot encoding of the agent’s current quantized position. For Ego Neural Map, only 1, 2, 3 are used (i.e. it has no input of the agent’s current true position given by an oracle). The 512 frame encoding is concatenated with the auxiliary state information to form the complete state embedding. Actions in the maze consist of moving forward and turning left or right. ",
+        "bbox": [
+            174,
+            165,
+            825,
+            347
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "For optimization, all architectures used the Adam optimization algorithm with gradients thresholded to a norm of 40. We used an auxiliary weighted entropy loss on the Synchronous Actor-Critic with weight 0.01. The learning rate for LSTM models was 0.0005, while for other architectures it was set to 0.00075. The hyperparameters were obtained during a limited hyperparameter sweep on a simpler version of the Indicator Maze environment. We trained A2C with a number of steps equal to the episode length (no truncated backprop). We trained the agent for 3000 steps, where each step consisted of a gradient obtained from 100 full episodes. The effective batch size was thus upper bounded by $5 0 0 * 1 0 0 = 5 0 0 0 0$ . We used multithreading to calculate the batch gradients efficiently. Each update step took on the order of 1-3 minutes depending on the number of threads available, meaning each agent took on the order of a week to train. ",
+        "bbox": [
+            174,
+            353,
+            825,
+            492
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The mazes were generated using an algorithm based on Depth-First Search. Once the completed fully-connected maze was generated, random walls were deleted with a probability $p$ . This $p$ probability was chosen at maze creation time and was sampled uniformly from between 0.0 and 0.6. Mazes were between size 4 to size 8. The size of a maze represents how many “cells” there are in the maze, where a cell is an area which can potentially have walls on each side. A set of 50 test maze geometries were sampled to act as a test set, and were made sure to never be sampled during training. These 50 test mazes were generated with $p = 0$ , so they represent the most difficult mazes seen during training due to their higher degree of partial-observability. Goal locations were sampled uniformly at random when the mazes are generated. ",
+        "bbox": [
+            174,
+            498,
+            825,
+            625
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Indicator Maze Details: The indicator mazes used a curriculum approach to accelerate learning. In $50 \\%$ of the episodes sampled, only one goal existed in the environment and the indicator color matched the single goal color, making entering an incorrect goal impossible. This curriculum prevented the agents from learning to always enter a single color goal, which happened often when learning on only double goal environments. The test environments only used double goals. A reward of $+ 1$ was given to correct goal entry, and a negative reward of -1 was given to incorrect goal entry or episode terminating after a maximum number of time steps. These time steps depended on the maze size and were [150, 250, 300, 400, 500] for maze sizes [4, 5, 6, 7, 8]. At test time, the maximum time steps were extended to [300, 500, 600, 800, 1000]. ",
+        "bbox": [
+            173,
+            631,
+            825,
+            757
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Repeating Maze Details We included the same curriculum as the indicator maze. Rewards were the same as the indicator maze. After the first time the agent reaches a goal, the red torch is shown at each subsequent episode (regardless of what the correct indicator was). Maximum time steps were again [150, 250, 300, 400, 500] for maze sizes [4, 5, 6, 7, 8]. At test time, the maximum time steps were extended to [300, 500, 600, 800, 1000]. ",
+        "bbox": [
+            174,
+            763,
+            823,
+            833
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Minotaur Maze Details: For minotaur maze, a reward of $+ 0 . 5$ was given when reaching the randomly located goal and a reward of $+ 1 . 0$ was given when returning to the initial position. Episodes are terminated once the agent completes the return path, otherwise a negative reward of -1 is given if the agent exceeds the maximum number of steps. The maximum time steps were again [150, 250, 300, 400, 500] for maze sizes [4, 5, 6, 7, 8]. At test time, the maximum time steps were extended to [300, 500, 600, 800, 1000]. ",
+        "bbox": [
+            173,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/39a5d4834fa9c5f46a1294b0e741925a9eaeb36d96bb1f9d746d2b5375d15943.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\" colspan=\"2\">Agent Maze Size</td><td colspan=\"3\">Indicator</td><td colspan=\"3\">Repeating</td><td colspan=\"3\">Minotaur</td></tr><tr><td>4</td><td>5</td><td>6</td><td>4</td><td>5</td><td>6</td><td>4</td><td>5</td><td>6</td></tr><tr><td rowspan=\"2\">σ=0</td><td>Acc</td><td>88.4</td><td>84.4</td><td>79.3</td><td>1</td><td>1</td><td>1</td><td>97.3</td><td>89.0</td><td>62.0</td></tr><tr><td>Rew</td><td>-</td><td>1</td><td>1</td><td>9.47</td><td>9.91</td><td>5.91</td><td>1.46</td><td>1.34</td><td>0.93</td></tr><tr><td rowspan=\"2\">σ = 0.01</td><td>Acc</td><td>92.4</td><td>91.9</td><td>84.3</td><td>1</td><td>1</td><td>1</td><td>96.7</td><td>86.2</td><td>66.1</td></tr><tr><td>Rew</td><td>1</td><td>1</td><td>1</td><td>12.4</td><td>12.9</td><td>10.9</td><td>1.45</td><td>1.29</td><td>0.99</td></tr></table>",
+        "bbox": [
+            210,
+            101,
+            787,
+            189
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Table 3: Results on the three 3D Doom maze tasks for the fixed-frame Neural Map with Controller LSTM. We can see that adding small compounding error does not largely affect the ability of the Neural Map to learn memory tasks and even has a beneficial effect for some tasks. Hyperparameters and architectures used were the same as presented in the main results. ",
+        "bbox": [
+            173,
+            198,
+            826,
+            255
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "(Ego-)Neural Map Agent Details: For the global read operation, we used a convolutional network with 3 layers of 8 channels and kernel size 3. The strides were set to 1 on the first layer, and 2 to the second and third layers. Padding was 1 on the first layer and 0 on other layers. The 3 convolutional layers were then followed by a fully-connected layer of dimension 256 and then another fullyconnected layer of size 32. All activations were relu except the 32 dimension layer, which was set to tanh. The Neural Map itself was size $3 2 \\mathrm { x } 1 5 \\mathrm { x } 1 5$ . Positions were normalized so that the largest map size used all $1 5 \\mathrm { x } 1 5$ positions, while smaller mazes used a subset of the map. Additionally, during writing we split the 32 channels of the map into 8 channels per orientation (so if the agent is facing north, it writes only to the first 8 dimensions, if south, the next 8, and so on). ",
+        "bbox": [
+            174,
+            287,
+            825,
+            412
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "LSTM Agent Details: The LSTM agent had a single 256-dimension LSTM layer on top of the state embedding. ",
+        "bbox": [
+            173,
+            420,
+            821,
+            449
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "FRMQN Agent Details: Each past history state was 64-dimensional (32-dimensional key $\\pm \\ 3 2 .$ - dimensional value feature). Due to large matrix multiplies from storing the entire episode history, having larger feature sizes causes the attention operation to start becoming prohibitively expensive. ",
+        "bbox": [
+            174,
+            455,
+            825,
+            497
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "D NEURAL MAP WITH DRIFT NOISE MODEL ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            525,
+            560,
+            541
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We did an additional experiment on the Neural Map that featured drift noise to simulate the effects of the agent using a local visual odometry model that had small error in predicting each frame-by-frame transformation. This is meant to represent a more realistic scenario (e.g. robotic navigation) where perfect localization is not feasible but a relatively accurate estimate can be provided, demonstrating the robustness of the architecture to noise. For example, we could assume the Neural Map is run in parallel with a SLAM algorithm which provides an estimate of the agent’s current position. ",
+        "bbox": [
+            174,
+            560,
+            825,
+            645
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "To model this noise, we add a zero-mean gaussian random variable to the oracle position with a variance that depends on the current time-step. In more detail, the noise-corrupted positions $( \\hat { x } , \\hat { y } )$ in an $W \\times W$ size map provided to the Neural Map are: ",
+        "bbox": [
+            174,
+            651,
+            823,
+            694
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f81b412940d0378e45881e664941817353d545518add3177e6459967eb221fec.jpg",
+        "text": "$$\n\\begin{array} { r l } & { ( \\hat { x } , \\hat { y } ) = ( \\operatorname* { m a x } \\{ \\operatorname* { m i n } \\{ \\lfloor x + \\epsilon _ { x } \\rfloor , W - 1 \\} , 0 \\} , \\operatorname* { m a x } \\{ \\operatorname* { m i n } \\{ \\lfloor y + \\epsilon _ { y } \\rfloor , W - 1 \\} , 0 \\} ) , } \\\\ & { \\epsilon _ { x } , \\epsilon _ { y } \\sim \\mathcal { N } ( 0 , \\sigma ^ { 2 } t ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            238,
+            705,
+            759,
+            746
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "This simulates the effect of an odometry algorithm which has independent zero-mean gaussian error with equal variance. This error compounds over time causing the variance to grow with the time step. We evaluate the Neural Map with noise $\\sigma = 1 / 1 0 0$ on smaller versions of the 3D Doom maze tasks (maze sizes [4, 5, 6]) and compare it to the version with perfect odometry. We train for 1500 steps of 100 episodes each step. Results are shown in Table 3. We can see that adding a small amount of error at each time step does not largely affect the results of the memory and can even benefit it, with some noticeable improvements on Indicator and Repeating tasks. It’s possible that the noise acts as a regularizer to speed up learning. For the Minotaur task, since positional information is important because the agent must remember the entire path taken, adding noise causes slight decrease in reward in mazes of size 4 and 5, but otherwise performance is very similar. Therefore this means that the Neural Map is likely to work in the case where a localization oracle is not available and instead only error-prone odometry is. ",
+        "bbox": [
+            173,
+            757,
+            825,
+            924
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We also plot some example trajectories to compare the effect of noise. We can see that the noise causes some slight aliasing in the position, which increases as time passes. The positions are quantized to a $1 5 \\times 1 5$ grid. ",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/84779dc3af0ef8cc2512e5669cc80a83b8ac4eb6133c3594bfb79ca023c9ef39.jpg",
+        "image_caption": [
+            "Figure 3: Top: Noisy v.s. Groundtruth Position trajectory (quantized to a $1 5 \\times 1 5$ grid). As time progresses, the colors get lighter. Center: Neural Map cells addressed by the write operator under the noisy positions. Bottom: Neural Map cells that would have been written to under perfect position estimates. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            205,
+            159,
+            794,
+            574
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "E SAMPLES OF CONTEXT READ DISTRIBUTION ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            102,
+            583,
+            118
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "E.1 2D ENVIRONMENT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            132,
+            348,
+            147
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "To provide some insight into what the Neural Map learns, we show samples of the probability distribution given by the context read operation in a 2D maze example. We ran it on an example maze shown in Figure 4. In this figure, the top row of images are the agent observations, the center row are the fully observable mazes and the bottom row are the probability distributions over locations from the context operation, e.g. the $\\alpha _ { t } ^ { ( x , y ) }$ values defined by Eq. 2. In this maze, the indicator is blue, which indicates that the teal goal should be visited. We can see that once the agent sees the incorrect red goal, the context distribution faintly focuses on the map location where the agent had observed the indicator. On the other hand, when the agent first observes the correct teal goal, the location where the agent observed the indicator lights up brightly. This means that the agent is using its context retrieval operation to keep track of the landmark (the indicator) that it has previously seen. ",
+        "bbox": [
+            173,
+            159,
+            825,
+            314
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/f37c3d73963f794f333ce8aac652a9c3718f675657d2129200e4ba1807da78c9.jpg",
+        "image_caption": [
+            "Figure 4: A few sampled states from an example episode demonstrating how the agent learns to use the context addressing operation of the Neural Map. The top row of images is the observations made by the agent, the center is the fully observable mazes and the bottom image is the probability distributions over locations induced by the context operation at that step. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            323,
+            823,
+            707
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "E.2 3D ENVIRONMENT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            786,
+            348,
+            800
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "We draw some examples of the context addressing probability distribution in the 3D Doom environment in Figure 5 (allocentric) and Figure 6 (egocentric). We can see that the Neural Map learns to use its context addressing operator to retrieve the indicator torch identity, until it sees the correct corresponding tower. Once it sees the correct tower there is a shift in how the agent uses the map and the probability map seems to invert, addressing the parts of the map that were unexplored. This effect is consistent in both allocentric and egocentric variants. This might be because the Neural Map variant used on Doom had an internal LSTM which could enable it to remember the indicator identity for the short amount of time it took to walk up to the goal. ",
+        "bbox": [
+            174,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Indicator Prediction To determine whether the Neural Map was accurately storing the indicator identity within its memory, we train a logistic regression model on memory vectors sampled over 75 episodes. We then attempt to predict the indicator on a held-out set of 25 episodes by taking the max prediction over all positions of the memory at the end of the episode. We can see that a simple logistic regression is capable of recovering the indicator in $100 \\%$ of the episodes, showing that the indicator identity can be easily extracted from, e.g., the context operator. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            188
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "table",
+        "img_path": "images/bc25c3d69e0cb03e0f3d693dbec51f4c9957f084a1d42ec35c802feb63af7690.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Agent</td><td>Indicator Accuracy</td></tr><tr><td>Controller NMap</td><td>100%</td></tr><tr><td>Controller Ego-NMap</td><td>100%</td></tr></table>",
+        "bbox": [
+            341,
+            200,
+            653,
+            246
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "Table 4: Figure showing accuracy of a logistic model to determine indicator identity from the stored Neural Map features. ",
+        "bbox": [
+            171,
+            255,
+            823,
+            284
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/c8737215b5e2340ede5c54756af4aab06bafee71e94f71c7ba6af7ecd67225c8.jpg",
+        "image_caption": [
+            "Figure 5: Three example episodes of the (allocentric) context addressing operator on Doom mazes. The top images of each row are the RGB inputs the agent sees, the center images are a top-down representation of the maze, and the bottom images are the $\\alpha _ { t } ^ { ( x , y ) }$ of the context operation. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            80,
+            908,
+            954
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "image",
+        "img_path": "images/757865053b472780e55b9e68d9a4bc5550b3e2745354499fdbcb397ce5c372ae.jpg",
+        "image_caption": [
+            "Figure 6: Three example episodes of the (egocentric) context addressing operator on Doom mazes. The top images of each row are the RGB inputs the agent sees, the center images are a top-down representation of the maze, and the bottom images are the (egocentric) $\\alpha _ { t } ^ { ( x , y ) }$ of the context operation. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            69,
+            908,
+            954
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "text",
+        "text": "F BACKTRACKING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            344,
+            118
+        ],
+        "page_idx": 19
+    },
+    {
+        "type": "text",
+        "text": "We also explored whether the allocentric and egocentric Neural Maps were capable of using their memories in order to do backtracking, i.e. re-visiting unexplored areas of the maze. To measure this, we developed a variant of the Indicator Maze where the goal states were removed. We want to measure how much of the maze is explored by the agent under this setting where there are no terminal states. To measure how much of the maze was explored, we quantized the 50 test mazes into 11 discrete positions and counted how many of the quantized positions the agent visited. We report results below in Table 5 ",
+        "bbox": [
+            173,
+            132,
+            825,
+            231
+        ],
+        "page_idx": 19
+    },
+    {
+        "type": "table",
+        "img_path": "images/0c9d7511cf29fc77449aa12eb6eb70ae8f992b70cdf157eda3569175fdea76a0.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Agent</td><td>Visitation Score</td></tr><tr><td>Controller NMap</td><td>71.6%</td></tr><tr><td>Controller Ego-NMap LSTM</td><td>77.6% 68.5%</td></tr></table>",
+        "bbox": [
+            354,
+            243,
+            638,
+            303
+        ],
+        "page_idx": 19
+    },
+    {
+        "type": "text",
+        "text": "Table 5: Visitation scores of the Neural Map models which measure how much of a maze is explored within a set time limit. We can see that the egocentric neural map explores more of the mazes than the allocentric model, exploring on average $7 7 . 6 \\%$ of the test mazes. The allocentric neural map explores $7 1 . 6 \\%$ of the test mazes. The LSTM is reported to provide a point of comparison. ",
+        "bbox": [
+            173,
+            313,
+            826,
+            369
+        ],
+        "page_idx": 19
+    }
+]

parse/train/BkgWHnR5tm/BkgWHnR5tm.md

@@ -0,0 +1,462 @@
+# NEURAL GRAPH EVOLUTION: TOWARDS EFFICIENT AUTOMATIC ROBOT DESIGN
+
+Tingwu Wang1,2∗, Yuhao Zhou1,2∗, Sanja Fidler1,2,3 & Jimmy $\mathbf { B a } ^ { 1 , 2 }$
+
+1 Department of Computer Science, University of Toronto   
+2 Vector Institute   
+3 NVIDIA   
+{tingwuwang,henryzhou,fidler,jba}@cs.toronto.e
+
+# ABSTRACT
+
+Despite the recent successes in robotic locomotion control, the design of robots, i.e., the design of their body structure, still heavily relies on human engineering. Automatic robot design has been a long studied subject, however, progress has been slow due to large combinatorial search space and the difficulty to efficiently evaluate the candidate structures. Note that one needs to both, search over many possible body structures, and choose among them based on how the robot with that structure performs in an environment. The latter means training an optimal controller given a candidate structure, which in itself is costly to obtain. In this paper, we propose Neural Graph Evolution (NGE), which performs evolutionary search in graph space, by iteratively evolving graph structures using simple mutation primitives. Key to our approach is to parameterize the control policies with graph neural networks, which allows us to transfer skills from previously evaluated designs during the graph search. This significantly reduces evaluation cost of new candidates and makes the search process orders of magnitude more efficient than that of past work. In addition, NGE applies Graph Mutation with Uncertainty (GM-UC) by incorporating model uncertainty, which reduces the search space by balancing exploration and exploitation. We show that NGE significantly outperforms previous methods in terms of convergence rate and final performance. As shown in experiments, NGE is the first algorithm that can automatically discover kinematically preferred robotic graph structures, such as a fish with two symmetric flat side-fins and a tail, or a cheetah with athletic front and back legs. NGE is extremely efficient, it finds plausible robotic structures within a day on a single 64 CPU-core Amazon EC2 machine.
+
+# 1 INTRODUCTION
+
+The goal of robot design is to find an optimal body structure and its means of locomotion to best achieve a given objective in an environment. Robot design often relies on careful human-engineering and expert knowledge. The field of automatic robot design aims to search for these structures automatically. This has been a long-studied subject, however, with limited success. There are two major challenges: 1) the search space of all possible designs is large and combinatorial, and 2) the evaluation of each design requires learning or testing a separate optimal controller that is often expensive to obtain.
+
+In (Sims, 1994), the authors evolved creatures with 3D-blocks. Recently, soft robots have been studied in (Joachimczak et al., 2014), which were evolved by adding small cells connected to the old ones. In (Cheney et al., 2014), the 3D voxels were treated as the minimum element of the robot. Most evolutionary robots (Duff et al., 2001; Neri, 2010) require heavy engineering of the initial structures, evolving rules and careful human-guidance. Due to the combinatorial nature of the problem, evolutionary, genetic or random structure search have been the de facto algorithms of automatic robot design in the pioneering works (Sims, 1994; Steels, 1993; Mitchell & Forrest, 1994; Langton, 1997; Lee, 1998; Taylor, 2017; Calandra et al., 2016). In terms of the underlying algorithm, most of these works have a similar population-based optimization loop to the one used in (Sims, 1994). None of these algorithms are able to evolve kinematically reasonable structures, as a result of large search space and the inefficient evaluation of candidates.
+
+Similar in vein to automatic robot design, automatic neural architecture search also faces a large combinatorial search space and difficulty in evaluation. There have been several approaches to tackle these problems. Bayesian optimization approaches (Snoek et al., 2012) primarily focus on fine-tuning the number of hidden units and layers from a predefined set. Reinforcement learning (Zoph & Le, 2016) and genetic algorithms (Liu et al., 2017) are studied to evolve recurrent neural networks (RNNs) and convolutional neural networks (CNNs) from scratch in order to maximize the validation accuracy. These approaches are computationally expensive because a large number of candidate networks have to be trained from grounds up. (Pham et al., 2018) and (Stanley & Miikkulainen, 2002) propose weight sharing among all possible candidates in the search space to effectively amortize the inner loop training time and thus speed up the architecture search. A typical neural architecture search on ImageNet (Krizhevsky et al., 2012) takes 1.5 days using 200 GPUs (Liu et al., 2017).
+
+In this paper, we propose an efficient search method for automatic robot design, Neural Graph Evolution (NGE), that co-evolves both, the robot design and the control policy. Unlike the recent reinforcement learning work, where the control policies are learnt on specific robots carefully designed by human experts (Mnih et al., 2013; Bansal et al., 2017; Heess et al., 2017), NGE aims to adapt the robot design along with policy learning to maximize the agent’s performance. NGE formulates automatic robot design as a graph search problem. It uses a graph as the main backbone of rich design representation and graph neural networks (GNN) as the controller. This is key in order to achieve efficiency of candidate structure evaluation during evolutionary graph search. Similar to previous algorithms like (Sims, 1994), NGE iteratively evolves new graphs and removes graphs based on the performance guided by the learnt GNN controller. The specific contributions of this paper are as follows:
+
+• We formulate the automatic robot design as a graph search problem.   
+• We utilize graph neural networks (GNNs) to share the weights between the controllers, which greatly reduces the computation time needed to evaluate each new robot design.   
+• To balance exploration and exploitation during the search, we developed a mutation scheme that incorporates model uncertainty of the graphs.
+
+We show that NGE automatically discovers robot designs that are comparable to the ones designed by human experts in MuJoCo (Todorov et al., 2012), while random graph search or naive evolutionary structure search (Sims, 1994) fail to discover meaningful results on these tasks.
+
+# 2 BACKGROUND
+
+# 2.1 REINFORCEMENT LEARNING
+
+In reinforcement learning (RL), the problem is usually formulated as a Markov Decision Process (MDP). The infinite-horizon discounted MDP consists of a tuple of $( S , { \mathcal { A } } , \gamma , P , R )$ , respectively the state space, action space, discount factor, transition function, and reward function. The objective of the agent is to maximize the total expected reward $\begin{array} { r } { J ( \theta ) = \mathbb { E } _ { \pi } \left[ \sum _ { t = 0 } ^ { \infty } \gamma ^ { t } r ( s _ { t } , a _ { t } ) \right] } \end{array}$ , where the state transition follows the distribution $\bar { P ( } s _ { t + 1 } | s _ { t } , a _ { t } )$ . Here, $s _ { t }$ and $a _ { t }$ denotes the state and action at time step $t$ , and $r ( s _ { t } , a _ { t } )$ is the reward function. In this paper, to evaluate each robot structure, we use PPO to train RL agents (Schulman et al., 2017; Heess et al., 2017). PPO uses a neural network parameterized as $\pi _ { \boldsymbol { \theta } } ( a _ { t } | \boldsymbol { s } _ { t } )$ to represent the policy, and adds a penalty for the KL-divergence between the new and old policy to prevent over-optimistic updates. PPO optimizes the following surrogate objective function instead:
+
+$$
+J _ { \mathrm { P P O } } ( \theta ) = \mathbb { E } _ { \pi _ { \theta } } \left[ \sum _ { t = 0 } ^ { \infty } A ^ { t } ( s _ { t } , a _ { t } ) r ^ { t } ( s _ { t } , a _ { t } ) \right] - \beta \operatorname { K L } \left[ \pi _ { \theta } ( : | s _ { t } ) | \pi _ { \theta _ { o l d } } ( : | s _ { t } ) \right] .
+$$
+
+We denote the estimate of the expected total reward given the current state-action pair, the value and the advantage functions, as $Q ^ { t } ( s _ { t } , a _ { t } )$ , $V ( s _ { t } )$ and $A ^ { t } ( s _ { t } , a _ { t } )$ respectively. PPO solves the problem by iteratively generating samples and optimizing $J _ { \mathrm { P P O } }$ (Schulman et al., 2017).
+
+![](images/2e9d715889591cf252e6b0c04ff94ec1f8941b9176793190fb0966ecbd604957.jpg)  
+Figure 1: In NGE, several mutation operations are allowed. By using Policy Sharing, child species reuse weights from parents, even if the graphs are different. The same color indicates shared and reused weights. For better visualization, we only plot the sharing of propagation model (yellow curves).
+
+# 2.2 GRAPH NEURAL NETWORK
+
+Graph Neural Networks (GNNs) are suitable for processing data in the form of graph (Bruna et al., 2014; Defferrard et al., 2016; Li et al., 2015; Kipf & Welling, 2017; Duvenaud et al., 2015; Henaff et al., 2015). Recently, the use of GNNs in locomotion control has greatly increased the transferability of controllers (Wang et al., 2018). A GNN operates on a graph whose nodes and edges are denoted respectively as $u \in V$ and $e \in E$ . We consider the following GNN, where at timestep $t$ each node in GNN receives an input feature and is supposed to produce an output at a node level.
+
+Input Model: The input feature for node $u$ is denoted as $x _ { u } ^ { t }$ . $x _ { u } ^ { t }$ is a vector of size $d$ , where $d$ is the size of features. In most cases, $x _ { u } ^ { t }$ is produced by the output of an embedding function used to encode information about $u$ into $d$ -dimensional space.
+
+Propagation Model: Within each timestep $t$ , the GNN performs $\tau$ internal propagations, so that each node has global (neighbourhood) information. In each propagation, every node communicates with its neighbours, and updates its hidden state by absorbing the input feature and message. We denote the hidden state at the internal propagation step $\tau$ $( \tau \leq \tau )$ as $h _ { u } ^ { t , \tau }$ . Note that $h _ { u } ^ { t , 0 }$ is usually initialized as $h _ { u } ^ { t - 1 , T }$ , i.e., the final hidden state in the previous time step. $\cdot _ { h ^ { 0 , 0 } }$ is usually initialized to zeros. The message that $u$ sends to its neighbors is computed as
+
+$$
+m _ { u } ^ { t , \tau } = M ( h _ { u } ^ { t , \tau - 1 } ) ,
+$$
+
+where $M$ is the message function. To compute the updated $h _ { u } ^ { t , \tau }$ , we use the following equations:
+
+$$
+r _ { u } ^ { t , \tau } = R ( \{ m _ { v } ^ { t , \tau } | \forall v \in \mathcal { N } _ { G } ( u ) \} ) , h _ { u } ^ { t , \tau } = U ( h _ { u } ^ { t , \tau - 1 } , ( r _ { u } ^ { t , \tau } ; x _ { u } ^ { t } ) )
+$$
+
+where $R$ and $U$ are the message aggregation function and the update function respectively, and $\mathcal { N } _ { G } ( u )$ denotes the neighbors of $u$ .
+
+Output Model: Output function $F$ takes input the node’s hidden states after the last internal propagation. The node-level output for node $u$ is therefore defined as $\mu _ { u } ^ { t } = F ( h _ { u } ^ { t , T } )$ .
+
+Functions $M , R , U , F$ in GNNs can be trainable neural networks or linear functions. For details of GNN controllers, we refer readers to (Wang et al., 2018).
+
+# 3 NEURAL GRAPH EVOLUTION
+
+In robotics design, every component, including the robot arms, finger and foot, can be regarded as a node. The connections between the components can be represented as edges. In locomotion control, the robotic simulators like MuJoCo (Todorov et al., 2012) use an XML file to record the graph of the robot. As we can see, robot design is naturally represented by a graph. To better illustrate Neural Graph Evolution (NGE), we first introduce the terminology and summarize the algorithm.
+
+Graph and Species. We use an undirected graph $\mathcal { G } = ( V , E , A )$ to represent each robotic design. $V$ and $E$ are the collection of physical body nodes and edges in the graph, respectively. The mapping
+
+# Algorithm 1 Neural Graph Evolution
+
+<table><tr><td>1: Initialize generation P°←{(0,G)}1</td><td></td></tr><tr><td>2:while Evolving jth generation do</td><td>Evolution outer loop</td></tr><tr><td>3: for ith species (0²,G) ∈ Pj do</td><td> Species fitness inner loop</td></tr><tr><td>4: 0j+1←Update(0）</td><td>Train policy network</td></tr><tr><td>5: S←s（0+1,G）</td><td>Evaluate fitness</td></tr><tr><td>6: end for</td><td></td></tr><tr><td>7: pj+1←Pj\{(0k,Sk) ∈Pj,∀k ∈ argminx({Si})}.</td><td>Remove worst K species</td></tr><tr><td>P ←{(0h,9h =M(Gh,p)), whereGh,p ~ Uniform(Pj+1)}h=1 8:</td><td>Mutate from survivors</td></tr><tr><td>9: pj+1 √ pj+1 U{(0k,9k) ∈P, ∀k ∈ argmaxx({ξp(Gh)})}. 10: end while</td><td>Pruning</td></tr></table>
+
+$A : V  \Lambda$ maps the node $u \in V$ to its structural attributes $A ( u ) \in \Lambda$ , where $\Lambda$ is the attributes space. For example, the fish in Figure 1 consists of a set of ellipsoid nodes, and vector $A ( u )$ describes the configurations of each ellipsoid. The controller is a policy network parameterized by weights $\theta$ The tuple formed by the graph and the policy is defined as a species, denoted as $\Omega = ( \mathcal { G } , \theta )$ .
+
+Generation and Policy Sharing. In the $j$ -th iteration, NGE evaluates a pool of species called a generation, denoted as $P ^ { j } = \{ ( \mathcal { G } _ { i } ^ { j } , \theta _ { i } ^ { j } ) , \forall i = 1 , 2 , . . . , \mathcal { N } \}$ , where $\mathcal { N }$ is the size of the generation. In NGE, the search space includes not only the graph space, but also the weight or parameter space of the policy network. For better efficiency of NGE, we design a process called Policy Sharing (PS), where weights are reused from parent to child species. The details of PS is described in Section 3.4.
+
+Our model can be summarized as follows. NGE performs population-based optimization by iterating among mutation, evaluation and selection. The objective and performance metric of NGE are introduced in Section 3.1. In NGE, we randomly initialize the generation with $\mathcal { N }$ species. For each generation, NGE trains each species and evaluates their fitness separately, the policy of which is described in Section 3.2. During the selection, we eliminate $\kappa$ species with the worst fitness. To mutate $\kappa$ new species from surviving species, we develop a novel mutation scheme called Graph Mutation with Uncertainty (GM-UC), described in Section 3.3, and efficiently inherit policies from the parent species by Policy Sharing, described in Section 3.4. Our method is outlined in Algorithm 1.
+
+# 3.1 AMORTIZED FITNESS AND OBJECTIVE FUNCTION
+
+Fitness represents the performance of a given $\mathcal { G }$ using the optimal controller parameterized with $\theta ^ { * } ( { \mathcal { G } } )$ . However, $\overleftarrow { \theta ^ { * } } ( \mathcal G )$ is impractical or impossible to obtain for the following reasons. First, each design is computationally expensive to evaluate. To evaluate one graph, the controller needs to be trained and tested. Model-free (MF) algorithms could take more than one million in-game timesteps to train a simple 6-degree-of-freedom cheetah (Schulman et al., 2017), while model-based (MB) controllers usually require much more execution time, without the guarantee of having higher performance than MF controllers (Tassa et al., 2012; Nagabandi et al., 2017; Drews et al., 2017; Chua et al., 2018). Second, the search in robotic graph space can easily get stuck in local-optima. In robotic design, local-optima are difficult to detect as it is hard to tell whether the controller has converged or has reached a temporary optimization plateau. Learning the controllers is a computation bottleneck in optimization.
+
+In population-based robot graph search, spending more computation resources on evaluating each species means that fewer different species can be explored. In our work, we enable transferablity between different topologies of NGE (described in Section 3.2 and 3.4). This allows us to introduce amortized fitness (AF) as the objective function across generations for NGE. AF is defined in the following equation as,
+
+$$
+\xi ( \mathcal { G } , \boldsymbol { \theta } ) = \mathbb { E } _ { \pi _ { \boldsymbol { \theta } } , \mathcal { G } } \left[ \sum _ { t = 0 } ^ { \infty } \gamma ^ { t } r ( s _ { t } , a _ { t } ) \right] .
+$$
+
+In NGE, the mutated species continues the optimization by initializing the parameters with the parameters inherited from its parent species. In past work (Sims, 1994), species in one generation are trained separately for a fixed number of updates, which is biased and potentially undertrained or
+
+overtrained. In next generations, new species have to discard old controllers if the graph topology is different, which might waste valuable computation resources.
+
+# 3.2 POLICY REPRESENTATION
+
+Given a species with graph $\mathcal { G }$ , we train the parameters $\theta$ of policy network $\pi _ { \theta } ( a ^ { t } | s ^ { t } )$ using reinforcement learning. Similar to (Wang et al., 2018), we use a GNN as the policy network of the controller. A graphical representation of our model is shown in Figure 1. We follow notation in Section 2.2.
+
+For the input model, we parse the input state vector $s ^ { t }$ obtained from the environment into a graph, where each node $u \in V$ fetches the corresponding observation $o ( u , t )$ from $s ^ { t }$ , and extracts the feature $x _ { u } ^ { O , t }$ with an embedding function $\Phi$ . We also encode the attribute information $A ( u )$ into $x _ { u } ^ { A }$ with an embedding function denoted as $\zeta$ . The input feature $x _ { u } ^ { t }$ is thus calculated as:
+
+$$
+\begin{array} { r } { x _ { u } ^ { O , t } = \Phi ( o ( u , t ) ) , ~ x _ { u } ^ { A } = \zeta ( A ( u ) ) , } \\ { x _ { u } ^ { t } = [ x _ { u } ^ { O , t } ; x _ { u } ^ { A } ] , ~ } \end{array}
+$$
+
+where $[ . ]$ denotes concatenation. We use $\theta _ { \Phi } , \theta _ { \zeta }$ to denote the weights of embedding functions.
+
+The propagation model is described in Section 2.2. We recap the propagation model here briefly: Initial hidden state for node $u$ is denoted as $h _ { u } ^ { t , 0 }$ , which are initialized from hidden states from the last timestep $h _ { u } ^ { t - 1 , T }$ or simply zeros. $\tau$ internal propagation steps are performed for each timestep, during each step (denoted as $\tau \leq \tau \}$ ) of which, every node sends messages to its neighboring nodes, and aggregates the received messages. $h _ { u } ^ { t , \tau + 1 }$ is calculated by an update function that takes in $h _ { u } ^ { t , \tau }$ , node input feature $x _ { u } ^ { t }$ and aggregated message $m _ { u } ^ { t , \tau }$ . We use summation as the aggregation function and a GRU (Chung et al., 2014) as the update function.
+
+For the output model, we define the collection of controller nodes as $\mathcal { F }$ , and define Gaussian distributions on each node’s controller as follows:
+
+$$
+\begin{array} { r } { \forall u \in \mathcal { F } , ~ \mu _ { u } ^ { t } = F _ { \mu } ( h _ { u } ^ { t , T } ) , } \\ { \sigma _ { u } ^ { t } = F _ { \sigma } ( h _ { u } ^ { t , T } ) , } \end{array}
+$$
+
+where $\mu _ { u }$ and $\sigma _ { u }$ are the mean and the standard deviation of the action distribution. The weights of output function are denoted as $\theta _ { F }$ . By combining all the actions produced by each node controller, we have the policy distribution of the agent:
+
+$$
+\pi ( a ^ { t } | s ^ { t } ) = \prod _ { u \in \mathcal { F } } \pi _ { u } ( a _ { u } ^ { t } | s ^ { t } ) = \prod _ { u \in \mathcal { F } } \frac { 1 } { \sqrt { 2 \pi ( \sigma _ { u } ^ { t } ) ^ { 2 } } } \mathrm { e x p } \left( \frac { ( a _ { u } ^ { t } - \mu _ { u } ^ { t } ) ^ { 2 } } { 2 ( \sigma _ { u } ^ { t } ) ^ { 2 } } \right)
+$$
+
+We optimize $\pi ( \boldsymbol { a } ^ { t } | \boldsymbol { s } ^ { t } )$ with PPO, the details of which are provided in Appendix A.
+
+# 3.3 GRAPH MUTATION WITH UNCERTAINTY
+
+Between generations, the graphs evolve from parents to children. We allow the following basic operations as the mutation primitives on the parent’s graph $\mathcal { G }$ :
+
+$\mathcal { M } _ { 1 }$ , Add-Node: In the $\mathcal { M } _ { 1 }$ (Add-Node) operation, the growing of a new body part is done by sampling a node $v \in V$ from the parent, and append a new node $u$ to it. We randomly initialize $u$ ’s attributes from an uniform distribution in the attribute space.
+
+$\mathcal { M } _ { 2 }$ , Add-Graph: The $\mathcal { M } _ { 2 }$ (Add-Graph) operation allows for faster evolution by reusing the subtrees in the graph with good functionality. We sample a sub-graph or leaf node $\bar { \mathcal { G } } ^ { \prime } = ( \bar { V ^ { \prime } } , E ^ { \prime } , A ^ { \prime } )$ from the current graph, and a placement node $u \in V ( { \mathcal { G } } )$ to which to append $\mathcal { G } ^ { \prime }$ . We randomly mirror the attributes of the root node in $\mathcal { G } ^ { \prime }$ to incorporate a symmetry prior.
+
+$\mathcal { M } _ { 3 }$ , Del-Graph: The process of removing body parts is defined as $\mathcal { M } _ { 3 }$ (Del-Graph) operation. In this operation, a sub-graph $\mathcal { G } ^ { \prime }$ from $\mathcal { G }$ is sampled and removed from $\mathcal { G }$ .
+
+$\mathcal { M } _ { 4 }$ , Pert-Graph: In the $\mathcal { M } _ { 4 }$ (Pert-Graph) operation, we randomly sample a sub-graph $\mathcal { G } ^ { \prime }$ and recursively perturb the parameter of each node $u \in V ( \mathcal { G } ^ { \prime } )$ by adding Gaussian noise to $A ( u )$ .
+
+We visualize a pair of example fish in Figure 1. The fish in the top-right is mutated from the fish in the top-left by applying $\mathcal { M } _ { 1 }$ . The new node (2) is colored magenta in the figure. To mutate each new candidate graph, we sample the operation $\mathcal { M }$ and apply $\mathcal { M }$ on $\mathcal { G }$ as
+
+$$
+\mathcal { G } ^ { \prime } = \mathcal { M } ( \mathcal { G } ) , \mathrm { w h e r e } \mathcal { M } \in \{ \mathcal { M } _ { l } , l = 1 , 2 , 3 , 4 \} , \ : \mathrm { P } ( \mathcal { M } = \mathcal { M } _ { l } ) = p _ { m } ^ { l } .
+$$
+
+$p _ { m } ^ { l }$ is the probability of sampling each operation with $\begin{array} { r } { \sum _ { l } p _ { m } ^ { l } = 1 } \end{array}$
+
+To facilitate evolution, we want to avoid wasting computation resources on species with low expected fitness, while encouraging NGE to test species with high uncertainty. We again employ a GNN to predict the fitness of the graph $\mathcal { G }$ , denoted as $\xi _ { P } ( \mathcal G )$ . The weights of this GNN are denoted as $\psi$ . In particular, we predict the AF score with a similar propagation model as our policy network, but the observation feature is only $x _ { u } ^ { A }$ , i.e., the embedding of the attributes. The output model is a graph-level output (as opposed to node-level used in our policy), regressing to the score $\xi$ . After each generation, we train the regression model using the L2 loss.
+
+However, pruning the species greedily may easily overfit the model to the existing species since there is no modeling of uncertainty. We thus propose Graph Mutation with Uncertainty (GM-UC) based on Thompson Sampling to balance between exploration and exploitation. We denote the dataset of past species and their AF score as $\mathcal { D }$ . GM-UC selects the best graph candidates by considering the posterior distribution of the surrogate $P \left( \psi | \mathcal { D } \right)$ :
+
+$$
+\mathcal { G } ^ { * } = \arg \operatorname* { m a x } _ { \mathcal { G } } \mathbb { E } _ { P \left( \psi \left| \mathcal { D } \right. \right]} \left[ \xi _ { P } \left( \mathcal { G } \right| \psi \right)  .
+$$
+
+Instead of sampling the full model with $\widetilde { \psi } \sim P \left( \psi | \mathcal { D } \right)$ , we follow Gal & Ghahramani (2016) and perform dropout during inference, which can be viewed as an approximate sampling from the model posterior. At the end of each generation, we randomly mutate ${ \mathcal { C } } \geq { \mathcal { N } }$ new species from surviving species. We then sample a single dropout mask for the surrogate model and only keep $\mathcal { N }$ species with highest $\xi _ { P }$ . The details of GM-UC are given in Appendix F.
+
+# 3.4 RAPID ADAPTATION USING POLICY SHARING
+
+To leverage the transferability of GNNs across different graphs, we propose Policy Sharing (PS) to reuse old weights from parent species. The weights of a species in NGE are as follows:
+
+$$
+\theta _ { G } = ( \theta _ { \Phi } , \theta _ { \zeta } , \theta _ { M } , \theta _ { U } , \theta _ { F } ) ,
+$$
+
+where $\theta _ { \Phi } , \theta _ { \zeta } , \theta _ { M } , \theta _ { U } , \theta _ { F }$ are the weights for the models we defined earlier in Section 3.2 and 2.2. Since our policy network is based on GNNs, as we can see from Figure 1, model weights of different graphs share the same cardinality (shape). A different graph will only alter the paths of message propagation. With PS, new species are provided with a strong weight initialization, and the evolution will less likely be dominated by species that are more ancient in the genealogy tree.
+
+Previous approaches including naive evolutionary structure search (ESS-Sims) (Sims, 1994) or random graph search (RGS) utilize human-engineered one-layer neural network or a fully connected network, which cannot reuse controllers once the graph structure is changed, as the parameter space for $\theta$ might be different. And even when the parameters happen to be of the same shape, transfer learning with unstructured policy controllers is still hardly successful (Rajeswaran et al., 2017). We denote the old species in generation $j$ , and its mutated species with different topologies as $( \theta _ { B } ^ { j } , \mathcal { G } )$ , $( \theta _ { B } ^ { j + 1 } , \mathcal { G } ^ { \prime } )$ in baseline algorithm ESS-Sims and RGS, and $( \theta _ { G } ^ { j } , \mathcal { G } )$ , $( \theta _ { G } ^ { j + 1 } , \mathcal { G } ^ { \prime } )$ for NGE. We also denote the network initialization scheme for fully-connected networks as $\boldsymbol { B }$ . We show the parameter reuse between generations in Table 1.
+
+<table><tr><td rowspan=1 colspan=1>Algorithm</td><td rowspan=1 colspan=1>Mutation</td><td rowspan=1 colspan=1>Parameter Space</td><td rowspan=1 colspan=1>Policy Initialization</td></tr><tr><td rowspan=1 colspan=1>ESS-Sims, RGSNGE</td><td rowspan=1 colspan=1>g→g&#x27;g→g&#x27;</td><td rowspan=1 colspan=1>{0B(9)}n {0B(S&#x27;)}=0{0G(9)}={0G(S&#x27;)}</td><td rowspan=1 colspan=1>B(&#x27;),， 0 not reused01</td></tr></table>
+
+Table 1: Parameter reuse between species and its mutated children if the topologies are different.
+
+![](images/38bc5764a077404c9112cc83437462191878af34cc741069550675015886ee62.jpg)  
+Figure 2: The performance of the graph search for RGS, ES and NGE. The figures on are the example creatures obtained from each of the method. The graph structure next to the figure are the corresponding graph structure. We included the original species for reference.
+
+# 4 EXPERIMENTS
+
+In this section, we demonstrate the effectiveness of NGE on various evolution tasks. In particular, we evaluate both, the most challenging problem of searching for the optimal body structure from scratch in Section 4.1, and also show a simpler yet useful problem where we aim to optimize humanengineered species in Section 4.2 using NGE. We also provide an ablation study on GM-UC in Section 4.3, and an ablation study on computational cost or generation size in Section 4.4.
+
+Our experiments are simulated with MuJoCo. We design the following environments to test the algorithms. Fish Env: In the fish environment, graph consists of ellipsoids. The reward is the swimming-speed along the $y$ -direction. We denote the reference human-engineered graph (Tassa et al., 2018) as $\mathcal { G } _ { F }$ . Walker Env: We also define a 2D environment walker constructed by cylinders, where the goal is to move along $x$ -direction as fast as possible. We denote the reference humanengineered walker as $\mathcal { G } _ { W }$ and cheetah as $\mathcal { G } _ { C }$ (Tassa et al., 2018). To validate the effectiveness of NGE, baselines including previous approaches are compared. We do a grid search on the hyper-parameters as summarized in Appendix E, and show the averaged curve of each method. The baselines are introduced as follows:
+
+ESS-Sims: This method was proposed in (Sims, 1994), and applied in (Cheney et al., 2014; Taylor, 2017), which has been the most classical and successful algorithm in automatic robotic design. In the original paper, the author uses evolutionary strategy to train a human-engineered one layer neural network, and randomly perturbs the graph after each generation. With the recent progress of robotics and reinforcement learning, we replace the network with a 3-layer Multilayer perceptron and train it with PPO instead of evolutionary strategy.
+
+ESS-Sims-AF: In the original ESS-Sims, amortized fitness is not used. Although amortized fitness could not be fully applied, it could be applied among species with the same topology. We name this variant as ESS-Sims-AF.
+
+ESS-GM-UC: ESS-GM-UC is a variant of ESS-Sims-AF, which combines GM-UC. The goal is to explore how GM-UC affects the performance without the use of a structured model like GNN.
+
+ESS-BodyShare: We also want to answer the question of whether GNN is indeed needed. We use both an unstructured models like MLP, as well as a structured model by removing the message propagation model.
+
+RGS: In the Random Graph Search (RGS) baseline, a large amount of graphs are generated randomly.   
+RGS focuses on exploiting given structures, and does not utilize evolution to generate new graphs.
+
+# 4.1 EVOLUTION TOPOLOGY SEARCH
+
+In this experiment, the task is to evolve the graph and the controller from scratch. For both fish and walker, species are initialized as random $( { \mathcal { G } } , \theta )$ . Computation cost is often a concern among structure search problems. In our comparison results, for fairness, we allocate the same computation budget to all methods, which is approximately 12 hours on a $\mathtt { E C 2 \ m 4 . 1 6 \times 1 a r g e }$ cluster with 64 cores for one session. A grid search over the hyper-parameters is performed (details in Appendix E). The averaged curves from different runs are shown in Figure 2. In both fish and walker environments, NGE is the best model. We find RGS is not able to efficiently search the space of $\mathcal { G }$ even after evaluating 12, 800 different graphs. The performance of ESS-Sims grows faster for the earlier generations, but is significantly worse than our method in the end. The use of AF and GM-UC on ESS-Sims can improve the performance by a large margin, which indicates that the sub-modules in NGE are effective. By looking at the generated species, ESS-Sims and its variants overfit to local species that dominate the rest of generations. The results of ESS-BodyShare indicates that, the use of structured graph models without message passing might be insufficient in environments that require global features, for example, walker.
+
+![](images/5e50d9c050c8d569952dde06bce8d1d51e7eca8d9b2cb77d12af4f9fb2cac2e7.jpg)  
+Figure 3: The genealogy tree generated using NGE for fish. The number next to the node is the reward (the averaged speed of the fish). For better visualization, we down-sample genealogy sub-chain of the winning species. NGE agents gradually grow symmetrical side-fins.
+
+![](images/9b433e8161c629493c0b84edc2c426bbe01e6993718cae2b5d395a7a563768e0.jpg)  
+Figure 4: Fine-tuning results on different creatures compared with baseline where structure is fixed. The figures included the species looking from 2 different angles.
+
+To better understand the evolution process, we visualize the genealogy tree of fish using our model in Figure 3. Our fish species gradually generates three fins with preferred $\{ A ( u ) \}$ , with two side-fins symmetrical about the fish torso, and one tail-fin lying in the middle line. We obtain similar results for walker, as shown in Appendix C. To the best of our knowledge, our algorithm is the first to automatically discover kinematically plausible robotic graph structures.
+
+# 4.2 FINE-TUNING SPECIES
+
+Evolving every species from scratch is costly in practice. For many locomotion control tasks, we already have a decent human-engineered robot as a starting point. In the fine-tuning task, we verify the ability of NGE to improve upon the human-engineered design. We showcase both, unconstrained experiments with NGE where the graph $( V , E , A )$ is fine-tuned, and constrained fine-tuning experiments where the topology of the graph is preserved and only the node attributes $\{ A ( u ) \}$ are fine-tuned. In the baseline models, the graph $( V , E , A )$ is fixed, and only the controllers are trained. We can see in Figure 4 that when given the same wall-clock time, it is better to co-evolve the attributes and controllers with NGE than only training the controllers.
+
+The figure shows that with NGE, the cheetah gradually transforms the forefoot into a claw, the 3D-fish rotates the pose of the side-fins and tail, and the 2D-walker evolves bigger feet. In general, unconstrained fine-tuning with NGE leads to better performance, but not necessarily preserves the initial structures.
+
+![](images/5fbb41d8252c34ce241a6c560a063ef4faa5d6f1f740b48a07d2a82c2d37c501.jpg)  
+Figure 5: Results of ablation study, NGE without uncertainty results and rapid evolution during experiments.
+
+# 4.3 GREEDY SEARCH V.S. EXPLORATION UNDER UNCERTAINTY
+
+We also investigate the performance of NGE with and without Graph Mutation with Uncertainty, whose hyper-parameters are summarized in Appendix E. In Figure 5a, we applied GM-UC to the evolution graph search task. The final performance of the GM-UC outperforms the baseline on both fish and walker environments. The proposed GM-UC is able to better explore the graph space, showcasing its importance.
+
+# 4.4 COMPUTATION COST AND GENERATION SIZE
+
+We also investigate how the generation size $\mathcal { N }$ affect the final performance of NGE. We note that as we increase the generation size and the computing resources, NGE achieves marginal improvement on the simple Fish task. A NGE session with 16-core m5.4xlarge $\$ 0.768$ per Hr) AWS machine can achieve almost the same performance with 64-core m4.16xlarge $\$ 3.20$ per Hr) in Fish environment in the same wall-clock time. However, we do notice that there is a trade off between computational resources and performance for the more difficult task. In general, NGE is effective even when the computing resources are limited and it significantly outperforms RGS and ES by using only a small generation size of 16.
+
+# 5 DISCUSSION
+
+In this paper, we introduced NGE, an efficient graph search algorithm for automatic robot design that co-evolves the robot design graph and its controllers. NGE greatly reduces evaluation cost by transferring the learned GNN-based control policy from previous generations, and better explores the search space by incorporating model uncertainties. Our experiments show that the search over the robotic body structures is challenging, where both random graph search and evolutionary strategy fail to discover meaning robot designs. NGE significantly outperforms the naive approaches in both the final performance and computation time by an order of magnitude, and is the first algorithm that can discovers graphs similar to carefully hand-engineered design. We believe this work is an important step towards automated robot design, and may show itself useful to other graph search problems.
+
+Acknowledgements Partially supported by Samsung and NSERC. We also thank NVIDIA for their donation of GPUs.
+
+# REFERENCES
+
+Trapit Bansal, Jakub Pachocki, Szymon Sidor, Ilya Sutskever, and Igor Mordatch. Emergent complexity via multi-agent competition. arXiv preprint arXiv:1710.03748, 2017.
+
+Joan Bruna, Wojciech Zaremba, Arthur Szlam, and Yann LeCun. Spectral networks and locally connected networks on graphs. ICLR, 2014.
+
+Roberto Calandra, André Seyfarth, Jan Peters, and Marc Peter Deisenroth. Bayesian optimization for learning gaits under uncertainty. Annals of Mathematics and Artificial Intelligence, 76(1-2):5–23, 2016.
+
+Nick Cheney, Robert MacCurdy, Jeff Clune, and Hod Lipson. Unshackling evolution: Evolving soft robots with multiple materials and a powerful generative encoding. ACM SIGEVOlution, 7(1): 11–23, 2014.
+
+Kurtland Chua, Roberto Calandra, Rowan McAllister, and Sergey Levine. Deep reinforcement learning in a handful of trials using probabilistic dynamics models. arXiv preprint arXiv:1805.12114, 2018.
+
+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.
+
+Michaël Defferrard, Xavier Bresson, and Pierre Vandergheynst. Convolutional neural networks on graphs with fast localized spectral filtering. In NIPS, 2016.
+
+Paul Drews, Grady Williams, Brian Goldfain, Evangelos A Theodorou, and James M Rehg. Aggressive deep driving: Combining convolutional neural networks and model predictive control. In Conference on Robot Learning, pp. 133–142, 2017.
+
+David Duff, Mark Yim, and Kimon Roufas. Evolution of polybot: A modular reconfigurable robot. In Proc. of the Harmonic Drive Intl. Symposium, Nagano, Japan, 2001.
+
+David K Duvenaud, Dougal Maclaurin, Jorge Iparraguirre, Rafael Bombarell, Timothy Hirzel, Alán Aspuru-Guzik, and Ryan P Adams. Convolutional networks on graphs for learning molecular fingerprints. In NIPS, 2015.
+
+Yarin Gal and Zoubin Ghahramani. Dropout as a bayesian approximation: Representing model uncertainty in deep learning. In international conference on machine learning, pp. 1050–1059, 2016.
+
+Nicolas Heess, Srinivasan Sriram, Jay Lemmon, Josh Merel, Greg Wayne, Yuval Tassa, Tom Erez, Ziyu Wang, Ali Eslami, Martin Riedmiller, et al. Emergence of locomotion behaviours in rich environments. arXiv preprint arXiv:1707.02286, 2017.
+
+Mikael Henaff, Joan Bruna, and Yann LeCun. Deep convolutional networks on graph-structured data. arXiv preprint arXiv:1506.05163, 2015.
+
+Michał Joachimczak, Reiji Suzuki, and Takaya Arita. Fine grained artificial development for bodycontroller coevolution of soft-bodied animats. Artificial life, 14:239–246, 2014.
+
+Thomas N Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. ICLR, 2017.
+
+Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. In Advances in neural information processing systems, pp. 1097–1105, 2012.
+
+Christopher G Langton. Artificial life: An overview. Mit Press, 1997.
+
+Wei-Po Lee. An evolutionary system for automatic robot design. In Systems, Man, and Cybernetics, 1998. 1998 IEEE International Conference on, volume 4, pp. 3477–3482. IEEE, 1998.
+
+Yujia Li, Daniel Tarlow, Marc Brockschmidt, and Richard Zemel. Gated graph sequence neural networks. arXiv preprint arXiv:1511.05493, 2015.
+
+Hanxiao Liu, Karen Simonyan, Oriol Vinyals, Chrisantha Fernando, and Koray Kavukcuoglu. Hierarchical representations for efficient architecture search. arXiv preprint arXiv:1711.00436, 2017.
+
+Melanie Mitchell and Stephanie Forrest. Genetic algorithms and artificial life. Artificial life, 1(3): 267–289, 1994.
+
+Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Alex Graves, Ioannis Antonoglou, Daan Wierstra, and Martin Riedmiller. Playing atari with deep reinforcement learning. arXiv preprint arXiv:1312.5602, 2013.
+
+Volodymyr Mnih, Adria Puigdomenech Badia, Mehdi Mirza, Alex Graves, Timothy Lillicrap, Tim Harley, David Silver, and Koray Kavukcuoglu. Asynchronous methods for deep reinforcement learning. In International Conference on Machine Learning, pp. 1928–1937, 2016.
+
+Anusha Nagabandi, Gregory Kahn, Ronald S Fearing, and Sergey Levine. Neural network dynamics for model-based deep reinforcement learning with model-free fine-tuning. arXiv preprint arXiv:1708.02596, 2017.
+
+Ferrante Neri. Memetic compact differential evolution for cartesian robot control. IEEE Computational Intelligence Magazine, 5(2):54–65, 2010.
+
+Hieu Pham, Melody Y Guan, Barret Zoph, Quoc V Le, and Jeff Dean. Efficient neural architecture search via parameter sharing. arXiv preprint arXiv:1802.03268, 2018.
+
+Aravind Rajeswaran, Kendall Lowrey, Emanuel V Todorov, and Sham M Kakade. Towards generalization and simplicity in continuous control. In Advances in Neural Information Processing Systems, pp. 6553–6564, 2017.
+
+John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy optimization algorithms. arXiv preprint arXiv:1707.06347, 2017.
+
+Karl Sims. Evolving virtual creatures. In Proceedings of the 21st annual conference on Computer graphics and interactive techniques, pp. 15–22. ACM, 1994.
+
+Jasper Snoek, Hugo Larochelle, and Ryan P Adams. Practical bayesian optimization of machine learning algorithms. In Advances in neural information processing systems, pp. 2951–2959, 2012.
+
+Kenneth O Stanley and Risto Miikkulainen. Evolving neural networks through augmenting topologies. Evolutionary computation, 10(2):99–127, 2002.
+
+Luc Steels. The artificial life roots of artificial intelligence. Artificial life, 1(1_2):75–110, 1993.
+
+Yuval Tassa, Tom Erez, and Emanuel Todorov. Synthesis and stabilization of complex behaviors through online trajectory optimization. In Intelligent Robots and Systems (IROS), 2012 IEEE/RSJ International Conference on, pp. 4906–4913. IEEE, 2012.
+
+Yuval Tassa, Yotam Doron, Alistair Muldal, Tom Erez, Yazhe Li, Diego de Las Casas, David Budden, Abbas Abdolmaleki, Josh Merel, Andrew Lefrancq, et al. Deepmind control suite. arXiv preprint arXiv:1801.00690, 2018.
+
+Tim Taylor. Evolution in virtual worlds. arXiv preprint arXiv:1710.06055, 2017.
+
+Emanuel Todorov, Tom Erez, and Yuval Tassa. Mujoco: A physics engine for model-based control. In Intelligent Robots and Systems (IROS), 2012 IEEE/RSJ International Conference on, pp. 5026– 5033. IEEE, 2012.
+
+Li Wan, Matthew Zeiler, Sixin Zhang, Yann Le Cun, and Rob Fergus. Regularization of neural networks using dropconnect. In International Conference on Machine Learning, pp. 1058–1066, 2013.
+
+Tingwu Wang, Renjie Liao, Jimmy Ba, and Sanja Fidler. Nervenet: Learning structured policy with graph neural networks. In ICLR, 2018.
+
+Barret Zoph and Quoc V Le. Neural architecture search with reinforcement learning. arXiv preprint arXiv:1611.01578, 2016.
+
+![](images/b5211ae0f5290b26b5598c34119199588fefd60fcfea62b58bcedd35e02f549a.jpg)  
+Figure 6: In this figure, we show the computation graph of NerveNet+ $^ +$ . At each timestep, every node in the graph updates its hidden state by absorbing the messages as well as the input feature. The output function takes the hidden states as input and outputs the controller (or policy) of the agent.
+
+# A DETAILS OF NERVENET $^ { + + }$
+
+Similar to NerveNet, we parse the agent into a graph, where each node in the graph corresponds to the physical body part of the agents. For example, the fish in Figure 1 can be parsed into a graph of five nodes, namely the torso (0), left-fin (1), right-fin (2), and tail-fin bodies (3, 4). By replacing MLP with NerveNet, the learnt policy has much better performance in terms of robustness and the transfer learning ability. We here propose minor but effective modifications to Wang et al. (2018), and refer to this model as NerveNet++.
+
+In the original NerveNet, at every timestep, several propagation steps need to be performed such that every node is able to receive global information before producing the control signal. This is time and memory consuming, with the minimum number of propagation steps constrained by the depth of the graph.
+
+Since the episode of each game usually lasts for several hundred timesteps, it is computationally expensive and ineffective to build the full back-propagation graph. Inspired by Mnih et al. (2016), we employ the truncated graph back-propagation to optimize the policy. NerveNet+ $^ { \cdot + }$ is suitable for an evolutionary search or population-based optimization, as it brings speed-up in wall-clock time, and decreases the amount of memory usage.
+
+Therefore in NerveNe $^ { + + }$ , we propose a propagation model with the memory state, where each node updates its hidden state by absorbing the input feature and a message with time. The number of propagation steps is no longer constrained by the depth of the graph, and in back-propagation, we save memory and time consumption with truncated computation graph.
+
+The computational performance evaluation is provided in Appendix B. NerveNet+ $^ +$ model is trained by the PPO algorithm Schulman et al. (2017); Heess et al. (2017),
+
+# B OPTIMIZATION WITH TRUNCATED BACKPROPAGATION
+
+During training, the agent generates the rollout data by sampling from the distribution $a _ { t } \sim \pi ( a _ { t } | s _ { t } )$ and stores the training data of $\mathcal { D } = \{ a ^ { t } , s ^ { t } , \{ h _ { u } ^ { t , \tau = 0 } \} \}$ . To train the reinforcement learning agents with memory, the original training objective is
+
+$$
+J ( \theta ) = \mathbb { E } _ { \pi } \left[ \sum _ { t = 0 } ^ { \infty } \gamma ^ { t } r ( s ^ { t } , a ^ { t } , \{ h _ { u } ^ { t , \tau = 0 } \} ) \right] ,
+$$
+
+where we denote the whole update model as $H$ and
+
+$$
+h _ { u } ^ { t + 1 , \tau = 0 } = H ( \{ h _ { v } ^ { t , \tau = 0 } \} , s ^ { t } , a ^ { t } ) .
+$$
+
+![](images/0cf94e39d660ebd29877df92792868564f3a09bea210994b1c774e00bd3db98f.jpg)  
+Figure 7: In these two figures, we show that to reach similar performance, NerveNet+ $^ +$ took shorter time comparing to original NerveNet.
+
+The memory state $h _ { u } ^ { t + 1 , \tau }$ depends on the previous actions, observations, and states. Therefore, the full back-propagation graph will be the same length as the episode length, which is very computationally intensive. The intuition from the authors in Mnih et al. (2016) is that, for the RL agents, the dependency of the agents on timesteps that are far-away from the current timestep is limited. Thus, negligible accuracy of the gradient estimator will be lost if we truncate the back-propagation graph. We define a back-propagation length $\Gamma$ , and optimize the following objective function instead:
+
+$$
+\begin{array} { r l } & { \quad J _ { T } ( \theta ) = \mathbb E _ { \pi } \left[ \displaystyle \sum _ { t = 0 } ^ { \infty } \displaystyle \sum _ { \kappa = 0 } ^ { \Gamma - 1 } \gamma ^ { t + \kappa } r ( s _ { t + \kappa } , a _ { t + \kappa } , \{ h _ { u } ^ { t , \tau = 0 } \} ) \right] , \ : \mathrm { w h e r e } } \\ & { \quad h _ { u } ^ { t + \kappa , \tau = 0 } = \left\{ \begin{array} { l l } { H ( \{ h _ { v } ^ { t + \kappa - 1 , \tau = 0 } , \forall v \} , s _ { t + \kappa - 1 } , a _ { t + \kappa - 1 } ) \quad } & { \kappa \neq 0 , } \\ { h _ { u } ^ { t , \tau = 0 } \in \mathcal D \quad } & { \kappa = 0 , } \end{array} \right. } \end{array}
+$$
+
+Essentially this optimization means that we only back-propagate up to $\Gamma$ timesteps, namely at the places where $\kappa = 0$ , we treat the hidden state as input to the network and stop the gradient. To optimize the objective function, we follow same optimization procedure as in Wang et al. (2018), which is a variant of PPO Schulman et al. (2017), where a surrogate loss $J _ { \mathrm { p p o } } ( \theta )$ is optimized. We refer the readers to these papers for algorithm details.
+
+# C FULL NGE RESULTS
+
+Similar to the fish genealogy tree, in Fig. 8, the simple initial walking agent evolves into a cheetah-like structure, and is able to run with high speed. We also show the species generated by NGE, ESS-Sims (ESS-Sims-AF to be more specific, which has the best performance among all ESS-Sims variants.) and RGS.
+
+# D RESETTING CONTROLLER FOR FAIR COMPETITION
+
+Although amortized fitness is a better estimation of the ground-truth fitness, it is still biased. Species that appear earlier in the experiment will be trained for more updates if it survives. Indeed, intuitively, it is possible that in real nature, species that appear earlier on will dominate the generation by number, and new species are eliminated even if the new species has better fitness. Therefore, we design the experiment where we reset the weights for all species $\theta = ( \theta _ { \Phi } , \theta _ { \zeta } , \theta _ { M } , \theta _ { U } , \theta _ { F } )$ randomly. By doing this, we are forcing the species to compete fairly. From Fig 10, we notice that this method helps exploration, which leads to a higher reward in the end. However, it usually takes a longer time for the algorithm to converge. Therefore for the graph search task in Fig 2, we do not include the results with the controller-resetting.
+
+![](images/716e206836792ddab9d1fc8348ce669faab16f2ec614d74faee62e59a8209062.jpg)  
+Figure 8: Our walker species gradually grows two foot-like structures from randomly initialized body graph.
+
+![](images/a406d83d3adcc19b5eac6dc93df042348580e2442eae8c5093c0f282310809d3.jpg)  
+Figure 9: We present qualitative comparison between the three algorithms in the figure. Specifically, the aligned comparison between our method and naive baseline are the representative creatures at the same generation (using same computation resources). Our algorithm notably display stronger dominance in terms of its structure as well as reward.
+
+![](images/c1838debebc25ca3af12e8c06a8bc188ee90c8eab19018442aa7d90a55637911.jpg)  
+Figure 10: The results of resetting controller scheme and baselines.
+
+# E HYPER-PARAMETERS SEARCHED
+
+All methods are given equal amount of computation budget. To be more specific, the number of total timesteps generated by all species for all generations is the same for all methods. For example, if we use 10 training epochs in one generation, each of the epoch with 2000 sampled timesteps, then the computation budget allows NGE to evolve for 200 generations, where each generation has a species size of 64. For NGE, RGS, ESS-Sims-AF models in Fig 11, we run a grid search over the hyper-parameters recorded in Table 2, and Table 3, and plot the curve with the best results respectively.
+
+![](images/e98cbe174974ebb813c4abfefabd4eabdc5fbc42014ba545dd6b2894fb925637.jpg)  
+Figure 11: The results of the graph search
+
+Since the number of generations for the RGS baseline can be regarded as 1, its curve is plotted with the number of updates normalized by the computation resource as $\mathbf { X }$ -axis.
+
+Here we show the detail figures of six baselines, which are: RGS-20, RGS-100, RGS-200, and ESS-Sims-AF-20, ESS-Sims-AF-100, ESS-Sims-AF-200. The number attached to the baseline names indicates the number of inner-loop policy training epochs. In the case of RGS-20, where more than 12800 different graphs are searched over, the average reward is still very low. Increasing the number of inner-loop training of species to 100 and 200 does not help the final performance significantly.
+
+To test the performance with and without GM-UC, we use 64-core clusters (generations of size 64).   
+Here, the hyper-parameters are chosen to be the first value available in Table 2 and Table 3.
+
+Table 2: Hyperparameter grid search options.   
+
+<table><tr><td>Items</td><td>Value Tried</td></tr><tr><td>Number of Iteration Per Update Number of Species per Generation Elimination Rate Discrete Socket Timesteps per Updates</td><td>10,20,100,200 16,32,64,100 0.15, 0.20, 0.3 Yes, True 2000,4000,6000</td></tr><tr><td>Target KL Learning Rate Schedule Number of Maximum Generation</td><td>0.01 Adaptive</td></tr><tr><td>Prob of Add-Node,Add-Graph Prob of Pert-Graph Prob of Del-Graph</td><td>400 0.15</td></tr></table>
+
+# F MODEL BASED SEARCH USING THOMPSON SAMPLING
+
+Thompson Sampling is a simple heuristic search strategy that is typically applied to the multi-armed bandit problem. The main idea is to select an action proportional to the probability of the action being optimal. When applied to the graph search problem, Thompson Sampling allows the search to balance the trade-off between exploration and exploitation by maximizing the expected fitness under the posterior distribution of the surrogate model.
+
+Table 3: Hyperparameters grid search options for NGE.   
+
+<table><tr><td>Items</td><td>Value Tried</td></tr><tr><td>Allow Graph-Add</td><td>True, False</td></tr><tr><td>Graph Mutation with Uncertainty</td><td>True,False</td></tr><tr><td>Pruning Temperature</td><td>0.01, 0.1, 1</td></tr><tr><td>Network Structure</td><td>NerveNet,NerveNet++</td></tr><tr><td>Number Candidates before Pruning</td><td>200,400</td></tr></table>
+
+Formally, Thompson Sampling selects the best graph candidates at each round according to the expected estimated fitness $\xi _ { P }$ using a surrogate model. The expectation is taken under the posterior distribution of the surrogate $P$ (model|data):
+
+$$
+\mathcal { G } ^ { * } = \arg \operatorname* { m a x } _ { \mathcal { G } } \mathbb { E } _ { P ( \mathrm { m o d e l } | \mathrm { d a t a } ) } \left[ \xi _ { P } \left( \mathcal { G } | \mathrm { m o d e l } \right) \right] .
+$$
+
+# F.1 SURROGATE MODEL ON GRAPHS.
+
+Here we consider a graph neural network (GNN) surrogate model to predict the average fitness of a graph as a Gaussian distribution, namely $\boldsymbol { P } \left( f ( \boldsymbol { \mathcal { G } } ) \right) \ \stackrel { \sim } { \sim } \mathcal { N } \left( \xi _ { P } ( \boldsymbol { \mathcal { G } } ) , \stackrel { \sim } { \sigma } ^ { 2 } ( \boldsymbol { \mathcal { G } } ) \right)$ . We use a simple architecture that predicts the mean of the Gaussian from the last hidden layer activations, $h _ { W } ( { \mathcal { G } } ) \in$ $\mathbb { R } ^ { D }$ , of the GNN, where $W$ are the weights in the GNN up to the last hidden layer.
+
+Greedy search. We denoted the size of dataset as $N$ . The GNN weights are trained to predict the average fitness of the graph as a standard regression task:
+
+$$
+\operatorname* { m i n } _ { W , W _ { o u t } } \frac { \beta } { 2 } \sum _ { n = 1 } ^ { N } \left( \xi ( \mathcal { G } _ { n } ) - \xi _ { P } ( \mathcal { G } _ { n } ) \right) ^ { 2 } , \quad \mathrm { w h e r e } \quad \xi _ { P } ( \mathcal { G } _ { n } ) = W _ { o u t } ^ { T } h _ { W } ( \mathcal { G } _ { n } )
+$$
+
+# Algorithm 2 Greedy Search
+
+1: Initialize generation $\mathcal { P } ^ { 0 }$   
+2: for $j <$ maximum generations do   
+3: Collect the $( \xi _ { i } ^ { k } , \mathcal { G } _ { i } ^ { k } )$ from previous $k \leq j$ generations . Update dataset   
+4: Train $W$ and $W _ { o u t }$ on $\{ ( \xi _ { i } ^ { k } , \mathcal { G } _ { i } ^ { k } ) \} _ { n = 1 } ^ { N }$ . Train GM-UC   
+5: Propose $\mathcal { C }$ new graph $\{ \mathcal { G } _ { i } \} _ { i = 1 } ^ { \mathcal { C } }$ , ${ \mathcal { C } } > > M$ . $\triangleright$ Propose new candidates   
+6: Rank $\{ \xi _ { P } ( \mathcal { G } _ { i } | W , W _ { o u t } ) \} _ { i = 1 } ^ { \mathcal { C } }$ on the proposals and pick the top $\kappa$ . Prune candidates   
+7: Update generation $\mathcal { P } ^ { j }$   
+8: for $m < \mathcal N$ do $\triangleright$ Train and evaluate each species   
+9: for $k <$ maximum parameter updates do   
+10: Train policy πGm   
+11: end for   
+12: Evaluate the fitness $\xi ( \mathcal { G } _ { m } , \theta _ { m } )$   
+13: end for   
+14: end for
+
+Thompson Sampling In practice, Thompson Sampling is very similar to the previous greedy search algorithm. Instead of picking the top action according to the best model parameters, at each generation, it draws a sample of the model and takes a greedy action under the sampled model.
+
+Approximating Thompson Sampling using Dropout Performing dropout during inference can be viewed as an approximately sampling from the model posterior. At each generation, we will sample a single dropout mask for the surrogate model and rank all the proposed graphs accordingly.
+
+# Algorithm 3 Thompson Sampling using Bayesian Neural Networks
+
+1: Initialize generation P0   
+2: for $j <$ maximum generations do   
+3: Collect the $( \xi _ { i } ^ { k } , \mathcal { G } _ { i } ^ { k } )$ from previous $k \leq j$ generations . Update dataset   
+4: Train $W$ and $W _ { o u t }$ on $\{ ( \xi _ { i } ^ { k } , \mathcal { G } _ { i } ^ { k } ) \} _ { n = 1 } ^ { N }$ . Train GM-UC   
+5: Propose $\mathcal { C }$ new graph $\{ \mathcal { G } _ { i } \} _ { i = 1 } ^ { \mathcal { C } } , \mathcal { C } > > M$ . . Propose new candidates   
+6: Sample a model from the posterior of the weights.   
+7: e.g. $\widetilde { W } , \widetilde { W } _ { o u t } \sim P \left( W , W _ { o u t } | D \right) \approx \mathcal { N } \left( [ W , W _ { o u t } ] , [ W , W _ { o u t } ] \right)$   
+8: (similar to DropConnect Wan et al. (2013))   
+9: Rank $\{ \xi _ { P } ( \mathcal { G } _ { i } | \widetilde { W } , \widetilde { W } _ { o u t } ) \} _ { i = 1 } ^ { \mathcal { C } }$ on the proposals and pick the top $\kappa$   
+10: for $m < \mathcal N$ do $\triangleright$ Train and evaluate each species   
+11: for $k <$ maximum parameter updates do   
+12: Train policy πGm   
+13: end for   
+14: Evaluate the fitness $\xi ( \mathcal { G } _ { m } , \theta _ { m } )$   
+15: end for   
+16: end for
+
+# Algorithm 4 Thompson Sampling with Dropout
+
+1: Initialize generation $\mathcal { P } ^ { 0 }$   
+2: for $j <$ maximum generations do   
+3: Collect the $( \xi _ { i } ^ { k } , \mathcal { G } _ { i } ^ { k } )$ from previous $k \leq j$ generations $\triangleright$ Update dataset   
+4: Train $W$ and $W _ { o u t }$ on $\{ { \mathcal G } _ { n } , \xi ( { \mathcal G } _ { n } ) \} _ { n = 1 } ^ { N }$ using dropout rate 0.5 on the inputs of the fc layers.   
+5: Propose $\mathcal { C }$ new graph $\{ \mathcal { G } _ { i } \} _ { i = 1 } ^ { \mathcal { C } } , \mathcal { C } > > M$ . . Propose new candidates   
+6: Sample a dropout mask $\mathrm { m } _ { i }$ for the hidden units   
+7: Rank $\{ \xi _ { P } ( \mathcal { G } _ { i } \bar { | } W , W _ { o u t } , \mathbf { m } _ { i } ) \} _ { i = 1 } ^ { J }$ on the proposals and pick the top $\kappa$   
+8: for $m < \mathcal N$ do $\triangleright$ Train and evaluate each species   
+9: for $k <$ maximum parameter updates do   
+10: Train policy πGm   
+11: end for   
+12: Evaluate the fitness $\xi ( \mathcal { G } _ { m } , \theta _ { m } )$   
+13: end for   
+14: end for

parse/train/BkgWHnR5tm/BkgWHnR5tm_content_list.json

@@ -0,0 +1,2189 @@
+[
+    {
+        "type": "text",
+        "text": "NEURAL GRAPH EVOLUTION: TOWARDS EFFICIENT AUTOMATIC ROBOT DESIGN ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            820,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Tingwu Wang1,2∗, Yuhao Zhou1,2∗, Sanja Fidler1,2,3 & Jimmy $\\mathbf { B a } ^ { 1 , 2 }$ ",
+        "bbox": [
+            184,
+            167,
+            653,
+            184
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Department of Computer Science, University of Toronto   \n2 Vector Institute   \n3 NVIDIA   \n{tingwuwang,henryzhou,fidler,jba}@cs.toronto.e ",
+        "bbox": [
+            186,
+            186,
+            627,
+            242
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            279,
+            544,
+            292
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Despite the recent successes in robotic locomotion control, the design of robots, i.e., the design of their body structure, still heavily relies on human engineering. Automatic robot design has been a long studied subject, however, progress has been slow due to large combinatorial search space and the difficulty to efficiently evaluate the candidate structures. Note that one needs to both, search over many possible body structures, and choose among them based on how the robot with that structure performs in an environment. The latter means training an optimal controller given a candidate structure, which in itself is costly to obtain. In this paper, we propose Neural Graph Evolution (NGE), which performs evolutionary search in graph space, by iteratively evolving graph structures using simple mutation primitives. Key to our approach is to parameterize the control policies with graph neural networks, which allows us to transfer skills from previously evaluated designs during the graph search. This significantly reduces evaluation cost of new candidates and makes the search process orders of magnitude more efficient than that of past work. In addition, NGE applies Graph Mutation with Uncertainty (GM-UC) by incorporating model uncertainty, which reduces the search space by balancing exploration and exploitation. We show that NGE significantly outperforms previous methods in terms of convergence rate and final performance. As shown in experiments, NGE is the first algorithm that can automatically discover kinematically preferred robotic graph structures, such as a fish with two symmetric flat side-fins and a tail, or a cheetah with athletic front and back legs. NGE is extremely efficient, it finds plausible robotic structures within a day on a single 64 CPU-core Amazon EC2 machine. ",
+        "bbox": [
+            232,
+            309,
+            766,
+            627
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            654,
+            336,
+            670
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The goal of robot design is to find an optimal body structure and its means of locomotion to best achieve a given objective in an environment. Robot design often relies on careful human-engineering and expert knowledge. The field of automatic robot design aims to search for these structures automatically. This has been a long-studied subject, however, with limited success. There are two major challenges: 1) the search space of all possible designs is large and combinatorial, and 2) the evaluation of each design requires learning or testing a separate optimal controller that is often expensive to obtain. ",
+        "bbox": [
+            174,
+            685,
+            825,
+            782
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In (Sims, 1994), the authors evolved creatures with 3D-blocks. Recently, soft robots have been studied in (Joachimczak et al., 2014), which were evolved by adding small cells connected to the old ones. In (Cheney et al., 2014), the 3D voxels were treated as the minimum element of the robot. Most evolutionary robots (Duff et al., 2001; Neri, 2010) require heavy engineering of the initial structures, evolving rules and careful human-guidance. Due to the combinatorial nature of the problem, evolutionary, genetic or random structure search have been the de facto algorithms of automatic robot design in the pioneering works (Sims, 1994; Steels, 1993; Mitchell & Forrest, 1994; Langton, 1997; Lee, 1998; Taylor, 2017; Calandra et al., 2016). In terms of the underlying algorithm, most of these works have a similar population-based optimization loop to the one used in (Sims, 1994). None of these algorithms are able to evolve kinematically reasonable structures, as a result of large search space and the inefficient evaluation of candidates. ",
+        "bbox": [
+            174,
+            790,
+            825,
+            901
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            145
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Similar in vein to automatic robot design, automatic neural architecture search also faces a large combinatorial search space and difficulty in evaluation. There have been several approaches to tackle these problems. Bayesian optimization approaches (Snoek et al., 2012) primarily focus on fine-tuning the number of hidden units and layers from a predefined set. Reinforcement learning (Zoph & Le, 2016) and genetic algorithms (Liu et al., 2017) are studied to evolve recurrent neural networks (RNNs) and convolutional neural networks (CNNs) from scratch in order to maximize the validation accuracy. These approaches are computationally expensive because a large number of candidate networks have to be trained from grounds up. (Pham et al., 2018) and (Stanley & Miikkulainen, 2002) propose weight sharing among all possible candidates in the search space to effectively amortize the inner loop training time and thus speed up the architecture search. A typical neural architecture search on ImageNet (Krizhevsky et al., 2012) takes 1.5 days using 200 GPUs (Liu et al., 2017). ",
+        "bbox": [
+            173,
+            152,
+            825,
+            305
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we propose an efficient search method for automatic robot design, Neural Graph Evolution (NGE), that co-evolves both, the robot design and the control policy. Unlike the recent reinforcement learning work, where the control policies are learnt on specific robots carefully designed by human experts (Mnih et al., 2013; Bansal et al., 2017; Heess et al., 2017), NGE aims to adapt the robot design along with policy learning to maximize the agent’s performance. NGE formulates automatic robot design as a graph search problem. It uses a graph as the main backbone of rich design representation and graph neural networks (GNN) as the controller. This is key in order to achieve efficiency of candidate structure evaluation during evolutionary graph search. Similar to previous algorithms like (Sims, 1994), NGE iteratively evolves new graphs and removes graphs based on the performance guided by the learnt GNN controller. The specific contributions of this paper are as follows: ",
+        "bbox": [
+            174,
+            313,
+            825,
+            464
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• We formulate the automatic robot design as a graph search problem.   \n• We utilize graph neural networks (GNNs) to share the weights between the controllers, which greatly reduces the computation time needed to evaluate each new robot design.   \n• To balance exploration and exploitation during the search, we developed a mutation scheme that incorporates model uncertainty of the graphs. ",
+        "bbox": [
+            174,
+            477,
+            825,
+            558
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We show that NGE automatically discovers robot designs that are comparable to the ones designed by human experts in MuJoCo (Todorov et al., 2012), while random graph search or naive evolutionary structure search (Sims, 1994) fail to discover meaningful results on these tasks. ",
+        "bbox": [
+            176,
+            569,
+            825,
+            611
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 BACKGROUND ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            631,
+            326,
+            647
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 REINFORCEMENT LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            662,
+            415,
+            676
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In reinforcement learning (RL), the problem is usually formulated as a Markov Decision Process (MDP). The infinite-horizon discounted MDP consists of a tuple of $( S , { \\mathcal { A } } , \\gamma , P , R )$ , respectively the state space, action space, discount factor, transition function, and reward function. The objective of the agent is to maximize the total expected reward $\\begin{array} { r } { J ( \\theta ) = \\mathbb { E } _ { \\pi } \\left[ \\sum _ { t = 0 } ^ { \\infty } \\gamma ^ { t } r ( s _ { t } , a _ { t } ) \\right] } \\end{array}$ , where the state transition follows the distribution $\\bar { P ( } s _ { t + 1 } | s _ { t } , a _ { t } )$ . Here, $s _ { t }$ and $a _ { t }$ denotes the state and action at time step $t$ , and $r ( s _ { t } , a _ { t } )$ is the reward function. In this paper, to evaluate each robot structure, we use PPO to train RL agents (Schulman et al., 2017; Heess et al., 2017). PPO uses a neural network parameterized as $\\pi _ { \\boldsymbol { \\theta } } ( a _ { t } | \\boldsymbol { s } _ { t } )$ to represent the policy, and adds a penalty for the KL-divergence between the new and old policy to prevent over-optimistic updates. PPO optimizes the following surrogate objective function instead: ",
+        "bbox": [
+            173,
+            688,
+            825,
+            828
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/14ef5f963d44647499e039195f8f80bdaba5d5fbe680d71590e302238438b944.jpg",
+        "text": "$$\nJ _ { \\mathrm { P P O } } ( \\theta ) = \\mathbb { E } _ { \\pi _ { \\theta } } \\left[ \\sum _ { t = 0 } ^ { \\infty } A ^ { t } ( s _ { t } , a _ { t } ) r ^ { t } ( s _ { t } , a _ { t } ) \\right] - \\beta \\operatorname { K L } \\left[ \\pi _ { \\theta } ( : | s _ { t } ) | \\pi _ { \\theta _ { o l d } } ( : | s _ { t } ) \\right] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            251,
+            833,
+            745,
+            877
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We denote the estimate of the expected total reward given the current state-action pair, the value and the advantage functions, as $Q ^ { t } ( s _ { t } , a _ { t } )$ , $V ( s _ { t } )$ and $A ^ { t } ( s _ { t } , a _ { t } )$ respectively. PPO solves the problem by iteratively generating samples and optimizing $J _ { \\mathrm { P P O } }$ (Schulman et al., 2017). ",
+        "bbox": [
+            174,
+            882,
+            823,
+            925
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/2e9d715889591cf252e6b0c04ff94ec1f8941b9176793190fb0966ecbd604957.jpg",
+        "image_caption": [
+            "Figure 1: In NGE, several mutation operations are allowed. By using Policy Sharing, child species reuse weights from parents, even if the graphs are different. The same color indicates shared and reused weights. For better visualization, we only plot the sharing of propagation model (yellow curves). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            101,
+            808,
+            272
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 GRAPH NEURAL NETWORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            339,
+            406,
+            354
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Graph Neural Networks (GNNs) are suitable for processing data in the form of graph (Bruna et al., 2014; Defferrard et al., 2016; Li et al., 2015; Kipf & Welling, 2017; Duvenaud et al., 2015; Henaff et al., 2015). Recently, the use of GNNs in locomotion control has greatly increased the transferability of controllers (Wang et al., 2018). A GNN operates on a graph whose nodes and edges are denoted respectively as $u \\in V$ and $e \\in E$ . We consider the following GNN, where at timestep $t$ each node in GNN receives an input feature and is supposed to produce an output at a node level. ",
+        "bbox": [
+            173,
+            364,
+            825,
+            450
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Input Model: The input feature for node $u$ is denoted as $x _ { u } ^ { t }$ . $x _ { u } ^ { t }$ is a vector of size $d$ , where $d$ is the size of features. In most cases, $x _ { u } ^ { t }$ is produced by the output of an embedding function used to encode information about $u$ into $d$ -dimensional space. ",
+        "bbox": [
+            174,
+            455,
+            825,
+            500
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Propagation Model: Within each timestep $t$ , the GNN performs $\\tau$ internal propagations, so that each node has global (neighbourhood) information. In each propagation, every node communicates with its neighbours, and updates its hidden state by absorbing the input feature and message. We denote the hidden state at the internal propagation step $\\tau$ $( \\tau \\leq \\tau )$ as $h _ { u } ^ { t , \\tau }$ . Note that $h _ { u } ^ { t , 0 }$ is usually initialized as $h _ { u } ^ { t - 1 , T }$ , i.e., the final hidden state in the previous time step. $\\cdot _ { h ^ { 0 , 0 } }$ is usually initialized to zeros. The message that $u$ sends to its neighbors is computed as ",
+        "bbox": [
+            173,
+            505,
+            825,
+            590
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/981228f1c24e7d68c2f5fa8ea44fd229859c212ddad6f6b44865f0c3298a54fe.jpg",
+        "text": "$$\nm _ { u } ^ { t , \\tau } = M ( h _ { u } ^ { t , \\tau - 1 } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            423,
+            595,
+            557,
+            614
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $M$ is the message function. To compute the updated $h _ { u } ^ { t , \\tau }$ , we use the following equations: ",
+        "bbox": [
+            169,
+            622,
+            803,
+            637
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7cf86a2ef755466885b61a7a2f82737a9b7f7178e49aaba78be828216376ea40.jpg",
+        "text": "$$\nr _ { u } ^ { t , \\tau } = R ( \\{ m _ { v } ^ { t , \\tau } | \\forall v \\in \\mathcal { N } _ { G } ( u ) \\} ) , h _ { u } ^ { t , \\tau } = U ( h _ { u } ^ { t , \\tau - 1 } , ( r _ { u } ^ { t , \\tau } ; x _ { u } ^ { t } ) )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            292,
+            642,
+            704,
+            661
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $R$ and $U$ are the message aggregation function and the update function respectively, and $\\mathcal { N } _ { G } ( u )$ denotes the neighbors of $u$ . ",
+        "bbox": [
+            173,
+            667,
+            823,
+            696
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Output Model: Output function $F$ takes input the node’s hidden states after the last internal propagation. The node-level output for node $u$ is therefore defined as $\\mu _ { u } ^ { t } = F ( h _ { u } ^ { t , T } )$ . ",
+        "bbox": [
+            171,
+            703,
+            823,
+            732
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Functions $M , R , U , F$ in GNNs can be trainable neural networks or linear functions. For details of GNN controllers, we refer readers to (Wang et al., 2018). ",
+        "bbox": [
+            174,
+            738,
+            825,
+            767
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 NEURAL GRAPH EVOLUTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            786,
+            449,
+            803
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In robotics design, every component, including the robot arms, finger and foot, can be regarded as a node. The connections between the components can be represented as edges. In locomotion control, the robotic simulators like MuJoCo (Todorov et al., 2012) use an XML file to record the graph of the robot. As we can see, robot design is naturally represented by a graph. To better illustrate Neural Graph Evolution (NGE), we first introduce the terminology and summarize the algorithm. ",
+        "bbox": [
+            174,
+            818,
+            825,
+            888
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Graph and Species. We use an undirected graph $\\mathcal { G } = ( V , E , A )$ to represent each robotic design. $V$ and $E$ are the collection of physical body nodes and edges in the graph, respectively. The mapping ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 Neural Graph Evolution ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            406,
+            117
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/a9978583661ad393fa68b2b0276890cf10127a78e6a4ac3f92bbe948df49da7f.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>1: Initialize generation P°←{(0,G)}1</td><td></td></tr><tr><td>2:while Evolving jth generation do</td><td>Evolution outer loop</td></tr><tr><td>3: for ith species (0²,G) ∈ Pj do</td><td> Species fitness inner loop</td></tr><tr><td>4: 0j+1←Update(0）</td><td>Train policy network</td></tr><tr><td>5: S←s（0+1,G）</td><td>Evaluate fitness</td></tr><tr><td>6: end for</td><td></td></tr><tr><td>7: pj+1←Pj\\{(0k,Sk) ∈Pj,∀k ∈ argminx({Si})}.</td><td>Remove worst K species</td></tr><tr><td>P ←{(0h,9h =M(Gh,p)), whereGh,p ~ Uniform(Pj+1)}h=1 8:</td><td>Mutate from survivors</td></tr><tr><td>9: pj+1 √ pj+1 U{(0k,9k) ∈P, ∀k ∈ argmaxx({ξp(Gh)})}. 10: end while</td><td>Pruning</td></tr></table>",
+        "bbox": [
+            174,
+            119,
+            825,
+            265
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "$A : V  \\Lambda$ maps the node $u \\in V$ to its structural attributes $A ( u ) \\in \\Lambda$ , where $\\Lambda$ is the attributes space. For example, the fish in Figure 1 consists of a set of ellipsoid nodes, and vector $A ( u )$ describes the configurations of each ellipsoid. The controller is a policy network parameterized by weights $\\theta$ The tuple formed by the graph and the policy is defined as a species, denoted as $\\Omega = ( \\mathcal { G } , \\theta )$ . ",
+        "bbox": [
+            173,
+            291,
+            825,
+            349
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Generation and Policy Sharing. In the $j$ -th iteration, NGE evaluates a pool of species called a generation, denoted as $P ^ { j } = \\{ ( \\mathcal { G } _ { i } ^ { j } , \\theta _ { i } ^ { j } ) , \\forall i = 1 , 2 , . . . , \\mathcal { N } \\}$ , where $\\mathcal { N }$ is the size of the generation. In NGE, the search space includes not only the graph space, but also the weight or parameter space of the policy network. For better efficiency of NGE, we design a process called Policy Sharing (PS), where weights are reused from parent to child species. The details of PS is described in Section 3.4. ",
+        "bbox": [
+            174,
+            354,
+            825,
+            428
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Our model can be summarized as follows. NGE performs population-based optimization by iterating among mutation, evaluation and selection. The objective and performance metric of NGE are introduced in Section 3.1. In NGE, we randomly initialize the generation with $\\mathcal { N }$ species. For each generation, NGE trains each species and evaluates their fitness separately, the policy of which is described in Section 3.2. During the selection, we eliminate $\\kappa$ species with the worst fitness. To mutate $\\kappa$ new species from surviving species, we develop a novel mutation scheme called Graph Mutation with Uncertainty (GM-UC), described in Section 3.3, and efficiently inherit policies from the parent species by Policy Sharing, described in Section 3.4. Our method is outlined in Algorithm 1. ",
+        "bbox": [
+            174,
+            434,
+            825,
+            546
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 AMORTIZED FITNESS AND OBJECTIVE FUNCTION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            578,
+            560,
+            593
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Fitness represents the performance of a given $\\mathcal { G }$ using the optimal controller parameterized with $\\theta ^ { * } ( { \\mathcal { G } } )$ . However, $\\overleftarrow { \\theta ^ { * } } ( \\mathcal G )$ is impractical or impossible to obtain for the following reasons. First, each design is computationally expensive to evaluate. To evaluate one graph, the controller needs to be trained and tested. Model-free (MF) algorithms could take more than one million in-game timesteps to train a simple 6-degree-of-freedom cheetah (Schulman et al., 2017), while model-based (MB) controllers usually require much more execution time, without the guarantee of having higher performance than MF controllers (Tassa et al., 2012; Nagabandi et al., 2017; Drews et al., 2017; Chua et al., 2018). Second, the search in robotic graph space can easily get stuck in local-optima. In robotic design, local-optima are difficult to detect as it is hard to tell whether the controller has converged or has reached a temporary optimization plateau. Learning the controllers is a computation bottleneck in optimization. ",
+        "bbox": [
+            174,
+            604,
+            826,
+            757
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In population-based robot graph search, spending more computation resources on evaluating each species means that fewer different species can be explored. In our work, we enable transferablity between different topologies of NGE (described in Section 3.2 and 3.4). This allows us to introduce amortized fitness (AF) as the objective function across generations for NGE. AF is defined in the following equation as, ",
+        "bbox": [
+            174,
+            763,
+            825,
+            834
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2da1cd2a4602f48e4dfe91141054afe3baa60dd6778a9631b8604a78dccf566a.jpg",
+        "text": "$$\n\\xi ( \\mathcal { G } , \\boldsymbol { \\theta } ) = \\mathbb { E } _ { \\pi _ { \\boldsymbol { \\theta } } , \\mathcal { G } } \\left[ \\sum _ { t = 0 } ^ { \\infty } \\gamma ^ { t } r ( s _ { t } , a _ { t } ) \\right] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            380,
+            834,
+            617,
+            877
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In NGE, the mutated species continues the optimization by initializing the parameters with the parameters inherited from its parent species. In past work (Sims, 1994), species in one generation are trained separately for a fixed number of updates, which is biased and potentially undertrained or ",
+        "bbox": [
+            174,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "overtrained. In next generations, new species have to discard old controllers if the graph topology is different, which might waste valuable computation resources. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 POLICY REPRESENTATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            148,
+            398,
+            162
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Given a species with graph $\\mathcal { G }$ , we train the parameters $\\theta$ of policy network $\\pi _ { \\theta } ( a ^ { t } | s ^ { t } )$ using reinforcement learning. Similar to (Wang et al., 2018), we use a GNN as the policy network of the controller. A graphical representation of our model is shown in Figure 1. We follow notation in Section 2.2. ",
+        "bbox": [
+            174,
+            174,
+            826,
+            217
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For the input model, we parse the input state vector $s ^ { t }$ obtained from the environment into a graph, where each node $u \\in V$ fetches the corresponding observation $o ( u , t )$ from $s ^ { t }$ , and extracts the feature $x _ { u } ^ { O , t }$ with an embedding function $\\Phi$ . We also encode the attribute information $A ( u )$ into $x _ { u } ^ { A }$ with an embedding function denoted as $\\zeta$ . The input feature $x _ { u } ^ { t }$ is thus calculated as: ",
+        "bbox": [
+            173,
+            223,
+            825,
+            280
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6e40617ac8b8579e240b905f395d64b491a87aad8af31a04d5355f5fd2ab3052.jpg",
+        "text": "$$\n\\begin{array} { r } { x _ { u } ^ { O , t } = \\Phi ( o ( u , t ) ) , ~ x _ { u } ^ { A } = \\zeta ( A ( u ) ) , } \\\\ { x _ { u } ^ { t } = [ x _ { u } ^ { O , t } ; x _ { u } ^ { A } ] , ~ } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            380,
+            284,
+            617,
+            325
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $[ . ]$ denotes concatenation. We use $\\theta _ { \\Phi } , \\theta _ { \\zeta }$ to denote the weights of embedding functions. ",
+        "bbox": [
+            168,
+            328,
+            787,
+            344
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The propagation model is described in Section 2.2. We recap the propagation model here briefly: Initial hidden state for node $u$ is denoted as $h _ { u } ^ { t , 0 }$ , which are initialized from hidden states from the last timestep $h _ { u } ^ { t - 1 , T }$ or simply zeros. $\\tau$ internal propagation steps are performed for each timestep, during each step (denoted as $\\tau \\leq \\tau \\}$ ) of which, every node sends messages to its neighboring nodes, and aggregates the received messages. $h _ { u } ^ { t , \\tau + 1 }$ is calculated by an update function that takes in $h _ { u } ^ { t , \\tau }$ , node input feature $x _ { u } ^ { t }$ and aggregated message $m _ { u } ^ { t , \\tau }$ . We use summation as the aggregation function and a GRU (Chung et al., 2014) as the update function. ",
+        "bbox": [
+            173,
+            349,
+            826,
+            448
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For the output model, we define the collection of controller nodes as $\\mathcal { F }$ , and define Gaussian distributions on each node’s controller as follows: ",
+        "bbox": [
+            174,
+            454,
+            823,
+            483
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5b730d26f3edd76181105190b87e3f22d2e8dd914f89528f4b03862b3474b9b5.jpg",
+        "text": "$$\n\\begin{array} { r } { \\forall u \\in \\mathcal { F } , ~ \\mu _ { u } ^ { t } = F _ { \\mu } ( h _ { u } ^ { t , T } ) , } \\\\ { \\sigma _ { u } ^ { t } = F _ { \\sigma } ( h _ { u } ^ { t , T } ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            411,
+            484,
+            586,
+            527
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\mu _ { u }$ and $\\sigma _ { u }$ are the mean and the standard deviation of the action distribution. The weights of output function are denoted as $\\theta _ { F }$ . By combining all the actions produced by each node controller, we have the policy distribution of the agent: ",
+        "bbox": [
+            174,
+            529,
+            826,
+            571
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f8662e7836047842ccef9704cd260e2535be5dedc6dbbf51db9c472f354126ca.jpg",
+        "text": "$$\n\\pi ( a ^ { t } | s ^ { t } ) = \\prod _ { u \\in \\mathcal { F } } \\pi _ { u } ( a _ { u } ^ { t } | s ^ { t } ) = \\prod _ { u \\in \\mathcal { F } } \\frac { 1 } { \\sqrt { 2 \\pi ( \\sigma _ { u } ^ { t } ) ^ { 2 } } } \\mathrm { e x p } \\left( \\frac { ( a _ { u } ^ { t } - \\mu _ { u } ^ { t } ) ^ { 2 } } { 2 ( \\sigma _ { u } ^ { t } ) ^ { 2 } } \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            282,
+            575,
+            715,
+            616
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We optimize $\\pi ( \\boldsymbol { a } ^ { t } | \\boldsymbol { s } ^ { t } )$ with PPO, the details of which are provided in Appendix A. ",
+        "bbox": [
+            174,
+            621,
+            709,
+            636
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.3 GRAPH MUTATION WITH UNCERTAINTY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            651,
+            493,
+            666
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Between generations, the graphs evolve from parents to children. We allow the following basic operations as the mutation primitives on the parent’s graph $\\mathcal { G }$ : ",
+        "bbox": [
+            171,
+            678,
+            823,
+            707
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "$\\mathcal { M } _ { 1 }$ , Add-Node: In the $\\mathcal { M } _ { 1 }$ (Add-Node) operation, the growing of a new body part is done by sampling a node $v \\in V$ from the parent, and append a new node $u$ to it. We randomly initialize $u$ ’s attributes from an uniform distribution in the attribute space. ",
+        "bbox": [
+            174,
+            713,
+            825,
+            756
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "$\\mathcal { M } _ { 2 }$ , Add-Graph: The $\\mathcal { M } _ { 2 }$ (Add-Graph) operation allows for faster evolution by reusing the subtrees in the graph with good functionality. We sample a sub-graph or leaf node $\\bar { \\mathcal { G } } ^ { \\prime } = ( \\bar { V ^ { \\prime } } , E ^ { \\prime } , A ^ { \\prime } )$ from the current graph, and a placement node $u \\in V ( { \\mathcal { G } } )$ to which to append $\\mathcal { G } ^ { \\prime }$ . We randomly mirror the attributes of the root node in $\\mathcal { G } ^ { \\prime }$ to incorporate a symmetry prior. ",
+        "bbox": [
+            174,
+            761,
+            825,
+            819
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "$\\mathcal { M } _ { 3 }$ , Del-Graph: The process of removing body parts is defined as $\\mathcal { M } _ { 3 }$ (Del-Graph) operation. In this operation, a sub-graph $\\mathcal { G } ^ { \\prime }$ from $\\mathcal { G }$ is sampled and removed from $\\mathcal { G }$ . ",
+        "bbox": [
+            174,
+            824,
+            823,
+            853
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "$\\mathcal { M } _ { 4 }$ , Pert-Graph: In the $\\mathcal { M } _ { 4 }$ (Pert-Graph) operation, we randomly sample a sub-graph $\\mathcal { G } ^ { \\prime }$ and recursively perturb the parameter of each node $u \\in V ( \\mathcal { G } ^ { \\prime } )$ by adding Gaussian noise to $A ( u )$ . ",
+        "bbox": [
+            176,
+            859,
+            823,
+            888
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We visualize a pair of example fish in Figure 1. The fish in the top-right is mutated from the fish in the top-left by applying $\\mathcal { M } _ { 1 }$ . The new node (2) is colored magenta in the figure. To mutate each new candidate graph, we sample the operation $\\mathcal { M }$ and apply $\\mathcal { M }$ on $\\mathcal { G }$ as ",
+        "bbox": [
+            173,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            614,
+            118
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/abc2d2f6ee2a05868fa1d4ae70119ab76f19f5a93467c49ec3c8c2e5529461bc.jpg",
+        "text": "$$\n\\mathcal { G } ^ { \\prime } = \\mathcal { M } ( \\mathcal { G } ) , \\mathrm { w h e r e } \\mathcal { M } \\in \\{ \\mathcal { M } _ { l } , l = 1 , 2 , 3 , 4 \\} , \\ : \\mathrm { P } ( \\mathcal { M } = \\mathcal { M } _ { l } ) = p _ { m } ^ { l } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            276,
+            128,
+            725,
+            147
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "$p _ { m } ^ { l }$ is the probability of sampling each operation with $\\begin{array} { r } { \\sum _ { l } p _ { m } ^ { l } = 1 } \\end{array}$ ",
+        "bbox": [
+            174,
+            156,
+            607,
+            174
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To facilitate evolution, we want to avoid wasting computation resources on species with low expected fitness, while encouraging NGE to test species with high uncertainty. We again employ a GNN to predict the fitness of the graph $\\mathcal { G }$ , denoted as $\\xi _ { P } ( \\mathcal G )$ . The weights of this GNN are denoted as $\\psi$ . In particular, we predict the AF score with a similar propagation model as our policy network, but the observation feature is only $x _ { u } ^ { A }$ , i.e., the embedding of the attributes. The output model is a graph-level output (as opposed to node-level used in our policy), regressing to the score $\\xi$ . After each generation, we train the regression model using the L2 loss. ",
+        "bbox": [
+            173,
+            179,
+            825,
+            276
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "However, pruning the species greedily may easily overfit the model to the existing species since there is no modeling of uncertainty. We thus propose Graph Mutation with Uncertainty (GM-UC) based on Thompson Sampling to balance between exploration and exploitation. We denote the dataset of past species and their AF score as $\\mathcal { D }$ . GM-UC selects the best graph candidates by considering the posterior distribution of the surrogate $P \\left( \\psi | \\mathcal { D } \\right)$ : ",
+        "bbox": [
+            173,
+            282,
+            825,
+            353
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5fbe75e1715723537d3cc5ab0feb06720549c0fe8fddc1104abd3e211158cba1.jpg",
+        "text": "$$\n\\mathcal { G } ^ { * } = \\arg \\operatorname* { m a x } _ { \\mathcal { G } } \\mathbb { E } _ { P \\left( \\psi \\left| \\mathcal { D } \\right. \\right]} \\left[ \\xi _ { P } \\left( \\mathcal { G } \\right| \\psi \\right)  .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            377,
+            363,
+            620,
+            387
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Instead of sampling the full model with $\\widetilde { \\psi } \\sim P \\left( \\psi | \\mathcal { D } \\right)$ , we follow Gal & Ghahramani (2016) and perform dropout during inference, which can be viewed as an approximate sampling from the model posterior. At the end of each generation, we randomly mutate ${ \\mathcal { C } } \\geq { \\mathcal { N } }$ new species from surviving species. We then sample a single dropout mask for the surrogate model and only keep $\\mathcal { N }$ species with highest $\\xi _ { P }$ . The details of GM-UC are given in Appendix F. ",
+        "bbox": [
+            173,
+            398,
+            825,
+            472
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.4 RAPID ADAPTATION USING POLICY SHARING ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            492,
+            529,
+            506
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To leverage the transferability of GNNs across different graphs, we propose Policy Sharing (PS) to reuse old weights from parent species. The weights of a species in NGE are as follows: ",
+        "bbox": [
+            174,
+            518,
+            826,
+            547
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/faf480d8a16dc00f52d1adbc178728c0380a527892c4d2ba88a619138158f2d8.jpg",
+        "text": "$$\n\\theta _ { G } = ( \\theta _ { \\Phi } , \\theta _ { \\zeta } , \\theta _ { M } , \\theta _ { U } , \\theta _ { F } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            406,
+            559,
+            589,
+            575
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $\\theta _ { \\Phi } , \\theta _ { \\zeta } , \\theta _ { M } , \\theta _ { U } , \\theta _ { F }$ are the weights for the models we defined earlier in Section 3.2 and 2.2. Since our policy network is based on GNNs, as we can see from Figure 1, model weights of different graphs share the same cardinality (shape). A different graph will only alter the paths of message propagation. With PS, new species are provided with a strong weight initialization, and the evolution will less likely be dominated by species that are more ancient in the genealogy tree. ",
+        "bbox": [
+            173,
+            585,
+            825,
+            656
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Previous approaches including naive evolutionary structure search (ESS-Sims) (Sims, 1994) or random graph search (RGS) utilize human-engineered one-layer neural network or a fully connected network, which cannot reuse controllers once the graph structure is changed, as the parameter space for $\\theta$ might be different. And even when the parameters happen to be of the same shape, transfer learning with unstructured policy controllers is still hardly successful (Rajeswaran et al., 2017). We denote the old species in generation $j$ , and its mutated species with different topologies as $( \\theta _ { B } ^ { j } , \\mathcal { G } )$ , $( \\theta _ { B } ^ { j + 1 } , \\mathcal { G } ^ { \\prime } )$ in baseline algorithm ESS-Sims and RGS, and $( \\theta _ { G } ^ { j } , \\mathcal { G } )$ , $( \\theta _ { G } ^ { j + 1 } , \\mathcal { G } ^ { \\prime } )$ for NGE. We also denote the network initialization scheme for fully-connected networks as $\\boldsymbol { B }$ . We show the parameter reuse between generations in Table 1. ",
+        "bbox": [
+            173,
+            661,
+            826,
+            792
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/0eeaf6a4c55774ae2724b9f6591746ec9bf90c19b7ebf6027d2ab3f818dad672.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Algorithm</td><td rowspan=1 colspan=1>Mutation</td><td rowspan=1 colspan=1>Parameter Space</td><td rowspan=1 colspan=1>Policy Initialization</td></tr><tr><td rowspan=1 colspan=1>ESS-Sims, RGSNGE</td><td rowspan=1 colspan=1>g→g&#x27;g→g&#x27;</td><td rowspan=1 colspan=1>{0B(9)}n {0B(S&#x27;)}=0{0G(9)}={0G(S&#x27;)}</td><td rowspan=1 colspan=1>B(&#x27;),， 0 not reused01</td></tr></table>",
+        "bbox": [
+            189,
+            809,
+            808,
+            877
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Table 1: Parameter reuse between species and its mutated children if the topologies are different. ",
+        "bbox": [
+            181,
+            886,
+            812,
+            901
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/38bc5764a077404c9112cc83437462191878af34cc741069550675015886ee62.jpg",
+        "image_caption": [
+            "Figure 2: The performance of the graph search for RGS, ES and NGE. The figures on are the example creatures obtained from each of the method. The graph structure next to the figure are the corresponding graph structure. We included the original species for reference. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            99,
+            823,
+            196
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            277,
+            326,
+            292
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this section, we demonstrate the effectiveness of NGE on various evolution tasks. In particular, we evaluate both, the most challenging problem of searching for the optimal body structure from scratch in Section 4.1, and also show a simpler yet useful problem where we aim to optimize humanengineered species in Section 4.2 using NGE. We also provide an ablation study on GM-UC in Section 4.3, and an ablation study on computational cost or generation size in Section 4.4. ",
+        "bbox": [
+            174,
+            310,
+            825,
+            381
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Our experiments are simulated with MuJoCo. We design the following environments to test the algorithms. Fish Env: In the fish environment, graph consists of ellipsoids. The reward is the swimming-speed along the $y$ -direction. We denote the reference human-engineered graph (Tassa et al., 2018) as $\\mathcal { G } _ { F }$ . Walker Env: We also define a 2D environment walker constructed by cylinders, where the goal is to move along $x$ -direction as fast as possible. We denote the reference humanengineered walker as $\\mathcal { G } _ { W }$ and cheetah as $\\mathcal { G } _ { C }$ (Tassa et al., 2018). To validate the effectiveness of NGE, baselines including previous approaches are compared. We do a grid search on the hyper-parameters as summarized in Appendix E, and show the averaged curve of each method. The baselines are introduced as follows: ",
+        "bbox": [
+            174,
+            387,
+            825,
+            512
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "ESS-Sims: This method was proposed in (Sims, 1994), and applied in (Cheney et al., 2014; Taylor, 2017), which has been the most classical and successful algorithm in automatic robotic design. In the original paper, the author uses evolutionary strategy to train a human-engineered one layer neural network, and randomly perturbs the graph after each generation. With the recent progress of robotics and reinforcement learning, we replace the network with a 3-layer Multilayer perceptron and train it with PPO instead of evolutionary strategy. ",
+        "bbox": [
+            174,
+            518,
+            825,
+            603
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "ESS-Sims-AF: In the original ESS-Sims, amortized fitness is not used. Although amortized fitness could not be fully applied, it could be applied among species with the same topology. We name this variant as ESS-Sims-AF. ",
+        "bbox": [
+            174,
+            609,
+            825,
+            652
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "ESS-GM-UC: ESS-GM-UC is a variant of ESS-Sims-AF, which combines GM-UC. The goal is to explore how GM-UC affects the performance without the use of a structured model like GNN. ",
+        "bbox": [
+            173,
+            659,
+            821,
+            688
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "ESS-BodyShare: We also want to answer the question of whether GNN is indeed needed. We use both an unstructured models like MLP, as well as a structured model by removing the message propagation model. ",
+        "bbox": [
+            174,
+            694,
+            825,
+            736
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "RGS: In the Random Graph Search (RGS) baseline, a large amount of graphs are generated randomly.   \nRGS focuses on exploiting given structures, and does not utilize evolution to generate new graphs. ",
+        "bbox": [
+            173,
+            743,
+            825,
+            772
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.1 EVOLUTION TOPOLOGY SEARCH ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            785,
+            444,
+            799
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this experiment, the task is to evolve the graph and the controller from scratch. For both fish and walker, species are initialized as random $( { \\mathcal { G } } , \\theta )$ . Computation cost is often a concern among structure search problems. In our comparison results, for fairness, we allocate the same computation budget to all methods, which is approximately 12 hours on a $\\mathtt { E C 2 \\ m 4 . 1 6 \\times 1 a r g e }$ cluster with 64 cores for one session. A grid search over the hyper-parameters is performed (details in Appendix E). The averaged curves from different runs are shown in Figure 2. In both fish and walker environments, NGE is the best model. We find RGS is not able to efficiently search the space of $\\mathcal { G }$ even after evaluating 12, 800 different graphs. The performance of ESS-Sims grows faster for the earlier generations, but is significantly worse than our method in the end. The use of AF and GM-UC on ESS-Sims can improve the performance by a large margin, which indicates that the sub-modules in NGE are effective. By looking at the generated species, ESS-Sims and its variants overfit to local species that dominate the rest of generations. The results of ESS-BodyShare indicates that, the use of structured graph models without message passing might be insufficient in environments that require global features, for example, walker. ",
+        "bbox": [
+            174,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/5e50d9c050c8d569952dde06bce8d1d51e7eca8d9b2cb77d12af4f9fb2cac2e7.jpg",
+        "image_caption": [
+            "Figure 3: The genealogy tree generated using NGE for fish. The number next to the node is the reward (the averaged speed of the fish). For better visualization, we down-sample genealogy sub-chain of the winning species. NGE agents gradually grow symmetrical side-fins. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            240,
+            99,
+            754,
+            273
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/9b433e8161c629493c0b84edc2c426bbe01e6993718cae2b5d395a7a563768e0.jpg",
+        "image_caption": [
+            "Figure 4: Fine-tuning results on different creatures compared with baseline where structure is fixed. The figures included the species looking from 2 different angles. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            214,
+            344,
+            784,
+            474
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            542,
+            825,
+            627
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "To better understand the evolution process, we visualize the genealogy tree of fish using our model in Figure 3. Our fish species gradually generates three fins with preferred $\\{ A ( u ) \\}$ , with two side-fins symmetrical about the fish torso, and one tail-fin lying in the middle line. We obtain similar results for walker, as shown in Appendix C. To the best of our knowledge, our algorithm is the first to automatically discover kinematically plausible robotic graph structures. ",
+        "bbox": [
+            174,
+            633,
+            825,
+            704
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.2 FINE-TUNING SPECIES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            722,
+            370,
+            737
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Evolving every species from scratch is costly in practice. For many locomotion control tasks, we already have a decent human-engineered robot as a starting point. In the fine-tuning task, we verify the ability of NGE to improve upon the human-engineered design. We showcase both, unconstrained experiments with NGE where the graph $( V , E , A )$ is fine-tuned, and constrained fine-tuning experiments where the topology of the graph is preserved and only the node attributes $\\{ A ( u ) \\}$ are fine-tuned. In the baseline models, the graph $( V , E , A )$ is fixed, and only the controllers are trained. We can see in Figure 4 that when given the same wall-clock time, it is better to co-evolve the attributes and controllers with NGE than only training the controllers. ",
+        "bbox": [
+            174,
+            750,
+            825,
+            861
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The figure shows that with NGE, the cheetah gradually transforms the forefoot into a claw, the 3D-fish rotates the pose of the side-fins and tail, and the 2D-walker evolves bigger feet. In general, unconstrained fine-tuning with NGE leads to better performance, but not necessarily preserves the initial structures. ",
+        "bbox": [
+            176,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/5fbb41d8252c34ce241a6c560a063ef4faa5d6f1f740b48a07d2a82c2d37c501.jpg",
+        "image_caption": [
+            "Figure 5: Results of ablation study, NGE without uncertainty results and rapid evolution during experiments. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            200,
+            102,
+            790,
+            253
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.3 GREEDY SEARCH V.S. EXPLORATION UNDER UNCERTAINTY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            323,
+            629,
+            337
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We also investigate the performance of NGE with and without Graph Mutation with Uncertainty, whose hyper-parameters are summarized in Appendix E. In Figure 5a, we applied GM-UC to the evolution graph search task. The final performance of the GM-UC outperforms the baseline on both fish and walker environments. The proposed GM-UC is able to better explore the graph space, showcasing its importance. ",
+        "bbox": [
+            174,
+            349,
+            826,
+            419
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.4 COMPUTATION COST AND GENERATION SIZE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            438,
+            529,
+            452
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We also investigate how the generation size $\\mathcal { N }$ affect the final performance of NGE. We note that as we increase the generation size and the computing resources, NGE achieves marginal improvement on the simple Fish task. A NGE session with 16-core m5.4xlarge $\\$ 0.768$ per Hr) AWS machine can achieve almost the same performance with 64-core m4.16xlarge $\\$ 3.20$ per Hr) in Fish environment in the same wall-clock time. However, we do notice that there is a trade off between computational resources and performance for the more difficult task. In general, NGE is effective even when the computing resources are limited and it significantly outperforms RGS and ES by using only a small generation size of 16. ",
+        "bbox": [
+            174,
+            465,
+            825,
+            577
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            599,
+            310,
+            614
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we introduced NGE, an efficient graph search algorithm for automatic robot design that co-evolves the robot design graph and its controllers. NGE greatly reduces evaluation cost by transferring the learned GNN-based control policy from previous generations, and better explores the search space by incorporating model uncertainties. Our experiments show that the search over the robotic body structures is challenging, where both random graph search and evolutionary strategy fail to discover meaning robot designs. NGE significantly outperforms the naive approaches in both the final performance and computation time by an order of magnitude, and is the first algorithm that can discovers graphs similar to carefully hand-engineered design. We believe this work is an important step towards automated robot design, and may show itself useful to other graph search problems. ",
+        "bbox": [
+            174,
+            631,
+            825,
+            757
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgements Partially supported by Samsung and NSERC. We also thank NVIDIA for their donation of GPUs. ",
+        "bbox": [
+            174,
+            777,
+            823,
+            806
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            829,
+            285,
+            844
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Trapit Bansal, Jakub Pachocki, Szymon Sidor, Ilya Sutskever, and Igor Mordatch. Emergent complexity via multi-agent competition. arXiv preprint arXiv:1710.03748, 2017. ",
+        "bbox": [
+            174,
+            854,
+            825,
+            882
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Joan Bruna, Wojciech Zaremba, Arthur Szlam, and Yann LeCun. Spectral networks and locally connected networks on graphs. ICLR, 2014. ",
+        "bbox": [
+            176,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Roberto Calandra, André Seyfarth, Jan Peters, and Marc Peter Deisenroth. Bayesian optimization for learning gaits under uncertainty. Annals of Mathematics and Artificial Intelligence, 76(1-2):5–23, 2016. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            145
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nick Cheney, Robert MacCurdy, Jeff Clune, and Hod Lipson. Unshackling evolution: Evolving soft robots with multiple materials and a powerful generative encoding. ACM SIGEVOlution, 7(1): 11–23, 2014. ",
+        "bbox": [
+            173,
+            155,
+            823,
+            196
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kurtland Chua, Roberto Calandra, Rowan McAllister, and Sergey Levine. Deep reinforcement learning in a handful of trials using probabilistic dynamics models. arXiv preprint arXiv:1805.12114, 2018. ",
+        "bbox": [
+            174,
+            207,
+            826,
+            248
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "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,
+            257,
+            823,
+            287
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Michaël Defferrard, Xavier Bresson, and Pierre Vandergheynst. Convolutional neural networks on graphs with fast localized spectral filtering. In NIPS, 2016. ",
+        "bbox": [
+            173,
+            295,
+            823,
+            325
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Paul Drews, Grady Williams, Brian Goldfain, Evangelos A Theodorou, and James M Rehg. Aggressive deep driving: Combining convolutional neural networks and model predictive control. In Conference on Robot Learning, pp. 133–142, 2017. ",
+        "bbox": [
+            173,
+            333,
+            826,
+            377
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "David Duff, Mark Yim, and Kimon Roufas. Evolution of polybot: A modular reconfigurable robot. In Proc. of the Harmonic Drive Intl. Symposium, Nagano, Japan, 2001. ",
+        "bbox": [
+            174,
+            385,
+            825,
+            415
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "David K Duvenaud, Dougal Maclaurin, Jorge Iparraguirre, Rafael Bombarell, Timothy Hirzel, Alán Aspuru-Guzik, and Ryan P Adams. Convolutional networks on graphs for learning molecular fingerprints. In NIPS, 2015. ",
+        "bbox": [
+            174,
+            422,
+            826,
+            467
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yarin Gal and Zoubin Ghahramani. Dropout as a bayesian approximation: Representing model uncertainty in deep learning. In international conference on machine learning, pp. 1050–1059, 2016. ",
+        "bbox": [
+            174,
+            474,
+            826,
+            517
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nicolas Heess, Srinivasan Sriram, Jay Lemmon, Josh Merel, Greg Wayne, Yuval Tassa, Tom Erez, Ziyu Wang, Ali Eslami, Martin Riedmiller, et al. Emergence of locomotion behaviours in rich environments. arXiv preprint arXiv:1707.02286, 2017. ",
+        "bbox": [
+            174,
+            526,
+            823,
+            570
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Mikael Henaff, Joan Bruna, and Yann LeCun. Deep convolutional networks on graph-structured data. arXiv preprint arXiv:1506.05163, 2015. ",
+        "bbox": [
+            171,
+            578,
+            825,
+            608
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Michał Joachimczak, Reiji Suzuki, and Takaya Arita. Fine grained artificial development for bodycontroller coevolution of soft-bodied animats. Artificial life, 14:239–246, 2014. ",
+        "bbox": [
+            171,
+            616,
+            825,
+            646
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Thomas N Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. ICLR, 2017. ",
+        "bbox": [
+            171,
+            654,
+            825,
+            683
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. In Advances in neural information processing systems, pp. 1097–1105, 2012. ",
+        "bbox": [
+            176,
+            691,
+            826,
+            734
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Christopher G Langton. Artificial life: An overview. Mit Press, 1997. ",
+        "bbox": [
+            174,
+            743,
+            629,
+            760
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Wei-Po Lee. An evolutionary system for automatic robot design. In Systems, Man, and Cybernetics, 1998. 1998 IEEE International Conference on, volume 4, pp. 3477–3482. IEEE, 1998. ",
+        "bbox": [
+            174,
+            767,
+            826,
+            796
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yujia Li, Daniel Tarlow, Marc Brockschmidt, and Richard Zemel. Gated graph sequence neural networks. arXiv preprint arXiv:1511.05493, 2015. ",
+        "bbox": [
+            173,
+            805,
+            825,
+            835
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hanxiao Liu, Karen Simonyan, Oriol Vinyals, Chrisantha Fernando, and Koray Kavukcuoglu. Hierarchical representations for efficient architecture search. arXiv preprint arXiv:1711.00436, 2017. ",
+        "bbox": [
+            174,
+            843,
+            826,
+            886
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Melanie Mitchell and Stephanie Forrest. Genetic algorithms and artificial life. Artificial life, 1(3): 267–289, 1994. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Alex Graves, Ioannis Antonoglou, Daan Wierstra, and Martin Riedmiller. Playing atari with deep reinforcement learning. arXiv preprint arXiv:1312.5602, 2013. ",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Volodymyr Mnih, Adria Puigdomenech Badia, Mehdi Mirza, Alex Graves, Timothy Lillicrap, Tim Harley, David Silver, and Koray Kavukcuoglu. Asynchronous methods for deep reinforcement learning. In International Conference on Machine Learning, pp. 1928–1937, 2016. ",
+        "bbox": [
+            176,
+            155,
+            823,
+            198
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Anusha Nagabandi, Gregory Kahn, Ronald S Fearing, and Sergey Levine. Neural network dynamics for model-based deep reinforcement learning with model-free fine-tuning. arXiv preprint arXiv:1708.02596, 2017. ",
+        "bbox": [
+            174,
+            207,
+            823,
+            250
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ferrante Neri. Memetic compact differential evolution for cartesian robot control. IEEE Computational Intelligence Magazine, 5(2):54–65, 2010. ",
+        "bbox": [
+            173,
+            257,
+            823,
+            287
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Hieu Pham, Melody Y Guan, Barret Zoph, Quoc V Le, and Jeff Dean. Efficient neural architecture search via parameter sharing. arXiv preprint arXiv:1802.03268, 2018. ",
+        "bbox": [
+            173,
+            295,
+            823,
+            325
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Aravind Rajeswaran, Kendall Lowrey, Emanuel V Todorov, and Sham M Kakade. Towards generalization and simplicity in continuous control. In Advances in Neural Information Processing Systems, pp. 6553–6564, 2017. ",
+        "bbox": [
+            173,
+            333,
+            825,
+            376
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy optimization algorithms. arXiv preprint arXiv:1707.06347, 2017. ",
+        "bbox": [
+            173,
+            385,
+            823,
+            414
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Karl Sims. Evolving virtual creatures. In Proceedings of the 21st annual conference on Computer graphics and interactive techniques, pp. 15–22. ACM, 1994. ",
+        "bbox": [
+            174,
+            422,
+            823,
+            452
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jasper Snoek, Hugo Larochelle, and Ryan P Adams. Practical bayesian optimization of machine learning algorithms. In Advances in neural information processing systems, pp. 2951–2959, 2012. ",
+        "bbox": [
+            173,
+            460,
+            825,
+            489
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kenneth O Stanley and Risto Miikkulainen. Evolving neural networks through augmenting topologies. Evolutionary computation, 10(2):99–127, 2002. ",
+        "bbox": [
+            173,
+            498,
+            823,
+            527
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Luc Steels. The artificial life roots of artificial intelligence. Artificial life, 1(1_2):75–110, 1993. ",
+        "bbox": [
+            169,
+            535,
+            799,
+            551
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yuval Tassa, Tom Erez, and Emanuel Todorov. Synthesis and stabilization of complex behaviors through online trajectory optimization. In Intelligent Robots and Systems (IROS), 2012 IEEE/RSJ International Conference on, pp. 4906–4913. IEEE, 2012. ",
+        "bbox": [
+            173,
+            559,
+            823,
+            603
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yuval Tassa, Yotam Doron, Alistair Muldal, Tom Erez, Yazhe Li, Diego de Las Casas, David Budden, Abbas Abdolmaleki, Josh Merel, Andrew Lefrancq, et al. Deepmind control suite. arXiv preprint arXiv:1801.00690, 2018. ",
+        "bbox": [
+            174,
+            611,
+            826,
+            655
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tim Taylor. Evolution in virtual worlds. arXiv preprint arXiv:1710.06055, 2017. ",
+        "bbox": [
+            173,
+            662,
+            705,
+            679
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Emanuel Todorov, Tom Erez, and Yuval Tassa. Mujoco: A physics engine for model-based control. In Intelligent Robots and Systems (IROS), 2012 IEEE/RSJ International Conference on, pp. 5026– 5033. IEEE, 2012. ",
+        "bbox": [
+            173,
+            686,
+            828,
+            729
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Li Wan, Matthew Zeiler, Sixin Zhang, Yann Le Cun, and Rob Fergus. Regularization of neural networks using dropconnect. In International Conference on Machine Learning, pp. 1058–1066, 2013. ",
+        "bbox": [
+            173,
+            738,
+            825,
+            780
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tingwu Wang, Renjie Liao, Jimmy Ba, and Sanja Fidler. Nervenet: Learning structured policy with graph neural networks. In ICLR, 2018. ",
+        "bbox": [
+            171,
+            790,
+            823,
+            820
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Barret Zoph and Quoc V Le. Neural architecture search with reinforcement learning. arXiv preprint arXiv:1611.01578, 2016. ",
+        "bbox": [
+            171,
+            828,
+            823,
+            858
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/b5211ae0f5290b26b5598c34119199588fefd60fcfea62b58bcedd35e02f549a.jpg",
+        "image_caption": [
+            "Figure 6: In this figure, we show the computation graph of NerveNet+ $^ +$ . At each timestep, every node in the graph updates its hidden state by absorbing the messages as well as the input feature. The output function takes the hidden states as input and outputs the controller (or policy) of the agent. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            103,
+            821,
+            303
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A DETAILS OF NERVENET $^ { + + }$ ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            386,
+            433,
+            401
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Similar to NerveNet, we parse the agent into a graph, where each node in the graph corresponds to the physical body part of the agents. For example, the fish in Figure 1 can be parsed into a graph of five nodes, namely the torso (0), left-fin (1), right-fin (2), and tail-fin bodies (3, 4). By replacing MLP with NerveNet, the learnt policy has much better performance in terms of robustness and the transfer learning ability. We here propose minor but effective modifications to Wang et al. (2018), and refer to this model as NerveNet++. ",
+        "bbox": [
+            173,
+            417,
+            825,
+            501
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "In the original NerveNet, at every timestep, several propagation steps need to be performed such that every node is able to receive global information before producing the control signal. This is time and memory consuming, with the minimum number of propagation steps constrained by the depth of the graph. ",
+        "bbox": [
+            174,
+            507,
+            825,
+            564
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Since the episode of each game usually lasts for several hundred timesteps, it is computationally expensive and ineffective to build the full back-propagation graph. Inspired by Mnih et al. (2016), we employ the truncated graph back-propagation to optimize the policy. NerveNet+ $^ { \\cdot + }$ is suitable for an evolutionary search or population-based optimization, as it brings speed-up in wall-clock time, and decreases the amount of memory usage. ",
+        "bbox": [
+            174,
+            570,
+            825,
+            640
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Therefore in NerveNe $^ { + + }$ , we propose a propagation model with the memory state, where each node updates its hidden state by absorbing the input feature and a message with time. The number of propagation steps is no longer constrained by the depth of the graph, and in back-propagation, we save memory and time consumption with truncated computation graph. ",
+        "bbox": [
+            173,
+            647,
+            825,
+            704
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "The computational performance evaluation is provided in Appendix B. NerveNet+ $^ +$ model is trained by the PPO algorithm Schulman et al. (2017); Heess et al. (2017), ",
+        "bbox": [
+            174,
+            710,
+            823,
+            739
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "B OPTIMIZATION WITH TRUNCATED BACKPROPAGATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            758,
+            663,
+            775
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "During training, the agent generates the rollout data by sampling from the distribution $a _ { t } \\sim \\pi ( a _ { t } | s _ { t } )$ and stores the training data of $\\mathcal { D } = \\{ a ^ { t } , s ^ { t } , \\{ h _ { u } ^ { t , \\tau = 0 } \\} \\}$ . To train the reinforcement learning agents with memory, the original training objective is ",
+        "bbox": [
+            176,
+            790,
+            825,
+            833
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4d72c46292f80e4544f7ebf20f13185a81cde2ca29941fd15fe7a08b2667fb47.jpg",
+        "text": "$$\nJ ( \\theta ) = \\mathbb { E } _ { \\pi } \\left[ \\sum _ { t = 0 } ^ { \\infty } \\gamma ^ { t } r ( s ^ { t } , a ^ { t } , \\{ h _ { u } ^ { t , \\tau = 0 } \\} ) \\right] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            364,
+            837,
+            632,
+            880
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "where we denote the whole update model as $H$ and ",
+        "bbox": [
+            173,
+            883,
+            511,
+            898
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4abb1ced89bffbe22c5457ceedf9f71de01c40ae5763e6ac3818d7bc349bb018.jpg",
+        "text": "$$\nh _ { u } ^ { t + 1 , \\tau = 0 } = H ( \\{ h _ { v } ^ { t , \\tau = 0 } \\} , s ^ { t } , a ^ { t } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            390,
+            902,
+            607,
+            921
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/0cf94e39d660ebd29877df92792868564f3a09bea210994b1c774e00bd3db98f.jpg",
+        "image_caption": [
+            "Figure 7: In these two figures, we show that to reach similar performance, NerveNet+ $^ +$ took shorter time comparing to original NerveNet. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            104,
+            800,
+            303
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The memory state $h _ { u } ^ { t + 1 , \\tau }$ depends on the previous actions, observations, and states. Therefore, the full back-propagation graph will be the same length as the episode length, which is very computationally intensive. The intuition from the authors in Mnih et al. (2016) is that, for the RL agents, the dependency of the agents on timesteps that are far-away from the current timestep is limited. Thus, negligible accuracy of the gradient estimator will be lost if we truncate the back-propagation graph. We define a back-propagation length $\\Gamma$ , and optimize the following objective function instead: ",
+        "bbox": [
+            173,
+            372,
+            826,
+            457
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0cc17035cbd39f575923666b1d481b761bc5e85d9d42ffc592d94a63ff7b2855.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\quad J _ { T } ( \\theta ) = \\mathbb E _ { \\pi } \\left[ \\displaystyle \\sum _ { t = 0 } ^ { \\infty } \\displaystyle \\sum _ { \\kappa = 0 } ^ { \\Gamma - 1 } \\gamma ^ { t + \\kappa } r ( s _ { t + \\kappa } , a _ { t + \\kappa } , \\{ h _ { u } ^ { t , \\tau = 0 } \\} ) \\right] , \\ : \\mathrm { w h e r e } } \\\\ & { \\quad h _ { u } ^ { t + \\kappa , \\tau = 0 } = \\left\\{ \\begin{array} { l l } { H ( \\{ h _ { v } ^ { t + \\kappa - 1 , \\tau = 0 } , \\forall v \\} , s _ { t + \\kappa - 1 } , a _ { t + \\kappa - 1 } ) \\quad } & { \\kappa \\neq 0 , } \\\\ { h _ { u } ^ { t , \\tau = 0 } \\in \\mathcal D \\quad } & { \\kappa = 0 , } \\end{array} \\right. } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            272,
+            467,
+            717,
+            546
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Essentially this optimization means that we only back-propagate up to $\\Gamma$ timesteps, namely at the places where $\\kappa = 0$ , we treat the hidden state as input to the network and stop the gradient. To optimize the objective function, we follow same optimization procedure as in Wang et al. (2018), which is a variant of PPO Schulman et al. (2017), where a surrogate loss $J _ { \\mathrm { p p o } } ( \\theta )$ is optimized. We refer the readers to these papers for algorithm details. ",
+        "bbox": [
+            174,
+            555,
+            825,
+            626
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "C FULL NGE RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            648,
+            383,
+            666
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Similar to the fish genealogy tree, in Fig. 8, the simple initial walking agent evolves into a cheetah-like structure, and is able to run with high speed. We also show the species generated by NGE, ESS-Sims (ESS-Sims-AF to be more specific, which has the best performance among all ESS-Sims variants.) and RGS. ",
+        "bbox": [
+            174,
+            684,
+            825,
+            739
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "D RESETTING CONTROLLER FOR FAIR COMPETITION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            763,
+            633,
+            781
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Although amortized fitness is a better estimation of the ground-truth fitness, it is still biased. Species that appear earlier in the experiment will be trained for more updates if it survives. Indeed, intuitively, it is possible that in real nature, species that appear earlier on will dominate the generation by number, and new species are eliminated even if the new species has better fitness. Therefore, we design the experiment where we reset the weights for all species $\\theta = ( \\theta _ { \\Phi } , \\theta _ { \\zeta } , \\theta _ { M } , \\theta _ { U } , \\theta _ { F } )$ randomly. By doing this, we are forcing the species to compete fairly. From Fig 10, we notice that this method helps exploration, which leads to a higher reward in the end. However, it usually takes a longer time for the algorithm to converge. Therefore for the graph search task in Fig 2, we do not include the results with the controller-resetting. ",
+        "bbox": [
+            173,
+            797,
+            825,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/716e206836792ddab9d1fc8348ce669faab16f2ec614d74faee62e59a8209062.jpg",
+        "image_caption": [
+            "Figure 8: Our walker species gradually grows two foot-like structures from randomly initialized body graph. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            99,
+            826,
+            328
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/a406d83d3adcc19b5eac6dc93df042348580e2442eae8c5093c0f282310809d3.jpg",
+        "image_caption": [
+            "Figure 9: We present qualitative comparison between the three algorithms in the figure. Specifically, the aligned comparison between our method and naive baseline are the representative creatures at the same generation (using same computation resources). Our algorithm notably display stronger dominance in terms of its structure as well as reward. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            386,
+            823,
+            474
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/c1838debebc25ca3af12e8c06a8bc188ee90c8eab19018442aa7d90a55637911.jpg",
+        "image_caption": [
+            "Figure 10: The results of resetting controller scheme and baselines. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            338,
+            564,
+            655,
+            748
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "E HYPER-PARAMETERS SEARCHED ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            806,
+            483,
+            821
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "All methods are given equal amount of computation budget. To be more specific, the number of total timesteps generated by all species for all generations is the same for all methods. For example, if we use 10 training epochs in one generation, each of the epoch with 2000 sampled timesteps, then the computation budget allows NGE to evolve for 200 generations, where each generation has a species size of 64. For NGE, RGS, ESS-Sims-AF models in Fig 11, we run a grid search over the hyper-parameters recorded in Table 2, and Table 3, and plot the curve with the best results respectively. ",
+        "bbox": [
+            173,
+            840,
+            826,
+            924
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/e98cbe174974ebb813c4abfefabd4eabdc5fbc42014ba545dd6b2894fb925637.jpg",
+        "image_caption": [
+            "Figure 11: The results of the graph search "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            103,
+            813,
+            308
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Since the number of generations for the RGS baseline can be regarded as 1, its curve is plotted with the number of updates normalized by the computation resource as $\\mathbf { X }$ -axis. ",
+        "bbox": [
+            174,
+            361,
+            823,
+            390
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Here we show the detail figures of six baselines, which are: RGS-20, RGS-100, RGS-200, and ESS-Sims-AF-20, ESS-Sims-AF-100, ESS-Sims-AF-200. The number attached to the baseline names indicates the number of inner-loop policy training epochs. In the case of RGS-20, where more than 12800 different graphs are searched over, the average reward is still very low. Increasing the number of inner-loop training of species to 100 and 200 does not help the final performance significantly. ",
+        "bbox": [
+            173,
+            396,
+            825,
+            481
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "To test the performance with and without GM-UC, we use 64-core clusters (generations of size 64).   \nHere, the hyper-parameters are chosen to be the first value available in Table 2 and Table 3. ",
+        "bbox": [
+            174,
+            487,
+            825,
+            516
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/69f6a63ea216ce981481035abfb93affc103e151bcb303cda292dd88c030aa2e.jpg",
+        "table_caption": [
+            "Table 2: Hyperparameter grid search options. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Items</td><td>Value Tried</td></tr><tr><td>Number of Iteration Per Update Number of Species per Generation Elimination Rate Discrete Socket Timesteps per Updates</td><td>10,20,100,200 16,32,64,100 0.15, 0.20, 0.3 Yes, True 2000,4000,6000</td></tr><tr><td>Target KL Learning Rate Schedule Number of Maximum Generation</td><td>0.01 Adaptive</td></tr><tr><td>Prob of Add-Node,Add-Graph Prob of Pert-Graph Prob of Del-Graph</td><td>400 0.15</td></tr></table>",
+        "bbox": [
+            289,
+            531,
+            709,
+            753
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "F MODEL BASED SEARCH USING THOMPSON SAMPLING ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            820,
+            656,
+            838
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Thompson Sampling is a simple heuristic search strategy that is typically applied to the multi-armed bandit problem. The main idea is to select an action proportional to the probability of the action being optimal. When applied to the graph search problem, Thompson Sampling allows the search to balance the trade-off between exploration and exploitation by maximizing the expected fitness under the posterior distribution of the surrogate model. ",
+        "bbox": [
+            174,
+            853,
+            825,
+            924
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/ff9603a6a5e527410d728295197abe92075ecdfee5a80527c609767874db9922.jpg",
+        "table_caption": [
+            "Table 3: Hyperparameters grid search options for NGE. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Items</td><td>Value Tried</td></tr><tr><td>Allow Graph-Add</td><td>True, False</td></tr><tr><td>Graph Mutation with Uncertainty</td><td>True,False</td></tr><tr><td>Pruning Temperature</td><td>0.01, 0.1, 1</td></tr><tr><td>Network Structure</td><td>NerveNet,NerveNet++</td></tr><tr><td>Number Candidates before Pruning</td><td>200,400</td></tr></table>",
+        "bbox": [
+            285,
+            102,
+            714,
+            200
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Formally, Thompson Sampling selects the best graph candidates at each round according to the expected estimated fitness $\\xi _ { P }$ using a surrogate model. The expectation is taken under the posterior distribution of the surrogate $P$ (model|data): ",
+        "bbox": [
+            174,
+            251,
+            826,
+            295
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b83e3ea31a2d2f35ed7ffc50ae8ff14b20a2c275b6fa1bd82b91c9d1894ffc59.jpg",
+        "text": "$$\n\\mathcal { G } ^ { * } = \\arg \\operatorname* { m a x } _ { \\mathcal { G } } \\mathbb { E } _ { P ( \\mathrm { m o d e l } | \\mathrm { d a t a } ) } \\left[ \\xi _ { P } \\left( \\mathcal { G } | \\mathrm { m o d e l } \\right) \\right] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            351,
+            301,
+            645,
+            324
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "F.1 SURROGATE MODEL ON GRAPHS.",
+        "text_level": 1,
+        "bbox": [
+            176,
+            340,
+            442,
+            354
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Here we consider a graph neural network (GNN) surrogate model to predict the average fitness of a graph as a Gaussian distribution, namely $\\boldsymbol { P } \\left( f ( \\boldsymbol { \\mathcal { G } } ) \\right) \\ \\stackrel { \\sim } { \\sim } \\mathcal { N } \\left( \\xi _ { P } ( \\boldsymbol { \\mathcal { G } } ) , \\stackrel { \\sim } { \\sigma } ^ { 2 } ( \\boldsymbol { \\mathcal { G } } ) \\right)$ . We use a simple architecture that predicts the mean of the Gaussian from the last hidden layer activations, $h _ { W } ( { \\mathcal { G } } ) \\in$ $\\mathbb { R } ^ { D }$ , of the GNN, where $W$ are the weights in the GNN up to the last hidden layer. ",
+        "bbox": [
+            173,
+            366,
+            825,
+            424
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Greedy search. We denoted the size of dataset as $N$ . The GNN weights are trained to predict the average fitness of the graph as a standard regression task: ",
+        "bbox": [
+            173,
+            438,
+            825,
+            468
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "equation",
+        "img_path": "images/187dd85dda9307f4619dded083f00332fc27bdcdd7e7f7b00ffc62505d8a04b6.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { W , W _ { o u t } } \\frac { \\beta } { 2 } \\sum _ { n = 1 } ^ { N } \\left( \\xi ( \\mathcal { G } _ { n } ) - \\xi _ { P } ( \\mathcal { G } _ { n } ) \\right) ^ { 2 } , \\quad \\mathrm { w h e r e } \\quad \\xi _ { P } ( \\mathcal { G } _ { n } ) = W _ { o u t } ^ { T } h _ { W } ( \\mathcal { G } _ { n } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            264,
+            473,
+            736,
+            517
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 2 Greedy Search ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            541,
+            361,
+            556
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "1: Initialize generation $\\mathcal { P } ^ { 0 }$   \n2: for $j <$ maximum generations do   \n3: Collect the $( \\xi _ { i } ^ { k } , \\mathcal { G } _ { i } ^ { k } )$ from previous $k \\leq j$ generations . Update dataset   \n4: Train $W$ and $W _ { o u t }$ on $\\{ ( \\xi _ { i } ^ { k } , \\mathcal { G } _ { i } ^ { k } ) \\} _ { n = 1 } ^ { N }$ . Train GM-UC   \n5: Propose $\\mathcal { C }$ new graph $\\{ \\mathcal { G } _ { i } \\} _ { i = 1 } ^ { \\mathcal { C } }$ , ${ \\mathcal { C } } > > M$ . $\\triangleright$ Propose new candidates   \n6: Rank $\\{ \\xi _ { P } ( \\mathcal { G } _ { i } | W , W _ { o u t } ) \\} _ { i = 1 } ^ { \\mathcal { C } }$ on the proposals and pick the top $\\kappa$ . Prune candidates   \n7: Update generation $\\mathcal { P } ^ { j }$   \n8: for $m < \\mathcal N$ do $\\triangleright$ Train and evaluate each species   \n9: for $k <$ maximum parameter updates do   \n10: Train policy πGm   \n11: end for   \n12: Evaluate the fitness $\\xi ( \\mathcal { G } _ { m } , \\theta _ { m } )$   \n13: end for   \n14: end for ",
+        "bbox": [
+            176,
+            561,
+            826,
+            763
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Thompson Sampling In practice, Thompson Sampling is very similar to the previous greedy search algorithm. Instead of picking the top action according to the best model parameters, at each generation, it draws a sample of the model and takes a greedy action under the sampled model. ",
+        "bbox": [
+            174,
+            796,
+            825,
+            840
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Approximating Thompson Sampling using Dropout Performing dropout during inference can be viewed as an approximately sampling from the model posterior. At each generation, we will sample a single dropout mask for the surrogate model and rank all the proposed graphs accordingly. ",
+        "bbox": [
+            176,
+            854,
+            825,
+            897
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 3 Thompson Sampling using Bayesian Neural Networks ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            186,
+            619,
+            202
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "1: Initialize generation P0   \n2: for $j <$ maximum generations do   \n3: Collect the $( \\xi _ { i } ^ { k } , \\mathcal { G } _ { i } ^ { k } )$ from previous $k \\leq j$ generations . Update dataset   \n4: Train $W$ and $W _ { o u t }$ on $\\{ ( \\xi _ { i } ^ { k } , \\mathcal { G } _ { i } ^ { k } ) \\} _ { n = 1 } ^ { N }$ . Train GM-UC   \n5: Propose $\\mathcal { C }$ new graph $\\{ \\mathcal { G } _ { i } \\} _ { i = 1 } ^ { \\mathcal { C } } , \\mathcal { C } > > M$ . . Propose new candidates   \n6: Sample a model from the posterior of the weights.   \n7: e.g. $\\widetilde { W } , \\widetilde { W } _ { o u t } \\sim P \\left( W , W _ { o u t } | D \\right) \\approx \\mathcal { N } \\left( [ W , W _ { o u t } ] , [ W , W _ { o u t } ] \\right)$   \n8: (similar to DropConnect Wan et al. (2013))   \n9: Rank $\\{ \\xi _ { P } ( \\mathcal { G } _ { i } | \\widetilde { W } , \\widetilde { W } _ { o u t } ) \\} _ { i = 1 } ^ { \\mathcal { C } }$ on the proposals and pick the top $\\kappa$   \n10: for $m < \\mathcal N$ do $\\triangleright$ Train and evaluate each species   \n11: for $k <$ maximum parameter updates do   \n12: Train policy πGm   \n13: end for   \n14: Evaluate the fitness $\\xi ( \\mathcal { G } _ { m } , \\theta _ { m } )$   \n15: end for   \n16: end for ",
+        "bbox": [
+            178,
+            207,
+            826,
+            440
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 4 Thompson Sampling with Dropout ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            618,
+            490,
+            633
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "1: Initialize generation $\\mathcal { P } ^ { 0 }$   \n2: for $j <$ maximum generations do   \n3: Collect the $( \\xi _ { i } ^ { k } , \\mathcal { G } _ { i } ^ { k } )$ from previous $k \\leq j$ generations $\\triangleright$ Update dataset   \n4: Train $W$ and $W _ { o u t }$ on $\\{ { \\mathcal G } _ { n } , \\xi ( { \\mathcal G } _ { n } ) \\} _ { n = 1 } ^ { N }$ using dropout rate 0.5 on the inputs of the fc layers.   \n5: Propose $\\mathcal { C }$ new graph $\\{ \\mathcal { G } _ { i } \\} _ { i = 1 } ^ { \\mathcal { C } } , \\mathcal { C } > > M$ . . Propose new candidates   \n6: Sample a dropout mask $\\mathrm { m } _ { i }$ for the hidden units   \n7: Rank $\\{ \\xi _ { P } ( \\mathcal { G } _ { i } \\bar { | } W , W _ { o u t } , \\mathbf { m } _ { i } ) \\} _ { i = 1 } ^ { J }$ on the proposals and pick the top $\\kappa$   \n8: for $m < \\mathcal N$ do $\\triangleright$ Train and evaluate each species   \n9: for $k <$ maximum parameter updates do   \n10: Train policy πGm   \n11: end for   \n12: Evaluate the fitness $\\xi ( \\mathcal { G } _ { m } , \\theta _ { m } )$   \n13: end for   \n14: end for ",
+        "bbox": [
+            178,
+            637,
+            826,
+            837
+        ],
+        "page_idx": 16
+    }
+]

parse/train/ByS1VpgRZ/ByS1VpgRZ.md

@@ -0,0 +1,280 @@
+# CGANS WITH PROJECTION DISCRIMINATOR
+
+Takeru Miyato1, Masanori Koyama2 miyato@preferred.jp koyama.masanori@gmail.com 1Preferred Networks, Inc. 2Ritsumeikan University
+
+# ABSTRACT
+
+We propose a novel, projection based way to incorporate the conditional information into the discriminator of GANs that respects the role of the conditional information in the underlining probabilistic model. This approach is in contrast with most frameworks of conditional GANs used in application today, which use the conditional information by concatenating the (embedded) conditional vector to the feature vectors. With this modification, we were able to significantly improve the quality of the class conditional image generation on ILSVRC2012 (ImageNet) 1000-class image dataset from the current state-of-the-art result, and we achieved this with a single pair of a discriminator and a generator. We were also able to extend the application to super-resolution and succeeded in producing highly discriminative super-resolution images. This new structure also enabled high quality category transformation based on parametric functional transformation of conditional batch normalization layers in the generator. The code with Chainer (Tokui et al., 2015), generated images and pretrained models are available at https://github.com/pfnet-research/sngan_projection.
+
+# 1 INTRODUCTION
+
+Generative Adversarial Networks (GANs) (Goodfellow et al., 2014) are a framework to construct a generative model that can mimic the target distribution, and in recent years it has given birth to arrays of state-of-the-art algorithms of generative models on image domain (Radford et al., 2016; Salimans et al., 2016; Ledig et al., 2017; Zhang et al., 2017; Reed et al., 2016). The most distinctive feature of GANs is the discriminator $D ( { \pmb x } )$ that evaluates the divergence between the current generative distribution $p _ { G } ( \pmb { x } )$ and the target distribution $q ( { \pmb x } )$ (Goodfellow et al., 2014; Nowozin et al., 2016; Arjovsky et al., 2017). The algorithm of GANs trains the generator model by iteratively training the discriminator and generator in turn, with the discriminator acting as an increasingly meticulous critic of the current generator.
+
+Conditional GANs (cGANs) are a type of GANs that use conditional information (Mirza & Osindero, 2014) for the discriminator and generator, and they have been drawing attention as a promising tool for class conditional image generation (Odena et al., 2017), the generation of the images from text (Reed et al., 2016; Zhang et al., 2017), and image to image translation (Kim et al., 2017; Zhu et al., 2017). Unlike in standard GANs, the discriminator of cGANs discriminates between the generator distribution and the target distribution on the set of the pairs of generated samples $_ { \textbf { \em x } }$ and its intended conditional variable $\textbf {  { y } }$ . To the authors’ knowledge, most frameworks of discriminators in cGANs at the time of writing feeds the pair the conditional information $\textbf {  { y } }$ into the discriminator by naively concatenating (embedded) $\textbf {  { y } }$ to the input or to the feature vector at some middle layer (Mirza & Osindero, 2014; Denton et al., 2015; Reed et al., 2016; Zhang et al., 2017; Perarnau et al., 2016; Saito et al., 2017; Dumoulin et al., 2017a; Sricharan et al., 2017). We would like to however, take into account the structure of the assumed conditional probabilistic models underlined by the structure of the discriminator, which is a function that measures the information theoretic distance between the generative distribution and the target distribution.
+
+By construction, any assumption about the form of the distribution would act as a regularization on the choice of the discriminator. In this paper, we propose a specific form of the discriminator, a form motivated by a probabilistic model in which the distribution of the conditional variable $\textbf {  { y } }$ given $_ { \textbf { \em x } }$ is
+
+![](images/ec3520e11657fdeb608fe6e00882b71a56ec36ba76d36bdf62da06ae694f1214.jpg)  
+Figure 1: Discriminator models for conditional GANs
+
+![](images/dfbb090f2bfa4de6de0efa4df202fa420d3811aa17ffa90e01fbf8972e05b9e1.jpg)
+
+![](images/8dd2760c90cb4a9e736ee0a370b3904e4d6803c56110e65a74098a88406bba67.jpg)  
+(a) Images generated with the projection model. (left) Tibetan terrier and (right) mushroom.   
+(b) (left) Consecutive category morphing with fixed $_ { z }$ . geyser Tibetan terrier mushroom robin. (right) category morphing from Tibetan terrier to mushroom with different value of fixed $_ { z }$
+
+Figure 2: The generator trained with the projection model can generate diverse set of images. For more results, see the experiment section and the appendix section.
+
+discrete or uni-modal continuous distributions. This model assumption is in fact common in many real world applications, including class-conditional image generation and super-resolution.
+
+As we will explain in the next section, adhering to this assumption will give rise to a structure of the discriminator that requires us to take an inner product between the embedded condition vector $\textbf {  { y } }$ and the feature vector (Figure 1d). With this modification, we were able to significantly improve the quality of the class conditional image generation on 1000-class ILSVRC2012 dataset (Russakovsky et al., 2015) with a single pair of a discriminator and generator (see the generated examples in Figure 2). Also, when we applied our model of cGANs to a super-resolution task, we were able to produce high quality super-resolution images that are more discriminative in terms of the accuracy of the label classifier than the cGANs based on concatenation, as well as the bilinear and the bicubic method.
+
+# 2 THE ARCHITECTURE OF THE CGAN DISCRIMINATOR WITH A PROBABILISTIC MODEL ASSUMPTIONS
+
+Let us denote the input vector by $_ { \textbf { \em x } }$ and the conditional information by $y ^ { 1 }$ . We also denote the cGAN discriminator by $D ( \pmb { x } , \pmb { y } ; \theta ) : = \mathcal { A } ( f ( \pmb { x } , \pmb { y } ; \theta ) )$ , where $f$ is a function of $_ { \textbf { \em x } }$ and $y , \theta$ is the parameters of $f$ , and $\mathcal { A }$ is an activation function of the users’ choice. Using $q$ and $p$ to designate the true distributions and the generator model respectively, the standard adversarial loss for the
+
+discriminator is given by:
+
+$$
+\mathcal { L } ( D ) = - E _ { q ( y ) } \left[ E _ { q ( x | y ) } \left[ \log ( D ( x , y ) ) \right] \right] - E _ { p ( y ) } \left[ E _ { p ( x | y ) } \left[ \log ( 1 - D ( x , y ) ) \right] \right] ,
+$$
+
+with $\mathcal { A }$ in $D$ representing the sigmoid function. By construction, the nature of the ‘critic’ $D$ significantly affects the performance of $G$ . A conventional way of feeding $\textbf {  { y } }$ to $D$ until now has been to concatenate the vector $\textbf {  { y } }$ to the feature vector $_ { \textbf { \em x } }$ , either at the input layer (Mirza $\&$ Osindero, 2014; Denton et al., 2015; Saito et al., 2017), or at some hidden layer (Reed et al., 2016; Zhang et al., 2017; Perarnau et al., 2016; Dumoulin et al., 2017a; Sricharan et al., 2017) (see Figure 1a and Figure 1b). We would like to propose an alternative to this approach by observing the form of the optimal solution (Goodfellow et al., 2014) for the loss function, Eq. (1), can be decomposed into the sum of two log likelihood ratios:
+
+$$
+f ^ { * } ( x , y ) = \log { \frac { q ( x | y ) q ( y ) } { p ( x | y ) p ( y ) } } = \log { \frac { q ( y | x ) } { p ( y | x ) } } + \log { \frac { q ( x ) } { p ( x ) } } : = r ( y | x ) + r ( x ) .
+$$
+
+Now, we can model the log likelihood ratio $r ( \pmb { y } | \pmb { x } )$ and $r ( { \pmb x } )$ by some parametric functions $f _ { 1 }$ and $f _ { 2 }$ respectively. If we make a standing assumption that $p ( \pmb { y } | \pmb { x } )$ and $q ( \pmb { y } | \pmb { x } )$ are simple distributions like those that are Gaussian or discrete log linear on the feature space, then, as we will show, the parametrization of the following form becomes natural:
+
+$$
+f ( \pmb { x } , \pmb { y } ; \theta ) : = f _ { 1 } ( \pmb { x } , \pmb { y } ; \theta ) + f _ { 2 } ( \pmb { x } ; \theta ) = \pmb { y } ^ { \operatorname { T } } V \phi ( \pmb { x } ; \theta _ { \Phi } ) + \psi ( \phi ( \pmb { x } ; \theta _ { \Phi } ) ; \theta _ { \Psi } ) ,
+$$
+
+where $V$ is the embedding matrix of y, $, \phi ( \cdot , \theta _ { \Phi } )$ is a vector output function of $_ { \textbf { \em x } }$ , and $\psi ( \cdot , \theta _ { \Psi } )$ is a scalar function of the same $\phi ( \pmb { x } ; \theta _ { \Phi } )$ that appears in $f _ { 1 }$ (see Figure 1d). The learned parameters $\theta = \{ V , \theta _ { \Phi } , \theta _ { \Psi } \}$ are to be trained to optimize the adversarial loss. From this point on, we will refer to this model of the discriminator as projection for short. In the next section, we would like to elaborate on how we can arrive at this form.
+
+# 3 MOTIVATION BEHIND THE projection DISCRIMINATOR
+
+In this section, we will begin from specific, often recurring models and show that, with certain regularity assumption, we can write the optimal solution of the discriminator objective function in the form of (3). Let us first consider the a case of categorical variable. Assume that $y$ is a categorical variable taking a value in $\{ 1 , \ldots , C \}$ , which is often common for a class conditional image generation task. The most popular model for $p ( y | \mathbf { \boldsymbol { x } } )$ is the following log linear model:
+
+$$
+\log p ( y = c | \pmb { x } ) : = \pmb { v } _ { c } ^ { p \mathrm { T } } \phi ( \pmb { x } ) - \log Z ( \phi ( \pmb { x } ) ) ,
+$$
+
+where $\begin{array} { r } { Z ( \phi ( \pmb { x } ) ) : = \left( \sum _ { j = 1 } ^ { C } \exp \left( \pmb { v } _ { j } ^ { p \mathrm { T } } \phi ( \pmb { x } ) \right) \right) } \end{array}$ is the partition function, and $\phi : \pmb { x } \mapsto \mathbb { R } ^ { d ^ { L } }$ is the input to the final layer of the network model. Now, we assume that the target distribution $q$ can also be parametrized in this form, with the same choice of $\phi$ . This way, the log likelihood ratio would take the following form;
+
+$$
+r ( y | x ) = \log \frac { q ( y = c | x ) } { p ( y = c | x ) } = ( v _ { c } ^ { q } - v _ { c } ^ { p } ) ^ { \mathrm { T } } \phi ( x ) - ( \log Z ^ { q } ( \phi ( x ) ) - \log Z ^ { p } ( \phi ( x ) ) ) .
+$$
+
+If we make the values of $( v _ { c } ^ { q } , v _ { c } ^ { p } )$ implicit and put $\pmb { v } _ { c } : = ( \pmb { v } _ { c } ^ { q } - \pmb { v } _ { c } ^ { p } )$ , we can write $f _ { 1 } ( x , y = c ) =$ ${ \pmb v } _ { c } ^ { \mathrm { T } } \phi ( { \pmb x } )$ . Now, if we can put together the normalization constant $- \left( \log Z ^ { q } ( \phi ( { \pmb x } ) ) - \log Z ^ { p } ( \phi ( { \pmb x } ) ) \right)$ and $r ( { \pmb x } )$ into one expression $\bar { \psi } ( \phi ( { \pmb x } ) )$ , we can rewrite the equation above as
+
+$$
+f ( \pmb { x } , \pmb { y } ) : = \pmb { y } ^ { \mathrm { T } } V \phi ( \pmb { x } ) + \psi ( \phi ( \pmb { x } ) ) .
+$$
+
+by using $\textbf {  { y } }$ to denote a one-hot vector of the label $y$ and using $V$ to denote the matrix consisting of the row vectors $v _ { c }$ . Most notably, this formulation introduces the label information via an inner product, as opposed to concatenation. The form (6) is indeed the form we proposed in (3).
+
+We can also arrive at the form (3) for unimodal continuous distributions $p ( \pmb { y } | \pmb { x } )$ as well. Let $\textbf { \textit { y } } \in \ \mathbb { R } ^ { d }$ be a $d$ -dimensional continuous variable, and let us assume that conditional $q ( \pmb { y } | \pmb { x } )$ and $p ( \pmb { y } | \pmb { x } )$ are both given by Gaussian distributions, so that $q ( \pmb { y } | \pmb { x } ) = \mathcal { N } ( \pmb { y } | \pmb { \mu } _ { q } ( \pmb { x } ) , \pmb { \Lambda } _ { q } ^ { - 1 } )$ and
+
+$p ( \pmb { y } | \pmb { x } ) = \mathcal { N } ( \pmb { y } | \pmb { \mu } _ { p } ( \pmb { x } ) , \pmb { \Lambda } _ { p } ^ { - 1 } )$ where $\pmb { \mu } _ { q } ( \pmb { x } ) : = W ^ { q } \pmb { \phi } ( \pmb { x } )$ and $\mu _ { p } ( { \pmb x } ) : = W ^ { p } \phi ( { \pmb x } )$ . Then the log density ratio $r ( { \pmb y } | { \pmb x } ) = \log \big ( q ( { \pmb y } | { \pmb x } ) / p ( { \pmb y } | { \pmb x } ) \big )$ is given by:
+
+$$
+\begin{array} { r } { r ( \pmb { y } | \pmb { x } ) = \log \left( \sqrt { \frac { | \mathbf { A } _ { q } | } { | \mathbf { A } _ { p } | } } \frac { \exp ( - ( 1 / 2 ) ( \pmb { y } - \pmb { \mu } _ { q } ( \pmb { x } ) ) ^ { \mathrm { T } } \mathbf { A } _ { q } ( \pmb { y } - \pmb { \mu } _ { q } ( \pmb { x } ) ) ) } { \exp ( - ( 1 / 2 ) ( \pmb { y } - \pmb { \mu } _ { p } ( \pmb { x } ) ) ^ { \mathrm { T } } \mathbf { A } _ { p } ( \pmb { y } - \pmb { \mu } _ { p } ( \pmb { x } ) ) ) } \right) } \\ { = - \frac { 1 } { 2 } \pmb { y } ^ { \mathrm { T } } \left( \pmb { \Lambda } _ { q } - \pmb { \Lambda } _ { p } \right) \pmb { y } + \pmb { y } ^ { \mathrm { T } } ( \pmb { \Lambda } _ { q } W ^ { q } - \pmb { \Lambda } _ { p } W ^ { p } ) \phi ( \pmb { x } ) + \psi ( \phi ( \pmb { x } ) ) , } \end{array}
+$$
+
+where $\psi ( \phi ( { \pmb x } ) )$ represents the terms independent of $\textbf {  { y } }$ . Now, if we assume that $\pmb { \Lambda } _ { q } = \pmb { \Lambda } _ { p } : = \pmb { \Lambda }$ , we can ignore the quadratic term. If we further express $\pmb { \Lambda } _ { q } W ^ { q } - \pmb { \Lambda } _ { p } W ^ { p }$ in the form $V$ , we can arrive at the form (3) again.
+
+Indeed, however, the way that this regularization affects the training of the generator $G$ is a little unclear in its formulation. As we have repeatedly explained, our discriminator measures the divergence between the generator distribution $p$ and the target distribution $q$ on the assumption that $p ( \pmb { y } | \pmb { x } )$ and $q ( \pmb { y } | \pmb { x } )$ are relatively simple, and it is highly possible that we are gaining stability in the training process by imposing a regularity condition on the divergence measure. Meanwhile, however, the actual $p ( \boldsymbol { y } | \boldsymbol { x } )$ can only be implicitly derived from $p ( { \pmb x } , { \pmb y } )$ in computation, and can possibly take numerous forms other than the ones we have considered here. We must admit that there is a room here for an important theoretical work to be done in order to assess the relationship between the choice of the function space for the discriminator and training process of the generator.
+
+# 4 COMPARISON WITH OTHER METHODS
+
+As described above, (3) is a form that is true for frequently occurring situations. In contrast, incorporation of the conditional information by concatenation is rather arbitrary and can possibly include into the pool of candidate functions some sets of functions for which it is difficult to find a logical basis. Indeed, if the situation calls for multimodal $p ( \pmb { y } | \pmb { x } )$ , it might be smart not to use the model that we suggest here. Otherwise, however, we expect our model to perform better; in general, it is preferable to use a discriminator that respects the presumed form of the probabilistic model.
+
+Still another way to incorporate the conditional information into the training procedure is to directly manipulate the loss function. The algorithm of AC-GANs (Odena et al., 2017) use a discriminator $( D _ { 1 } )$ that shares a part of its structure with the classifier $( D _ { 2 } )$ , and incorporates the label information into the objective function by augmenting the original discriminator objective with the likelihood score of the classifier on both the generated and training dataset (see Figure 1c). Plug and Play Generative models (PPGNs) (Nguyen et al., 2017) is another approach for the generative model that uses an auxiliary classifier function. It is a method that endeavors to make samples from $p ( { \pmb x } | { \pmb y } )$ using an MCMC sampler based on the Langevin equation with drift terms consisting of the gradient of an autoencoder prior $p ( { \pmb x } )$ and a pretrained auxiliary classifier $p ( y | \mathbf { \boldsymbol { x } } )$ . With these method, one can generate a high quality image. However, these ways of using auxiliary classifier may unwittingly encourage the generator to produce images that are particularly easy for the auxiliary classifier to classify, and deviate the final $p ( { \pmb x } | { \pmb y } )$ from the true $\dot { \mathbf { \ b { q } } } ( \mathbf { \ b { x } } | \mathbf { \ b { y } } )$ . In fact, Odena et al. (2017) reports that this problem has a tendency to exacerbate with increasing number of labels. We were able to reproduce this phenomena in our experiments; when we implemented their algorithm on a dataset with 1000 class categories, the final trained model was able to generate only one image for most classes. Nguyen et al.’s PPGNs is also likely to suffer from the same problem because they are using an order of magnitude greater coefficient for the term corresponding to $p ( y | \mathbf { \boldsymbol { x } } )$ than for the other terms in the Langevin equation.
+
+# 5 EXPERIMENTS
+
+In order to evaluate the effectiveness of our newly proposed architecture for the discriminator, we conducted two sets of experiments: class conditional image generation and super-resolution on ILSVRC2012 (ImageNet) dataset (Russakovsky et al., 2015). For both tasks, we used the ResNet (He et al., 2016b) based discriminator and the generator used in Gulrajani et al. (2017), and applied spectral normalization (Miyato et al., 2018) to the all of the weights of the discriminator to regularize the Lipschitz constant. For the objective function, we used the following hinge version of the standard adversarial loss (1) (Lim & Ye, 2017; Tran et al., 2017)
+
+$$
+\begin{array} { r l r } & { \langle ( \hat { G } , D ) = E _ { q ( y ) } [ E _ { q ( x | y ) } [ \operatorname* { m a x } ( 0 , 1 - D ( \pmb { x } , y ) ] ] + E _ { q ( y ) } [ E _ { p ( z ) } [ \operatorname* { m a x } ( 0 , 1 + D ( \hat { G } ( z , y ) , y ) ) ] ] , } & \\ & { \langle ( G , \hat { D } ) = - E _ { q ( y ) } [ E _ { p ( z ) } [ \hat { D } ( G ( z , y ) , y ) ) ] ] , } & { ( 9 ) } \end{array}
+$$
+
+where the last activation function $\mathcal { A }$ of $D$ is identity function. $p ( z )$ is standard Gaussian distribution and $G ( z , y )$ is the generator network. For all experiments, we used Adam optimizer (Kingma & Ba, 2015) with hyper-parameters set to $\alpha = 0 . 0 0 0 2 , \beta _ { 1 } = 0 , \beta _ { 2 } = 0 . 9$ . We updated the discriminator five times per each update of the generator. We will use concat to designate the models (Figure $1 \mathsf { b } ) ^ { 2 }$ , and use projection to designate the proposed model (Figure 1d) .
+
+# 5.1 CLASS-CONDITIONAL IMAGE GENERATION
+
+The ImageNet dataset used in the experiment of class conditional image generation consisted of 1,000 image classes of approximately 1,300 pictures each. We compressed each images to $1 2 8 \times 1 2 8$ pixels. Unlike for AC-GANs3 we used a single pair of a ResNet-based generator and a discriminator. Also, we used conditional batch normalization (Dumoulin et al., 2017b; de Vries et al., 2017) for the generator. As for the architecture of the generator network used in the experiment, please see Figure 14 for more detail. Our proposed projection model discriminator is equipped with a ‘projection layer’ that takes inner product between the embedded one-hot vector $\textbf {  { y } }$ and the intermediate output (Figure 14a). As for the structure of the the concat model discriminator to be compared against, we used the identical bulk architecture as the projection model discriminator, except that we removed the projection layer from the structure and concatenated the spatially replicated embedded conditional vector $\textbf {  { y } }$ to the output of third ResBlock. We also experimented with AC-GANs as the current state of the art model. For AC-GANs, we placed the softmax layer classifier to the same structure shared by concat and projection. For each method, we updated the generator 450K times, and applied linear decay for the learning rate after 400K iterations so that the rate would be 0 at the end. For the comparative experiments, we trained the model for 450K iterations, which was ample for the training of concat to stabilize. AC-GANs collapsed prematurely before the completion of 450K iterations, so we reported the result from the peak of its performance ( 80K iterations). For all experiments throughout, we used the training over 450K iterations for comparing the performances. On a separate note, our method continued to improve even after 450K. We therefore also reported the inception score and FID of the extended training (850K iterations) for our method exclusively. See the table 1 for the exact figures.
+
+We used inception score (Salimans et al., 2016) for the evaluation of the visual appearance of the generated images. It is in general difficult to evaluate how ‘good’ the generative model is. Indeed, however, either subjective or objective, some definite measures of ‘goodness’ exists, and essential two of them are ‘diversity’ and the sheer visual quality of the images. One possible candidate for quantitative measure of diversity and visual appearance is FID (Heusel et al., 2017). We computed FID between the generated images and dataset images within each class, and designated the values as intra FIDs. More precisely, FID (Heusel et al., 2017) measures the 2-Wasserstein distance between the two distributions $q _ { y }$ and $p _ { y }$ , and is given by $F ( q _ { y } , p _ { y } ) \ = \ \| { \pmb { \mu } } _ { q _ { y } } \ - { \pmb { \mu } } _ { p _ { y } } \| _ { 2 } ^ { 2 } \ +$ trace $\left( C _ { q _ { y } } + C _ { p _ { y } } - 2 ( C _ { q _ { y } } C _ { p _ { y } } ) ^ { 1 / 2 } \right)$ , where $\{ \mu _ { q _ { y } } , C _ { q _ { y } } \}$ , $\{ \mu _ { p _ { y } } , C _ { p _ { y } } \}$ are respectively the mean and the covariance of the final feature vectors produced by the inception model (Szegedy et al., 2015) from the true samples and generated samples of class $y$ . When the set of generated examples have collapsed modes, the trace of $C _ { p _ { y } }$ becomes small and the trace term itself becomes large. In order to compute $C _ { q _ { y } }$ we used all samples in the training data belonging to the class of concern, and used 5000 generated samples for the computation of $C _ { p _ { y } }$ . We empirically observed in our experiments that intra FID is, to a certain extent, serving its purpose well in measuring the diversity and the visual quality.
+
+To highlight the effectiveness of our inner-product based approach (projection) of introducing the conditional information into the model, we compared our method against the state of the art ACGANs as well as the conventional incorporation of the conditional information via concatenation at hidden layer (concat). As we can see in the training curves Figure 3, projection outperforms inception score than concat throughout the training. Table 1 compares the intra class FIDs and the inception Score of the images generated by each method. The result shown here for the AC-GANs is that of the model at its prime in terms of the inception score, because the training collapsed at the end. We see that the images generated by projection have lower intra FID scores than both adversaries, indicating that the Wasserstein distance between the generative distribution by projection to the target distribution is smaller. For the record, our model performed better than other models on the CIFAR10 and CIFAR 100 as well (See Appendix A).
+
+![](images/2192e95c50d255416dbc8d3cef02975c1b0b270d3f11d26a257f2780374ad431.jpg)
+
+![](images/3d525ce3d861a0acb3d00d06bf586814dc5726773cf2522420243abf5bcfd5fb.jpg)  
+Figure 3: Learning curves of Figure 4: Comparison of intra FID scores for projection cGANs with concat and projection concat, and AC-GANs on ImageNet. Each dot corresponds on ImageNet. to a class.
+
+Table 1: Inception score and intra FIDs on ImageNet.   
+
+<table><tr><td>Method</td><td>Inception Score</td><td>Intra FID</td></tr><tr><td>AC-GANs</td><td>28.5±.20</td><td>260.0</td></tr><tr><td>concat</td><td>21.1±.35</td><td>141.2</td></tr><tr><td>projection</td><td>29.7±.61</td><td>103.1</td></tr><tr><td>*projection (850K iteration)</td><td>36.8±.44</td><td>92.4</td></tr></table>
+
+Figure 10a and 10b shows the set of classes for which (a) projection yielded results with better intra FIDs than the concat and (b) the reverse. From the top, the figures are listed in descending order of the ratio between the intra FID score between the two methods. Note that when the concat outperforms projection it only wins by a slight margin, whereas the projection outperforms concat by large margin in the opposite case. A quick glance on the cases in which the concat outperforms the projection suggests that the FID is in fact measuring the visual quality, because both sets looks similar to the human eyes in terms of appearance. Figure 5 shows an arbitrarily selected set of results yielded by AC-GANs from variety of ${ \boldsymbol { z } } \mathbf { s }$ . We can clearly observe the mode-collapse on this batch. This is indeed a tendency reported by the inventors themselves (Odena et al., 2017). ACGANs can generate easily recognizable (i.e classifiable) images, but at the cost of losing diversity and hence at the cost of constructing a generative distribution that is significantly different from the target distribution as a whole. We can also assess the low FID score of projection from different perspective. By construction, the trace term of intra FID measures the degree of diversity within the class. Thus, our result on the intra FID scores also indicates that that our projection is doing better in reproducing the diversity of the original. The GANs with the concat discriminator also suffered from mode-collapse for some classes (see Figure 6). For the set of images generated by projection, we were not able to detect any notable mode-collapse.
+
+Figure 7a shows the samples generated with the projection model for the classes on which the cGAN achieved lowest intra FID scores (that is the classes on which the generative distribution were particularly close to target conditional distribution), and Figure 7b the reverse. While most of the images listed in Figure 7a are of relatively high quality, we still observe some degree of mode-collapse. Note that the images in the classes with high FID are featuring complex objects like human; that is, one can expect the diversity within the class to be wide. However, we note that we did not use the most complicated neural network available for the experiments presented on this paper, because we prioritized the completion of the training within a reasonable time frame. It is very possible that, by increasing the complexity of the model, we will be able to further improve the visual quality of the images and the diversity of the distribution. In Appendix D, we list images of numerous classes generated by cGANs trained with our projection model.
+
+![](images/537d54379a8fc36a8717dd27960d5ac73b4f9314a2c3c18cac52a12aaf215700.jpg)  
+Figure 5: comparison of the images generated by (a) AC-GANs and (b) projection.
+
+![](images/800874aca51e180b570c20cf4c25fdd54d2d22dd2e2591c73dc1debbad131650.jpg)  
+Figure 6: Collapsed images on the concat model.
+
+Category Morphing With our new architecture, we were also able to successfully perform category morphism. When there are classes $y _ { 1 }$ and $y _ { 2 }$ , we can create an interpolated generator by simply mixing the parameters of conditional batch normalization layers of the conditional generator corresponding to these two classes. Figure 8 shows the output of the interpolated generator with the same $z$ . Interestingly, the combination is also yielding meaningful images when $y _ { 1 }$ and $y _ { 2 }$ are significantly different.
+
+Fine-tuning with the pretrained model on the ILSVRC2012 classification task. As we mentioned in Section 4, the authors of Plug and Play Generative model (PPGNs) (Nguyen et al., 2017) were able to improve the visual appearance of the model by augmenting the cost function with that of the label classifier. We also followed their footstep and augmented the original generator loss with an additional auxiliary classifier loss. As warned earlier regarding this type of approach, however, this type of modification tends to only improve the visual performance of the images that are easy for the pretrained model to classify. In fact, as we can see in Appendix B, we were able to improve the visual appearance the images with the augmentation, but at the cost of diversity.
+
+# 5.2 SUPER-RESOLUTION
+
+We also evaluated the effectiveness of (3) in its application to the super-resolution task. Put formally, the super-resolution task is to infer the high resolution RGB image of dimension $\pmb { x } \in \mathbb { R } ^ { R _ { H } \times R _ { H } \times \hat { \mathbf { 3 } } }$ from the low resolution RGB image of dimension $\pmb { y } \in \mathbb { R } ^ { R _ { L } \times R _ { L } \times 3 } ; R _ { H } > R _ { L }$ . This task is very much the case that we presumed in our model construction, because $p ( \pmb { y } | \pmb { x } )$ is most likely unimodal even if $p ( { \pmb x } | { \pmb y } )$ is multimodal. For the super-resolution task, we used the following formulation for discriminator function:
+
+$$
+f ( { \pmb x } , { \pmb y } ; { \theta } ) = \sum _ { i , j , k } \left( y _ { i j k } F _ { i j k } ( { \phi } ( { \pmb x } ; { \theta } _ { \Phi } ) ) \right) + \psi ( { \phi } ( { \pmb x } ; { \theta } _ { \Phi } ) ; { \theta } _ { \Psi } ) ,
+$$
+
+where $\begin{array} { r } { F ( \phi ( \pmb { x } ; \theta _ { \Phi } ) ) = V * \phi ( \pmb { x } ; \theta _ { \Phi } ) } \end{array}$ where $V$ is a convolutional kernel and $^ *$ stands for convolution operator. Please see Figure 15 in the appendix section for the actual network architectures we used for this task. For this set of experiments, we constructed the concat model by removing the module in the projection model containing the the inner product layer and the accompanying convolution layer altogether, and simply concatenated $\textbf {  { y } }$ to the output of the ResBlock preceding the inner product module in the original. As for the resolutions of the image datasets, we chose $R _ { H } = 1 2 8$ and $R _ { L } =$ 32, and created the low resolution images by applying bilinear downsampling on high resolution images. We updated the generators 150K times for all methods, and applied linear decay for the learning rate after 100K iterations so that the final learning rate was 0 at 150K-th iteration.
+
+![](images/55f061a8535be4d7c6a950904319ef9f483b316b7f577db5f89f5f58553f04ee.jpg)  
+Figure 7: $1 2 8 \times 1 2 8$ pixel images generated by the projection method for the classes with (a) bottom five FID scores and (b) top five FID scores. The string and the value above each panel are respectively the name of the corresponding class and the FID score. The second row in each panel corresponds to the original dataset.
+
+Figure 9 shows the result of our super-resolution. The bicubic super-resolution is very blurry, and concat result is suffering from excessively sharp and rough edges. On the other hand, the edges of the images generated by our projection method are much clearer and smoother, and the image itself is much more faithful to the original high resolution images. In order to qualitatively compare the performances of the models, we checked MS-SSIM (Wang et al., 2003) and the classification accuracy of the inception model on the generated images using the validation set of the ILSVRC2012 dataset. As we can see in Table 2, our projection model was able to achieve high inception accuracy and high MS-SSIM when compared to bicubic and concat. Note that the performance of superresolution with concat model even falls behind those of the bilinear and bicubic super-resolutions in terms of the inception accuracy. Also, we used projection model to generate multiple batches of images with different random values of $_ { z }$ to be fed to the generator and computed the average of the logits of the inception model on these batches (MC samples). We then used the so-computed average logits to make prediction of the labels. With an ensemble over 10 seeds ( $1 0 \mathrm { M C }$ in Table 2), we were able to improve the inception accuracy even further. This result indicates that our GANs are learning the super-resolution as an distribution, as opposed to deterministic function. Also, the success with the ensemble also suggests a room for a new way to improve the accuracy of classification task on low resolution images.
+
+![](images/32cddc648d477a401d503a77d877fb1a55955b50be00a272260fa4fb9cd3c72f.jpg)  
+Figure 8: Category morphing. More results are in the appendix section.
+
+Table 2: Inception accuracy and MS-SSIM on different super-resolution methods. We picked up dataset images from the validation set.   
+
+<table><tr><td>Method</td><td>biliear</td><td>bicubic</td><td>concat</td><td> projection</td><td> projection (10 MC)</td></tr><tr><td>Inception Acc.(%)</td><td>23.1</td><td>31.4</td><td>11.0</td><td>35.2</td><td>36.4</td></tr><tr><td>MS-SSIM</td><td>0.835</td><td>0.859</td><td>0.829</td><td>0.878</td><td>1</td></tr></table>
+
+# 6 CONCLUSION
+
+Any specification on the form of the discriminator imposes a regularity condition for the choice for the generator distribution and the target distribution. In this research, we proposed a model for the discriminator of cGANs that is motivated by a commonly occurring family of probabilistic models. This simple modification was able to significantly improve the performance of the trained generator on conditional image generation task and super-resolution task. The result presented in this paper is strongly suggestive of the importance of the choice of the form of the discriminator and the design of the distributional metric. We plan to extend this approach to other applications of cGANs, such as semantic segmentation tasks and image to image translation tasks.
+
+![](images/de90c79076be5c3819a460e5e92251e8aeb7edc82d94dc65978c6b2cc7ffb58a.jpg)  
+Figure 9: 32x32 to $1 2 8 \mathrm { x } 1 2 8$ super-resolution by different methods
+
+# ACKNOWLEDGMENTS
+
+We would like to thank the members of Preferred Networks, Inc., especially Richard Calland, Sosuke Kobayashi and Crissman Loomis, for helpful comments. We would also like to thank Shoichiro Yamaguchi, a graduate student of Kyoto University, for helpful comments.
+
+![](images/bfa07cf264b9631ba798d785bec7f2dcb6e023453799ec788e16784907ed1782.jpg)  
+Figure 10: Comparison of concat vs. projection. The value attached above each panel represents the achieved FID score.
+
+# REFERENCES
+
+Martin Arjovsky, Soumith Chintala, and Leon Bottou. Wasserstein generative adversarial networks. In ´ ICML, pp. 214–223, 2017.   
+Harm de Vries, Florian Strub, Jer´ emie Mary, Hugo Larochelle, Olivier Pietquin, and Aaron C Courville. Mod- ´ ulating early visual processing by language. In NIPS, pp. 6576–6586, 2017.   
+Emily Denton, Soumith Chintala, Arthur Szlam, and Rob Fergus. Deep generative image models using a laplacian pyramid of adversarial networks. In NIPS, pp. 1486–1494, 2015.   
+Vincent Dumoulin, Ishmael Belghazi, Ben Poole, Alex Lamb, Martin Arjovsky, Olivier Mastropietro, and Aaron Courville. Adversarially learned inference. In ICLR, 2017a.   
+Vincent Dumoulin, Jonathon Shlens, and Manjunath Kudlur. A learned representation for artistic style. In ICLR, 2017b.   
+Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In NIPS, pp. 2672–2680, 2014.   
+Ishaan Gulrajani, Faruk Ahmed, Martin Arjovsky, Vincent Dumoulin, and Aaron Courville. Improved training of wasserstein GANs. arXiv preprint arXiv:1704.00028, 2017.   
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, 2016a.   
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Identity mappings in deep residual networks. In European Conference on Computer Vision, pp. 630–645. Springer, 2016b.   
+Martin Heusel, Hubert Ramsauer, Thomas Unterthiner, Bernhard Nessler, Gunter Klambauer, and Sepp ¨ Hochreiter. Gans trained by a two time-scale update rule converge to a nash equilibrium. arXiv preprint arXiv:1706.08500, 2017.   
+Taeksoo Kim, Moonsu Cha, Hyunsoo Kim, Jungkwon Lee, and Jiwon Kim. Learning to discover cross-domain relations with generative adversarial networks. In ICML, pp. 1857–1865, 2017.   
+Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In ICLR, 2015.   
+Christian Ledig, Lucas Theis, Ferenc Huszar, Jose Caballero, Andrew Cunningham, Alejandro Acosta, Andrew ´ Aitken, Alykhan Tejani, Johannes Totz, Zehan Wang, and Wenzhe Shi. Photo-realistic single image superresolution using a generative adversarial network. In CVPR, 2017.   
+Jae Hyun Lim and Jong Chul Ye. Geometric GAN. arXiv preprint arXiv:1705.02894, 2017.   
+Mehdi Mirza and Simon Osindero. Conditional generative adversarial nets. arXiv preprint arXiv:1411.1784, 2014.   
+Takeru Miyato, Toshiki Kataoka, Masanori Koyama, and Yuichi Yoshida. Spectral normalization for generative adversarial networks. In ICLR, 2018.   
+Anh Nguyen, Jeff Clune, Yoshua Bengio, Alexey Dosovitskiy, and Jason Yosinski. Plug & play generative networks: Conditional iterative generation of images in latent space. In CVPR, 2017.   
+Sebastian Nowozin, Botond Cseke, and Ryota Tomioka. f-GAN: Training generative neural samplers using variational divergence minimization. In NIPS, pp. 271–279, 2016.   
+Augustus Odena, Christopher Olah, and Jonathon Shlens. Conditional image synthesis with auxiliary classifier GANs. In ICML, pp. 2642–2651, 2017.   
+Guim Perarnau, Joost van de Weijer, Bogdan Raducanu, and Jose M Alvarez. Invertible conditional gans for ´ image editing. In NIPS Workshop on Adversarial Training, 2016.   
+Alec Radford, Luke Metz, and Soumith Chintala. Unsupervised representation learning with deep convolutional generative adversarial networks. In ICLR, 2016.   
+Scott Reed, Zeynep Akata, Xinchen Yan, Lajanugen Logeswaran, Bernt Schiele, and Honglak Lee. Generative adversarial text to image synthesis. In ICML, pp. 1060–1069, 2016.   
+Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael Bernstein, Alexander C. Berg, and Li Fei-Fei. ImageNet Large Scale Visual Recognition Challenge. International Journal of Computer Vision (IJCV), 115(3):211–252, 2015. doi: 10.1007/s11263-015-0816-y.   
+Masaki Saito, Eiichi Matsumoto, and Shunta Saito. Temporal generative adversarial nets with singular value clipping. In ICCV, 2017.   
+Tim Salimans, Ian Goodfellow, Wojciech Zaremba, Vicki Cheung, Alec Radford, and Xi Chen. Improved techniques for training GANs. In NIPS, pp. 2226–2234, 2016.   
+Kumar Sricharan, Raja Bala, Matthew Shreve, Hui Ding, Kumar Saketh, and Jin Sun. Semi-supervised conditional GANs. arXiv preprint arXiv:1708.05789, 2017.   
+Christian Szegedy, Wei Liu, Yangqing Jia, Pierre Sermanet, Scott Reed, Dragomir Anguelov, Dumitru Erhan, Vincent Vanhoucke, and Andrew Rabinovich. Going deeper with convolutions. In CVPR, pp. 1–9, 2015.   
+Seiya Tokui, Kenta Oono, Shohei Hido, and Justin Clayton. Chainer: a next-generation open source framework for deep learning. In Proceedings of workshop on machine learning systems (LearningSys) in the twentyninth annual conference on neural information processing systems (NIPS), 2015.   
+Antonio Torralba, Rob Fergus, and William T Freeman. 80 million tiny images: A large data set for nonparametric object and scene recognition. IEEE transactions on pattern analysis and machine intelligence, 30 (11):1958–1970, 2008.   
+Dustin Tran, Rajesh Ranganath, and David M Blei. Deep and hierarchical implicit models. arXiv preprint arXiv:1702.08896, 2017.   
+Zhou Wang, Eero P Simoncelli, and Alan C Bovik. Multiscale structural similarity for image quality assessment. In Asilomar Conference on Signals, Systems and Computers, pp. 1398–1402, 2003.   
+Han Zhang, Tao Xu, Hongsheng Li, Shaoting Zhang, Xiaolei Huang, Xiaogang Wang, and Dimitris Metaxas. Stackgan: Text to photo-realistic image synthesis with stacked generative adversarial networks. In ICCV, 2017.   
+Jun-Yan Zhu, Taesung Park, Phillip Isola, and Alexei A Efros. Unpaired image-to-image translation using cycle-consistent adversarial networks. In ICCV, 2017.
+
+# A RESULTS OF CLASS CONDITIONAL IMAGE GENERATION ON CIFAR-10 AND CIFAR-100
+
+As a preliminary experiment, we compared the performance of conditional image generation on CIFAR-10 and CIFAR-100 3. For the discriminator and the generator, we reused the same architecture used in Miyato et al. (2018) for the task on CIFAR-10. For the adversarial objective functions, we used (9), and trained both machine learners with the same optimizer with same hyper parameters we used in Section 5. For our projection model, we added the projection layer to the discriminator in the same way we did in the ImageNet experiment (before the last linear layer). Our projection model achieved better performance than other methods on both CIFAR-10 and CIFAR-100. Concatenation at hidden layer (hidden concat) was performed on the output of second ResBlock of the discriminator. We tested hidden concat as a comparative method in our main experiments on ImageNet, because the concatenation at hidden layer performed better than the concatenation at the input layer (input concat) when the number of classes was large (CIFAR-100).
+
+To explore how the hyper-parameters affect the performance of our proposed architecture, we conducted hyper-parameter search on CIFAR-100 about the Adam hyper-parameters (learning rate $\alpha$ and 1st order momentum $\beta _ { 1 . }$ ) for both our proposed architecture and the baselines. Namely, we varied each one of these parameters while keeping the other constant, and reported the inception scores for all methods including several versions of concat architectures to compare. We tested with concat module introduced at (a) input layer, (b) hidden layer, and at (c) output layer. As we can see in Figure 11, our projection architecture excelled over all other architectures for all choice of the parameters, and achieved the inception score of 9.53. Meanwhile, concat architectures were able to achieve all 8.82 at most. The best concat model in term of the inception score on CIFAR-100 was the hidden concat with $\alpha = 0 . 0 0 0 2$ and $\beta _ { 1 } = 0$ , which turns out to be the very choice of the parameters we picked for our ImageNet experiment.
+
+Table 3: The performance of class conditional image generation on CIFAR-10 (C10) and CIFAR100 (C100).   
+
+<table><tr><td>Method</td><td>Inception score C10</td><td>C100</td><td>FID C10 C100</td></tr><tr><td>(Real data)</td><td>11.24</td><td>14.79</td><td>7.60 8.94</td></tr><tr><td>AC-GAN</td><td>8.22</td><td>8.80</td><td>19.7 25.4</td></tr><tr><td> input concat</td><td>8.25</td><td>7.93</td><td>19.2 31.4</td></tr><tr><td>hidden concat</td><td>8.14</td><td>8.82</td><td>19.2 24.8</td></tr><tr><td>(ours) projection</td><td>8.62</td><td>9.04</td><td>17.5 23.2</td></tr></table>
+
+![](images/802214d0fe7e313b4d57605ad6721c042423588c1ef245e8806e4e681daed633.jpg)  
+Figure 11: Inception scores on CIFAR-100 with different discriminator models varying hyperparameters ( $\overset { \cdot } { \alpha }$ and $\beta _ { 1 }$ ) of Adam optimizer.
+
+![](images/f09ac1616c4b5401905190295c7ea6c94be9035139cf2497f1add48c249565d7.jpg)  
+Figure 12: Effect of the finetuning with auxiliary classifier loss. Same coordinate in panel (a) and (b) corresponds to same value of $_ z$
+
+Table 4: Inception score and intra FIDs on ImageNet with a pretrained model on classification tasks for ILSVRC2012 dataset. $^ { \ddag \mathrm { N } }$ guyen et al. (2017)   
+
+<table><tr><td>Method</td><td>Inception Score</td><td>Intra FID</td></tr><tr><td>PPGNs+</td><td>47.4</td><td>N/A</td></tr><tr><td>projection(finetuned)</td><td>210</td><td>54.2</td></tr></table>
+
+# B OBJECTIVE FUNCTION WITH AN AUXILIARY CLASSIFIER COST
+
+In this experiment, we followed the footsteps of Plug and Play Generative model (PPGNs) (Nguyen et al., 2017) and augmented the original generator loss with an additional auxiliary classifier loss. In particular, we used the losses given by :
+
+$$
+L \left( G , \hat { D } , \hat { p } _ { \mathrm { p r e } } ( y | x ) \right) = - E _ { q ( y ) } \left[ E _ { p ( z ) } \left[ \hat { D } ( G ( z , y ) , y ) - L _ { C } ( \hat { p } _ { \mathrm { p r e } } ( y | G ( z , y ) ) ) \right] \right] ,
+$$
+
+where $\hat { p } _ { \mathrm { p r e } } ( y | \pmb { x } )$ is the fixed model pretrained for ILSVRC2012 classification task. For the actual experiment, we trained the generator with the original adversarial loss for the first 400K updates, and used the augmented loss for the last 50K updates. For the learning rate hyper parameter, we adopted the same values as other experiments we described above. For the pretrained classifier, we used ResNet50 model used in He et al. (2016a). Figure 12 compares the results generated by vanilla objective function and the results generated by the augmented objective function. As we can see in Table 4, we were able to significantly outperform PPGNs in terms of inception score. However, note that the images generated here are images that are easy to classify. The method with auxiliary classifier loss seems effective in improving the visual appearance, but not in training faithful generative model.
+
+![](images/f238ed8ab5746c733f3277093cc6d7d4f752a7154edca57a4e2729674c208ddc.jpg)  
+(b) ResBlock for the generator.   
+Figure 13: Architecture of the ResBlocks used in all experiments. For the generator generator’s Resblock, conditional batch normalization layer (Dumoulin et al., 2017b; de Vries et al., 2017) was used in place of the standard batch normalization layer. For the ResBlock in the generator for the super resolution tasks that implements the upsampling, the random vector $_ z$ was fed to the model by concatenating the vector to the embedded low resolution image vector $\textbf {  { y } }$ prior to the first convolution layer within the block. For the procedure of downsampling and upsampling, we followed the implementation by Gulrajani et al. (2017). For the discriminator, we performed downsampling (average pool) after the second conv of the ResBlock. For the generator, we performed upsampling before the first conv of the ResBlock. For the ResBlock that is performing the downsampling, we replaced the identity mapping with 1x1 conv layer followed by downsampling to balance the dimension. We did the essentially same for the Resblock that is performing the upsampling, except that we applied the upsampling before the 1x1 conv.
+
+![](images/0962bcbc2b0a16a4cbcffc020e1ce5de4d97aeba750dbdaba02271b1d9825325.jpg)  
+Figure 14: The models we used for the conditional image generation task.
+
+![](images/7b40023e7636d6e1a08658472654e4381183c33e10a7a39b9b5bc264eeb17eb3.jpg)  
+Figure 15: The models we used for the super resolution task.
+
+# D MORE RESULTS ON THE CONDITIONAL IMAGE GENERATION TASK
+
+![](images/0f88dc2f1d5027682f9a8cbc76dc727127c9850e184973291aceaf1e5e03b3a7.jpg)  
+Figure 16: $1 2 8 \times 1 2 8$ generated examples on various categories with projection architecture. Each panel corresponds to a class.
+
+![](images/c3c43653d190b9d75ed4a9dbf3c52426e9fa1f96f9619a209df81e9f13d0bf00.jpg)  
+Figure 17: $1 2 8 \times 1 2 8$ generated examples on various categories with projection architecture. Each panel corresponds to a class. From top to bottom, tench, papillon, grey whale, desktop computer, altar, whiskey jug and volcano.
+
+# E RESULTS OF CATEGORY MORPHING
+
+![](images/c39939af00d1bc3e38ace98572a248bb753f5e0040afc2c750739e6aa68d435e.jpg)  
+Figure 18: Dog (Lhasa apso) to different categories
+
+![](images/8dcf7a13ceec1ddeab354971f2ff49d4d26e578f77d9410c76b46963807f944c.jpg)
+
+![](images/9c0c5542463d8ec56923d821210439ac6bdcda4b65eb43285ced64c953798cad.jpg)  
+(a) Hip to Yellow lady’s slipper
+
+![](images/d8e5962ed122548ba7ade6a52a637b935d99506fc2ef25b5e540938e74af4c28.jpg)  
+(b) Pirate ship to Yawl
+
+![](images/35db938603fe17ce553f1c7b8cb4514a49e7342feb40dfd50cf6fd4cdbb781d0.jpg)  
+(c) Yurt to Castle
+
+![](images/d47dffd614af997cc2fe31335db973ea33bed8759b0c4099c0a12ffcd0256452.jpg)  
+(d) Chiffonier to Chinese cabinet   
+Figure 19: Morphing between different categories
+
+F MORE RESULTS WITH SUPER-RESOLUTION
+
+![](images/8d2019cccf7dd72ba2705b4c679d73810796567bcba7ac7537deb84373a45ff8.jpg)  
+Figure 20: $3 2 \mathrm { x } 3 2 $ to $1 2 8 \mathrm { x } 1 2 8$ super-resolution results

parse/train/ByS1VpgRZ/ByS1VpgRZ_content_list.json

@@ -0,0 +1,1310 @@
+[
+    {
+        "type": "text",
+        "text": "CGANS WITH PROJECTION DISCRIMINATOR ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            704,
+            121
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Takeru Miyato1, Masanori Koyama2 miyato@preferred.jp koyama.masanori@gmail.com 1Preferred Networks, Inc. 2Ritsumeikan University ",
+        "bbox": [
+            184,
+            143,
+            519,
+            202
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            238,
+            544,
+            253
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We propose a novel, projection based way to incorporate the conditional information into the discriminator of GANs that respects the role of the conditional information in the underlining probabilistic model. This approach is in contrast with most frameworks of conditional GANs used in application today, which use the conditional information by concatenating the (embedded) conditional vector to the feature vectors. With this modification, we were able to significantly improve the quality of the class conditional image generation on ILSVRC2012 (ImageNet) 1000-class image dataset from the current state-of-the-art result, and we achieved this with a single pair of a discriminator and a generator. We were also able to extend the application to super-resolution and succeeded in producing highly discriminative super-resolution images. This new structure also enabled high quality category transformation based on parametric functional transformation of conditional batch normalization layers in the generator. The code with Chainer (Tokui et al., 2015), generated images and pretrained models are available at https://github.com/pfnet-research/sngan_projection. ",
+        "bbox": [
+            233,
+            272,
+            764,
+            481
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            513,
+            336,
+            530
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Generative Adversarial Networks (GANs) (Goodfellow et al., 2014) are a framework to construct a generative model that can mimic the target distribution, and in recent years it has given birth to arrays of state-of-the-art algorithms of generative models on image domain (Radford et al., 2016; Salimans et al., 2016; Ledig et al., 2017; Zhang et al., 2017; Reed et al., 2016). The most distinctive feature of GANs is the discriminator $D ( { \\pmb x } )$ that evaluates the divergence between the current generative distribution $p _ { G } ( \\pmb { x } )$ and the target distribution $q ( { \\pmb x } )$ (Goodfellow et al., 2014; Nowozin et al., 2016; Arjovsky et al., 2017). The algorithm of GANs trains the generator model by iteratively training the discriminator and generator in turn, with the discriminator acting as an increasingly meticulous critic of the current generator. ",
+        "bbox": [
+            174,
+            547,
+            825,
+            672
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Conditional GANs (cGANs) are a type of GANs that use conditional information (Mirza & Osindero, 2014) for the discriminator and generator, and they have been drawing attention as a promising tool for class conditional image generation (Odena et al., 2017), the generation of the images from text (Reed et al., 2016; Zhang et al., 2017), and image to image translation (Kim et al., 2017; Zhu et al., 2017). Unlike in standard GANs, the discriminator of cGANs discriminates between the generator distribution and the target distribution on the set of the pairs of generated samples $_ { \\textbf { \\em x } }$ and its intended conditional variable $\\textbf {  { y } }$ . To the authors’ knowledge, most frameworks of discriminators in cGANs at the time of writing feeds the pair the conditional information $\\textbf {  { y } }$ into the discriminator by naively concatenating (embedded) $\\textbf {  { y } }$ to the input or to the feature vector at some middle layer (Mirza & Osindero, 2014; Denton et al., 2015; Reed et al., 2016; Zhang et al., 2017; Perarnau et al., 2016; Saito et al., 2017; Dumoulin et al., 2017a; Sricharan et al., 2017). We would like to however, take into account the structure of the assumed conditional probabilistic models underlined by the structure of the discriminator, which is a function that measures the information theoretic distance between the generative distribution and the target distribution. ",
+        "bbox": [
+            174,
+            680,
+            825,
+            875
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "By construction, any assumption about the form of the distribution would act as a regularization on the choice of the discriminator. In this paper, we propose a specific form of the discriminator, a form motivated by a probabilistic model in which the distribution of the conditional variable $\\textbf {  { y } }$ given $_ { \\textbf { \\em x } }$ is ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/ec3520e11657fdeb608fe6e00882b71a56ec36ba76d36bdf62da06ae694f1214.jpg",
+        "image_caption": [
+            "Figure 1: Discriminator models for conditional GANs "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            240,
+            103,
+            758,
+            273
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/dfbb090f2bfa4de6de0efa4df202fa420d3811aa17ffa90e01fbf8972e05b9e1.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            311,
+            823,
+            397
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/8dd2760c90cb4a9e736ee0a370b3904e4d6803c56110e65a74098a88406bba67.jpg",
+        "image_caption": [
+            "(a) Images generated with the projection model. (left) Tibetan terrier and (right) mushroom. ",
+            "(b) (left) Consecutive category morphing with fixed $_ { z }$ . geyser Tibetan terrier mushroom robin. (right) category morphing from Tibetan terrier to mushroom with different value of fixed $_ { z }$ "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            189,
+            417,
+            808,
+            515
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Figure 2: The generator trained with the projection model can generate diverse set of images. For more results, see the experiment section and the appendix section. ",
+        "bbox": [
+            174,
+            558,
+            821,
+            585
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "discrete or uni-modal continuous distributions. This model assumption is in fact common in many real world applications, including class-conditional image generation and super-resolution. ",
+        "bbox": [
+            174,
+            613,
+            821,
+            642
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "As we will explain in the next section, adhering to this assumption will give rise to a structure of the discriminator that requires us to take an inner product between the embedded condition vector $\\textbf {  { y } }$ and the feature vector (Figure 1d). With this modification, we were able to significantly improve the quality of the class conditional image generation on 1000-class ILSVRC2012 dataset (Russakovsky et al., 2015) with a single pair of a discriminator and generator (see the generated examples in Figure 2). Also, when we applied our model of cGANs to a super-resolution task, we were able to produce high quality super-resolution images that are more discriminative in terms of the accuracy of the label classifier than the cGANs based on concatenation, as well as the bilinear and the bicubic method. ",
+        "bbox": [
+            173,
+            648,
+            825,
+            773
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 THE ARCHITECTURE OF THE CGAN DISCRIMINATOR WITH A PROBABILISTIC MODEL ASSUMPTIONS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            794,
+            709,
+            828
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Let us denote the input vector by $_ { \\textbf { \\em x } }$ and the conditional information by $y ^ { 1 }$ . We also denote the cGAN discriminator by $D ( \\pmb { x } , \\pmb { y } ; \\theta ) : = \\mathcal { A } ( f ( \\pmb { x } , \\pmb { y } ; \\theta ) )$ , where $f$ is a function of $_ { \\textbf { \\em x } }$ and $y , \\theta$ is the parameters of $f$ , and $\\mathcal { A }$ is an activation function of the users’ choice. Using $q$ and $p$ to designate the true distributions and the generator model respectively, the standard adversarial loss for the ",
+        "bbox": [
+            174,
+            843,
+            825,
+            900
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "discriminator is given by: ",
+        "bbox": [
+            174,
+            103,
+            343,
+            118
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b4065a7a28673d291100074c26afe5d5907908ec4d8cb249c28af73c8a30530f.jpg",
+        "text": "$$\n\\mathcal { L } ( D ) = - E _ { q ( y ) } \\left[ E _ { q ( x | y ) } \\left[ \\log ( D ( x , y ) ) \\right] \\right] - E _ { p ( y ) } \\left[ E _ { p ( x | y ) } \\left[ \\log ( 1 - D ( x , y ) ) \\right] \\right] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            228,
+            126,
+            767,
+            146
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "with $\\mathcal { A }$ in $D$ representing the sigmoid function. By construction, the nature of the ‘critic’ $D$ significantly affects the performance of $G$ . A conventional way of feeding $\\textbf {  { y } }$ to $D$ until now has been to concatenate the vector $\\textbf {  { y } }$ to the feature vector $_ { \\textbf { \\em x } }$ , either at the input layer (Mirza $\\&$ Osindero, 2014; Denton et al., 2015; Saito et al., 2017), or at some hidden layer (Reed et al., 2016; Zhang et al., 2017; Perarnau et al., 2016; Dumoulin et al., 2017a; Sricharan et al., 2017) (see Figure 1a and Figure 1b). We would like to propose an alternative to this approach by observing the form of the optimal solution (Goodfellow et al., 2014) for the loss function, Eq. (1), can be decomposed into the sum of two log likelihood ratios: ",
+        "bbox": [
+            173,
+            151,
+            826,
+            263
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e9a64d425d67184bf13c2b813267070a30748cfe870c79155cfb50891ee648d7.jpg",
+        "text": "$$\nf ^ { * } ( x , y ) = \\log { \\frac { q ( x | y ) q ( y ) } { p ( x | y ) p ( y ) } } = \\log { \\frac { q ( y | x ) } { p ( y | x ) } } + \\log { \\frac { q ( x ) } { p ( x ) } } : = r ( y | x ) + r ( x ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            253,
+            272,
+            745,
+            306
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Now, we can model the log likelihood ratio $r ( \\pmb { y } | \\pmb { x } )$ and $r ( { \\pmb x } )$ by some parametric functions $f _ { 1 }$ and $f _ { 2 }$ respectively. If we make a standing assumption that $p ( \\pmb { y } | \\pmb { x } )$ and $q ( \\pmb { y } | \\pmb { x } )$ are simple distributions like those that are Gaussian or discrete log linear on the feature space, then, as we will show, the parametrization of the following form becomes natural: ",
+        "bbox": [
+            173,
+            314,
+            825,
+            371
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/37ff4e92cb29dd25d81c8ad44a839e566d26f0c89234d11b8d40424a3cdebb71.jpg",
+        "text": "$$\nf ( \\pmb { x } , \\pmb { y } ; \\theta ) : = f _ { 1 } ( \\pmb { x } , \\pmb { y } ; \\theta ) + f _ { 2 } ( \\pmb { x } ; \\theta ) = \\pmb { y } ^ { \\operatorname { T } } V \\phi ( \\pmb { x } ; \\theta _ { \\Phi } ) + \\psi ( \\phi ( \\pmb { x } ; \\theta _ { \\Phi } ) ; \\theta _ { \\Psi } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            253,
+            378,
+            741,
+            398
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $V$ is the embedding matrix of y, $, \\phi ( \\cdot , \\theta _ { \\Phi } )$ is a vector output function of $_ { \\textbf { \\em x } }$ , and $\\psi ( \\cdot , \\theta _ { \\Psi } )$ is a scalar function of the same $\\phi ( \\pmb { x } ; \\theta _ { \\Phi } )$ that appears in $f _ { 1 }$ (see Figure 1d). The learned parameters $\\theta = \\{ V , \\theta _ { \\Phi } , \\theta _ { \\Psi } \\}$ are to be trained to optimize the adversarial loss. From this point on, we will refer to this model of the discriminator as projection for short. In the next section, we would like to elaborate on how we can arrive at this form. ",
+        "bbox": [
+            173,
+            405,
+            825,
+            477
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 MOTIVATION BEHIND THE projection DISCRIMINATOR ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            498,
+            647,
+            515
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section, we will begin from specific, often recurring models and show that, with certain regularity assumption, we can write the optimal solution of the discriminator objective function in the form of (3). Let us first consider the a case of categorical variable. Assume that $y$ is a categorical variable taking a value in $\\{ 1 , \\ldots , C \\}$ , which is often common for a class conditional image generation task. The most popular model for $p ( y | \\mathbf { \\boldsymbol { x } } )$ is the following log linear model: ",
+        "bbox": [
+            173,
+            530,
+            825,
+            602
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4bed0f9e6af0cd25d091587679cf8dcb900911602bfe53c90453307267a2a15a.jpg",
+        "text": "$$\n\\log p ( y = c | \\pmb { x } ) : = \\pmb { v } _ { c } ^ { p \\mathrm { T } } \\phi ( \\pmb { x } ) - \\log Z ( \\phi ( \\pmb { x } ) ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            348,
+            609,
+            647,
+            628
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\begin{array} { r } { Z ( \\phi ( \\pmb { x } ) ) : = \\left( \\sum _ { j = 1 } ^ { C } \\exp \\left( \\pmb { v } _ { j } ^ { p \\mathrm { T } } \\phi ( \\pmb { x } ) \\right) \\right) } \\end{array}$ is the partition function, and $\\phi : \\pmb { x } \\mapsto \\mathbb { R } ^ { d ^ { L } }$ is the input to the final layer of the network model. Now, we assume that the target distribution $q$ can also be parametrized in this form, with the same choice of $\\phi$ . This way, the log likelihood ratio would take the following form; ",
+        "bbox": [
+            173,
+            637,
+            825,
+            704
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3bb1612882989e285c513600bafa37f1aba934cc21bba893d66e7d98bee0d34d.jpg",
+        "text": "$$\nr ( y | x ) = \\log \\frac { q ( y = c | x ) } { p ( y = c | x ) } = ( v _ { c } ^ { q } - v _ { c } ^ { p } ) ^ { \\mathrm { T } } \\phi ( x ) - ( \\log Z ^ { q } ( \\phi ( x ) ) - \\log Z ^ { p } ( \\phi ( x ) ) ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            225,
+            712,
+            772,
+            746
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "If we make the values of $( v _ { c } ^ { q } , v _ { c } ^ { p } )$ implicit and put $\\pmb { v } _ { c } : = ( \\pmb { v } _ { c } ^ { q } - \\pmb { v } _ { c } ^ { p } )$ , we can write $f _ { 1 } ( x , y = c ) =$ ${ \\pmb v } _ { c } ^ { \\mathrm { T } } \\phi ( { \\pmb x } )$ . Now, if we can put together the normalization constant $- \\left( \\log Z ^ { q } ( \\phi ( { \\pmb x } ) ) - \\log Z ^ { p } ( \\phi ( { \\pmb x } ) ) \\right)$ and $r ( { \\pmb x } )$ into one expression $\\bar { \\psi } ( \\phi ( { \\pmb x } ) )$ , we can rewrite the equation above as ",
+        "bbox": [
+            173,
+            753,
+            825,
+            796
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bca960cdde563cee042ffce15003faf9fcdfda36b1e2a594a7a2bf809cdb6f52.jpg",
+        "text": "$$\nf ( \\pmb { x } , \\pmb { y } ) : = \\pmb { y } ^ { \\mathrm { T } } V \\phi ( \\pmb { x } ) + \\psi ( \\phi ( \\pmb { x } ) ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            382,
+            805,
+            616,
+            824
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "by using $\\textbf {  { y } }$ to denote a one-hot vector of the label $y$ and using $V$ to denote the matrix consisting of the row vectors $v _ { c }$ . Most notably, this formulation introduces the label information via an inner product, as opposed to concatenation. The form (6) is indeed the form we proposed in (3). ",
+        "bbox": [
+            173,
+            832,
+            825,
+            875
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We can also arrive at the form (3) for unimodal continuous distributions $p ( \\pmb { y } | \\pmb { x } )$ as well. Let $\\textbf { \\textit { y } } \\in \\ \\mathbb { R } ^ { d }$ be a $d$ -dimensional continuous variable, and let us assume that conditional $q ( \\pmb { y } | \\pmb { x } )$ and $p ( \\pmb { y } | \\pmb { x } )$ are both given by Gaussian distributions, so that $q ( \\pmb { y } | \\pmb { x } ) = \\mathcal { N } ( \\pmb { y } | \\pmb { \\mu } _ { q } ( \\pmb { x } ) , \\pmb { \\Lambda } _ { q } ^ { - 1 } )$ and ",
+        "bbox": [
+            174,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "$p ( \\pmb { y } | \\pmb { x } ) = \\mathcal { N } ( \\pmb { y } | \\pmb { \\mu } _ { p } ( \\pmb { x } ) , \\pmb { \\Lambda } _ { p } ^ { - 1 } )$ where $\\pmb { \\mu } _ { q } ( \\pmb { x } ) : = W ^ { q } \\pmb { \\phi } ( \\pmb { x } )$ and $\\mu _ { p } ( { \\pmb x } ) : = W ^ { p } \\phi ( { \\pmb x } )$ . Then the log density ratio $r ( { \\pmb y } | { \\pmb x } ) = \\log \\big ( q ( { \\pmb y } | { \\pmb x } ) / p ( { \\pmb y } | { \\pmb x } ) \\big )$ is given by: ",
+        "bbox": [
+            169,
+            102,
+            825,
+            135
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ff1abe03c3bffc7ebd9b499c18354228b67e84dfd881f4343f9270a9dc5c5653.jpg",
+        "text": "$$\n\\begin{array} { r } { r ( \\pmb { y } | \\pmb { x } ) = \\log \\left( \\sqrt { \\frac { | \\mathbf { A } _ { q } | } { | \\mathbf { A } _ { p } | } } \\frac { \\exp ( - ( 1 / 2 ) ( \\pmb { y } - \\pmb { \\mu } _ { q } ( \\pmb { x } ) ) ^ { \\mathrm { T } } \\mathbf { A } _ { q } ( \\pmb { y } - \\pmb { \\mu } _ { q } ( \\pmb { x } ) ) ) } { \\exp ( - ( 1 / 2 ) ( \\pmb { y } - \\pmb { \\mu } _ { p } ( \\pmb { x } ) ) ^ { \\mathrm { T } } \\mathbf { A } _ { p } ( \\pmb { y } - \\pmb { \\mu } _ { p } ( \\pmb { x } ) ) ) } \\right) } \\\\ { = - \\frac { 1 } { 2 } \\pmb { y } ^ { \\mathrm { T } } \\left( \\pmb { \\Lambda } _ { q } - \\pmb { \\Lambda } _ { p } \\right) \\pmb { y } + \\pmb { y } ^ { \\mathrm { T } } ( \\pmb { \\Lambda } _ { q } W ^ { q } - \\pmb { \\Lambda } _ { p } W ^ { p } ) \\phi ( \\pmb { x } ) + \\psi ( \\phi ( \\pmb { x } ) ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            253,
+            141,
+            740,
+            217
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\psi ( \\phi ( { \\pmb x } ) )$ represents the terms independent of $\\textbf {  { y } }$ . Now, if we assume that $\\pmb { \\Lambda } _ { q } = \\pmb { \\Lambda } _ { p } : = \\pmb { \\Lambda }$ , we can ignore the quadratic term. If we further express $\\pmb { \\Lambda } _ { q } W ^ { q } - \\pmb { \\Lambda } _ { p } W ^ { p }$ in the form $V$ , we can arrive at the form (3) again. ",
+        "bbox": [
+            178,
+            220,
+            820,
+            263
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Indeed, however, the way that this regularization affects the training of the generator $G$ is a little unclear in its formulation. As we have repeatedly explained, our discriminator measures the divergence between the generator distribution $p$ and the target distribution $q$ on the assumption that $p ( \\pmb { y } | \\pmb { x } )$ and $q ( \\pmb { y } | \\pmb { x } )$ are relatively simple, and it is highly possible that we are gaining stability in the training process by imposing a regularity condition on the divergence measure. Meanwhile, however, the actual $p ( \\boldsymbol { y } | \\boldsymbol { x } )$ can only be implicitly derived from $p ( { \\pmb x } , { \\pmb y } )$ in computation, and can possibly take numerous forms other than the ones we have considered here. We must admit that there is a room here for an important theoretical work to be done in order to assess the relationship between the choice of the function space for the discriminator and training process of the generator. ",
+        "bbox": [
+            173,
+            270,
+            825,
+            396
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 COMPARISON WITH OTHER METHODS ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            416,
+            516,
+            431
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "As described above, (3) is a form that is true for frequently occurring situations. In contrast, incorporation of the conditional information by concatenation is rather arbitrary and can possibly include into the pool of candidate functions some sets of functions for which it is difficult to find a logical basis. Indeed, if the situation calls for multimodal $p ( \\pmb { y } | \\pmb { x } )$ , it might be smart not to use the model that we suggest here. Otherwise, however, we expect our model to perform better; in general, it is preferable to use a discriminator that respects the presumed form of the probabilistic model. ",
+        "bbox": [
+            174,
+            446,
+            823,
+            531
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Still another way to incorporate the conditional information into the training procedure is to directly manipulate the loss function. The algorithm of AC-GANs (Odena et al., 2017) use a discriminator $( D _ { 1 } )$ that shares a part of its structure with the classifier $( D _ { 2 } )$ , and incorporates the label information into the objective function by augmenting the original discriminator objective with the likelihood score of the classifier on both the generated and training dataset (see Figure 1c). Plug and Play Generative models (PPGNs) (Nguyen et al., 2017) is another approach for the generative model that uses an auxiliary classifier function. It is a method that endeavors to make samples from $p ( { \\pmb x } | { \\pmb y } )$ using an MCMC sampler based on the Langevin equation with drift terms consisting of the gradient of an autoencoder prior $p ( { \\pmb x } )$ and a pretrained auxiliary classifier $p ( y | \\mathbf { \\boldsymbol { x } } )$ . With these method, one can generate a high quality image. However, these ways of using auxiliary classifier may unwittingly encourage the generator to produce images that are particularly easy for the auxiliary classifier to classify, and deviate the final $p ( { \\pmb x } | { \\pmb y } )$ from the true $\\dot { \\mathbf { \\ b { q } } } ( \\mathbf { \\ b { x } } | \\mathbf { \\ b { y } } )$ . In fact, Odena et al. (2017) reports that this problem has a tendency to exacerbate with increasing number of labels. We were able to reproduce this phenomena in our experiments; when we implemented their algorithm on a dataset with 1000 class categories, the final trained model was able to generate only one image for most classes. Nguyen et al.’s PPGNs is also likely to suffer from the same problem because they are using an order of magnitude greater coefficient for the term corresponding to $p ( y | \\mathbf { \\boldsymbol { x } } )$ than for the other terms in the Langevin equation. ",
+        "bbox": [
+            173,
+            536,
+            825,
+            787
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "5 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            809,
+            331,
+            824
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In order to evaluate the effectiveness of our newly proposed architecture for the discriminator, we conducted two sets of experiments: class conditional image generation and super-resolution on ILSVRC2012 (ImageNet) dataset (Russakovsky et al., 2015). For both tasks, we used the ResNet (He et al., 2016b) based discriminator and the generator used in Gulrajani et al. (2017), and applied spectral normalization (Miyato et al., 2018) to the all of the weights of the discriminator to regularize the Lipschitz constant. For the objective function, we used the following hinge version of the standard adversarial loss (1) (Lim & Ye, 2017; Tran et al., 2017) ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            637,
+            118
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d4c663512107ea509105c31d42bf9bf3507112dcb3808ab568087a3be6eb5d81.jpg",
+        "text": "$$\n\\begin{array} { r l r } & { \\langle ( \\hat { G } , D ) = E _ { q ( y ) } [ E _ { q ( x | y ) } [ \\operatorname* { m a x } ( 0 , 1 - D ( \\pmb { x } , y ) ] ] + E _ { q ( y ) } [ E _ { p ( z ) } [ \\operatorname* { m a x } ( 0 , 1 + D ( \\hat { G } ( z , y ) , y ) ) ] ] , } & \\\\ & { \\langle ( G , \\hat { D } ) = - E _ { q ( y ) } [ E _ { p ( z ) } [ \\hat { D } ( G ( z , y ) , y ) ) ] ] , } & { ( 9 ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            181,
+            121,
+            830,
+            176
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where the last activation function $\\mathcal { A }$ of $D$ is identity function. $p ( z )$ is standard Gaussian distribution and $G ( z , y )$ is the generator network. For all experiments, we used Adam optimizer (Kingma & Ba, 2015) with hyper-parameters set to $\\alpha = 0 . 0 0 0 2 , \\beta _ { 1 } = 0 , \\beta _ { 2 } = 0 . 9$ . We updated the discriminator five times per each update of the generator. We will use concat to designate the models (Figure $1 \\mathsf { b } ) ^ { 2 }$ , and use projection to designate the proposed model (Figure 1d) . ",
+        "bbox": [
+            174,
+            178,
+            825,
+            248
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "5.1 CLASS-CONDITIONAL IMAGE GENERATION",
+        "text_level": 1,
+        "bbox": [
+            174,
+            263,
+            516,
+            279
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The ImageNet dataset used in the experiment of class conditional image generation consisted of 1,000 image classes of approximately 1,300 pictures each. We compressed each images to $1 2 8 \\times 1 2 8$ pixels. Unlike for AC-GANs3 we used a single pair of a ResNet-based generator and a discriminator. Also, we used conditional batch normalization (Dumoulin et al., 2017b; de Vries et al., 2017) for the generator. As for the architecture of the generator network used in the experiment, please see Figure 14 for more detail. Our proposed projection model discriminator is equipped with a ‘projection layer’ that takes inner product between the embedded one-hot vector $\\textbf {  { y } }$ and the intermediate output (Figure 14a). As for the structure of the the concat model discriminator to be compared against, we used the identical bulk architecture as the projection model discriminator, except that we removed the projection layer from the structure and concatenated the spatially replicated embedded conditional vector $\\textbf {  { y } }$ to the output of third ResBlock. We also experimented with AC-GANs as the current state of the art model. For AC-GANs, we placed the softmax layer classifier to the same structure shared by concat and projection. For each method, we updated the generator 450K times, and applied linear decay for the learning rate after 400K iterations so that the rate would be 0 at the end. For the comparative experiments, we trained the model for 450K iterations, which was ample for the training of concat to stabilize. AC-GANs collapsed prematurely before the completion of 450K iterations, so we reported the result from the peak of its performance ( 80K iterations). For all experiments throughout, we used the training over 450K iterations for comparing the performances. On a separate note, our method continued to improve even after 450K. We therefore also reported the inception score and FID of the extended training (850K iterations) for our method exclusively. See the table 1 for the exact figures. ",
+        "bbox": [
+            173,
+            290,
+            825,
+            580
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We used inception score (Salimans et al., 2016) for the evaluation of the visual appearance of the generated images. It is in general difficult to evaluate how ‘good’ the generative model is. Indeed, however, either subjective or objective, some definite measures of ‘goodness’ exists, and essential two of them are ‘diversity’ and the sheer visual quality of the images. One possible candidate for quantitative measure of diversity and visual appearance is FID (Heusel et al., 2017). We computed FID between the generated images and dataset images within each class, and designated the values as intra FIDs. More precisely, FID (Heusel et al., 2017) measures the 2-Wasserstein distance between the two distributions $q _ { y }$ and $p _ { y }$ , and is given by $F ( q _ { y } , p _ { y } ) \\ = \\ \\| { \\pmb { \\mu } } _ { q _ { y } } \\ - { \\pmb { \\mu } } _ { p _ { y } } \\| _ { 2 } ^ { 2 } \\ +$ trace $\\left( C _ { q _ { y } } + C _ { p _ { y } } - 2 ( C _ { q _ { y } } C _ { p _ { y } } ) ^ { 1 / 2 } \\right)$ , where $\\{ \\mu _ { q _ { y } } , C _ { q _ { y } } \\}$ , $\\{ \\mu _ { p _ { y } } , C _ { p _ { y } } \\}$ are respectively the mean and the covariance of the final feature vectors produced by the inception model (Szegedy et al., 2015) from the true samples and generated samples of class $y$ . When the set of generated examples have collapsed modes, the trace of $C _ { p _ { y } }$ becomes small and the trace term itself becomes large. In order to compute $C _ { q _ { y } }$ we used all samples in the training data belonging to the class of concern, and used 5000 generated samples for the computation of $C _ { p _ { y } }$ . We empirically observed in our experiments that intra FID is, to a certain extent, serving its purpose well in measuring the diversity and the visual quality. ",
+        "bbox": [
+            173,
+            588,
+            825,
+            813
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To highlight the effectiveness of our inner-product based approach (projection) of introducing the conditional information into the model, we compared our method against the state of the art ACGANs as well as the conventional incorporation of the conditional information via concatenation at hidden layer (concat). As we can see in the training curves Figure 3, projection outperforms inception score than concat throughout the training. Table 1 compares the intra class FIDs and the inception Score of the images generated by each method. The result shown here for the AC-GANs is that of the model at its prime in terms of the inception score, because the training collapsed at the end. We see that the images generated by projection have lower intra FID scores than both adversaries, indicating that the Wasserstein distance between the generative distribution by projection to the target distribution is smaller. For the record, our model performed better than other models on the CIFAR10 and CIFAR 100 as well (See Appendix A). ",
+        "bbox": [
+            174,
+            820,
+            825,
+            862
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/2192e95c50d255416dbc8d3cef02975c1b0b270d3f11d26a257f2780374ad431.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            452,
+            102,
+            781,
+            224
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/3d525ce3d861a0acb3d00d06bf586814dc5726773cf2522420243abf5bcfd5fb.jpg",
+        "image_caption": [
+            "Figure 3: Learning curves of Figure 4: Comparison of intra FID scores for projection cGANs with concat and projection concat, and AC-GANs on ImageNet. Each dot corresponds on ImageNet. to a class. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            222,
+            103,
+            375,
+            220
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/a691b7c832d61c4784b18168b06db0dcce33f15aff6f185b71665377f08ba6a2.jpg",
+        "table_caption": [
+            "Table 1: Inception score and intra FIDs on ImageNet. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>Inception Score</td><td>Intra FID</td></tr><tr><td>AC-GANs</td><td>28.5±.20</td><td>260.0</td></tr><tr><td>concat</td><td>21.1±.35</td><td>141.2</td></tr><tr><td>projection</td><td>29.7±.61</td><td>103.1</td></tr><tr><td>*projection (850K iteration)</td><td>36.8±.44</td><td>92.4</td></tr></table>",
+        "bbox": [
+            294,
+            319,
+            704,
+            411
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            438,
+            825,
+            549
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Figure 10a and 10b shows the set of classes for which (a) projection yielded results with better intra FIDs than the concat and (b) the reverse. From the top, the figures are listed in descending order of the ratio between the intra FID score between the two methods. Note that when the concat outperforms projection it only wins by a slight margin, whereas the projection outperforms concat by large margin in the opposite case. A quick glance on the cases in which the concat outperforms the projection suggests that the FID is in fact measuring the visual quality, because both sets looks similar to the human eyes in terms of appearance. Figure 5 shows an arbitrarily selected set of results yielded by AC-GANs from variety of ${ \\boldsymbol { z } } \\mathbf { s }$ . We can clearly observe the mode-collapse on this batch. This is indeed a tendency reported by the inventors themselves (Odena et al., 2017). ACGANs can generate easily recognizable (i.e classifiable) images, but at the cost of losing diversity and hence at the cost of constructing a generative distribution that is significantly different from the target distribution as a whole. We can also assess the low FID score of projection from different perspective. By construction, the trace term of intra FID measures the degree of diversity within the class. Thus, our result on the intra FID scores also indicates that that our projection is doing better in reproducing the diversity of the original. The GANs with the concat discriminator also suffered from mode-collapse for some classes (see Figure 6). For the set of images generated by projection, we were not able to detect any notable mode-collapse. ",
+        "bbox": [
+            173,
+            556,
+            825,
+            792
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Figure 7a shows the samples generated with the projection model for the classes on which the cGAN achieved lowest intra FID scores (that is the classes on which the generative distribution were particularly close to target conditional distribution), and Figure 7b the reverse. While most of the images listed in Figure 7a are of relatively high quality, we still observe some degree of mode-collapse. Note that the images in the classes with high FID are featuring complex objects like human; that is, one can expect the diversity within the class to be wide. However, we note that we did not use the most complicated neural network available for the experiments presented on this paper, because we prioritized the completion of the training within a reasonable time frame. It is very possible that, by increasing the complexity of the model, we will be able to further improve the visual quality of the images and the diversity of the distribution. In Appendix D, we list images of numerous classes generated by cGANs trained with our projection model. ",
+        "bbox": [
+            173,
+            799,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/537d54379a8fc36a8717dd27960d5ac73b4f9314a2c3c18cac52a12aaf215700.jpg",
+        "image_caption": [
+            "Figure 5: comparison of the images generated by (a) AC-GANs and (b) projection. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            341,
+            103,
+            661,
+            239
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/800874aca51e180b570c20cf4c25fdd54d2d22dd2e2591c73dc1debbad131650.jpg",
+        "image_caption": [
+            "Figure 6: Collapsed images on the concat model. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            189,
+            282,
+            808,
+            425
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            477,
+            825,
+            505
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Category Morphing With our new architecture, we were also able to successfully perform category morphism. When there are classes $y _ { 1 }$ and $y _ { 2 }$ , we can create an interpolated generator by simply mixing the parameters of conditional batch normalization layers of the conditional generator corresponding to these two classes. Figure 8 shows the output of the interpolated generator with the same $z$ . Interestingly, the combination is also yielding meaningful images when $y _ { 1 }$ and $y _ { 2 }$ are significantly different. ",
+        "bbox": [
+            174,
+            520,
+            825,
+            603
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Fine-tuning with the pretrained model on the ILSVRC2012 classification task. As we mentioned in Section 4, the authors of Plug and Play Generative model (PPGNs) (Nguyen et al., 2017) were able to improve the visual appearance of the model by augmenting the cost function with that of the label classifier. We also followed their footstep and augmented the original generator loss with an additional auxiliary classifier loss. As warned earlier regarding this type of approach, however, this type of modification tends to only improve the visual performance of the images that are easy for the pretrained model to classify. In fact, as we can see in Appendix B, we were able to improve the visual appearance the images with the augmentation, but at the cost of diversity. ",
+        "bbox": [
+            173,
+            617,
+            825,
+            729
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.2 SUPER-RESOLUTION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            746,
+            356,
+            760
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We also evaluated the effectiveness of (3) in its application to the super-resolution task. Put formally, the super-resolution task is to infer the high resolution RGB image of dimension $\\pmb { x } \\in \\mathbb { R } ^ { R _ { H } \\times R _ { H } \\times \\hat { \\mathbf { 3 } } }$ from the low resolution RGB image of dimension $\\pmb { y } \\in \\mathbb { R } ^ { R _ { L } \\times R _ { L } \\times 3 } ; R _ { H } > R _ { L }$ . This task is very much the case that we presumed in our model construction, because $p ( \\pmb { y } | \\pmb { x } )$ is most likely unimodal even if $p ( { \\pmb x } | { \\pmb y } )$ is multimodal. For the super-resolution task, we used the following formulation for discriminator function: ",
+        "bbox": [
+            173,
+            771,
+            825,
+            854
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fcddc66ff03303a47346117b581c0e0469e27dcc8bfef16654214c0a1d490917.jpg",
+        "text": "$$\nf ( { \\pmb x } , { \\pmb y } ; { \\theta } ) = \\sum _ { i , j , k } \\left( y _ { i j k } F _ { i j k } ( { \\phi } ( { \\pmb x } ; { \\theta } _ { \\Phi } ) ) \\right) + \\psi ( { \\phi } ( { \\pmb x } ; { \\theta } _ { \\Phi } ) ; { \\theta } _ { \\Psi } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            302,
+            856,
+            694,
+            891
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "where $\\begin{array} { r } { F ( \\phi ( \\pmb { x } ; \\theta _ { \\Phi } ) ) = V * \\phi ( \\pmb { x } ; \\theta _ { \\Phi } ) } \\end{array}$ where $V$ is a convolutional kernel and $^ *$ stands for convolution operator. Please see Figure 15 in the appendix section for the actual network architectures we used for this task. For this set of experiments, we constructed the concat model by removing the module in the projection model containing the the inner product layer and the accompanying convolution layer altogether, and simply concatenated $\\textbf {  { y } }$ to the output of the ResBlock preceding the inner product module in the original. As for the resolutions of the image datasets, we chose $R _ { H } = 1 2 8$ and $R _ { L } =$ 32, and created the low resolution images by applying bilinear downsampling on high resolution images. We updated the generators 150K times for all methods, and applied linear decay for the learning rate after 100K iterations so that the final learning rate was 0 at 150K-th iteration. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/55f061a8535be4d7c6a950904319ef9f483b316b7f577db5f89f5f58553f04ee.jpg",
+        "image_caption": [
+            "Figure 7: $1 2 8 \\times 1 2 8$ pixel images generated by the projection method for the classes with (a) bottom five FID scores and (b) top five FID scores. The string and the value above each panel are respectively the name of the corresponding class and the FID score. The second row in each panel corresponds to the original dataset. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            90,
+            825,
+            595
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            694,
+            825,
+            791
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Figure 9 shows the result of our super-resolution. The bicubic super-resolution is very blurry, and concat result is suffering from excessively sharp and rough edges. On the other hand, the edges of the images generated by our projection method are much clearer and smoother, and the image itself is much more faithful to the original high resolution images. In order to qualitatively compare the performances of the models, we checked MS-SSIM (Wang et al., 2003) and the classification accuracy of the inception model on the generated images using the validation set of the ILSVRC2012 dataset. As we can see in Table 2, our projection model was able to achieve high inception accuracy and high MS-SSIM when compared to bicubic and concat. Note that the performance of superresolution with concat model even falls behind those of the bilinear and bicubic super-resolutions in terms of the inception accuracy. Also, we used projection model to generate multiple batches of images with different random values of $_ { z }$ to be fed to the generator and computed the average of the logits of the inception model on these batches (MC samples). We then used the so-computed average logits to make prediction of the labels. With an ensemble over 10 seeds ( $1 0 \\mathrm { M C }$ in Table 2), we were able to improve the inception accuracy even further. This result indicates that our GANs are learning the super-resolution as an distribution, as opposed to deterministic function. Also, the success with the ensemble also suggests a room for a new way to improve the accuracy of classification task on low resolution images. ",
+        "bbox": [
+            173,
+            797,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/32cddc648d477a401d503a77d877fb1a55955b50be00a272260fa4fb9cd3c72f.jpg",
+        "image_caption": [
+            "Figure 8: Category morphing. More results are in the appendix section. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            83,
+            826,
+            505
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/982f6e35f5651b6e7284472287c38c7c48e16478b71f3d76f2bc8efef379992e.jpg",
+        "table_caption": [
+            "Table 2: Inception accuracy and MS-SSIM on different super-resolution methods. We picked up dataset images from the validation set. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>biliear</td><td>bicubic</td><td>concat</td><td> projection</td><td> projection (10 MC)</td></tr><tr><td>Inception Acc.(%)</td><td>23.1</td><td>31.4</td><td>11.0</td><td>35.2</td><td>36.4</td></tr><tr><td>MS-SSIM</td><td>0.835</td><td>0.859</td><td>0.829</td><td>0.878</td><td>1</td></tr></table>",
+        "bbox": [
+            215,
+            585,
+            781,
+            643
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            671,
+            825,
+            784
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            806,
+            318,
+            823
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Any specification on the form of the discriminator imposes a regularity condition for the choice for the generator distribution and the target distribution. In this research, we proposed a model for the discriminator of cGANs that is motivated by a commonly occurring family of probabilistic models. This simple modification was able to significantly improve the performance of the trained generator on conditional image generation task and super-resolution task. The result presented in this paper is strongly suggestive of the importance of the choice of the form of the discriminator and the design of the distributional metric. We plan to extend this approach to other applications of cGANs, such as semantic segmentation tasks and image to image translation tasks. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/de90c79076be5c3819a460e5e92251e8aeb7edc82d94dc65978c6b2cc7ffb58a.jpg",
+        "image_caption": [
+            "Figure 9: 32x32 to $1 2 8 \\mathrm { x } 1 2 8$ super-resolution by different methods "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            106,
+            825,
+            334
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            387,
+            823,
+            415
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            431,
+            326,
+            444
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We would like to thank the members of Preferred Networks, Inc., especially Richard Calland, Sosuke Kobayashi and Crissman Loomis, for helpful comments. We would also like to thank Shoichiro Yamaguchi, a graduate student of Kyoto University, for helpful comments. ",
+        "bbox": [
+            176,
+            455,
+            825,
+            497
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/bfa07cf264b9631ba798d785bec7f2dcb6e023453799ec788e16784907ed1782.jpg",
+        "image_caption": [
+            "Figure 10: Comparison of concat vs. projection. The value attached above each panel represents the achieved FID score. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            251,
+            825,
+            728
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            285,
+            117
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Martin Arjovsky, Soumith Chintala, and Leon Bottou. Wasserstein generative adversarial networks. In ´ ICML, pp. 214–223, 2017.   \nHarm de Vries, Florian Strub, Jer´ emie Mary, Hugo Larochelle, Olivier Pietquin, and Aaron C Courville. Mod- ´ ulating early visual processing by language. In NIPS, pp. 6576–6586, 2017.   \nEmily Denton, Soumith Chintala, Arthur Szlam, and Rob Fergus. Deep generative image models using a laplacian pyramid of adversarial networks. In NIPS, pp. 1486–1494, 2015.   \nVincent Dumoulin, Ishmael Belghazi, Ben Poole, Alex Lamb, Martin Arjovsky, Olivier Mastropietro, and Aaron Courville. Adversarially learned inference. In ICLR, 2017a.   \nVincent Dumoulin, Jonathon Shlens, and Manjunath Kudlur. A learned representation for artistic style. In ICLR, 2017b.   \nIan Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In NIPS, pp. 2672–2680, 2014.   \nIshaan Gulrajani, Faruk Ahmed, Martin Arjovsky, Vincent Dumoulin, and Aaron Courville. Improved training of wasserstein GANs. arXiv preprint arXiv:1704.00028, 2017.   \nKaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, 2016a.   \nKaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Identity mappings in deep residual networks. In European Conference on Computer Vision, pp. 630–645. Springer, 2016b.   \nMartin Heusel, Hubert Ramsauer, Thomas Unterthiner, Bernhard Nessler, Gunter Klambauer, and Sepp ¨ Hochreiter. Gans trained by a two time-scale update rule converge to a nash equilibrium. arXiv preprint arXiv:1706.08500, 2017.   \nTaeksoo Kim, Moonsu Cha, Hyunsoo Kim, Jungkwon Lee, and Jiwon Kim. Learning to discover cross-domain relations with generative adversarial networks. In ICML, pp. 1857–1865, 2017.   \nDiederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In ICLR, 2015.   \nChristian Ledig, Lucas Theis, Ferenc Huszar, Jose Caballero, Andrew Cunningham, Alejandro Acosta, Andrew ´ Aitken, Alykhan Tejani, Johannes Totz, Zehan Wang, and Wenzhe Shi. Photo-realistic single image superresolution using a generative adversarial network. In CVPR, 2017.   \nJae Hyun Lim and Jong Chul Ye. Geometric GAN. arXiv preprint arXiv:1705.02894, 2017.   \nMehdi Mirza and Simon Osindero. Conditional generative adversarial nets. arXiv preprint arXiv:1411.1784, 2014.   \nTakeru Miyato, Toshiki Kataoka, Masanori Koyama, and Yuichi Yoshida. Spectral normalization for generative adversarial networks. In ICLR, 2018.   \nAnh Nguyen, Jeff Clune, Yoshua Bengio, Alexey Dosovitskiy, and Jason Yosinski. Plug & play generative networks: Conditional iterative generation of images in latent space. In CVPR, 2017.   \nSebastian Nowozin, Botond Cseke, and Ryota Tomioka. f-GAN: Training generative neural samplers using variational divergence minimization. In NIPS, pp. 271–279, 2016.   \nAugustus Odena, Christopher Olah, and Jonathon Shlens. Conditional image synthesis with auxiliary classifier GANs. In ICML, pp. 2642–2651, 2017.   \nGuim Perarnau, Joost van de Weijer, Bogdan Raducanu, and Jose M Alvarez. Invertible conditional gans for ´ image editing. In NIPS Workshop on Adversarial Training, 2016.   \nAlec Radford, Luke Metz, and Soumith Chintala. Unsupervised representation learning with deep convolutional generative adversarial networks. In ICLR, 2016.   \nScott Reed, Zeynep Akata, Xinchen Yan, Lajanugen Logeswaran, Bernt Schiele, and Honglak Lee. Generative adversarial text to image synthesis. In ICML, pp. 1060–1069, 2016.   \nOlga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael Bernstein, Alexander C. Berg, and Li Fei-Fei. ImageNet Large Scale Visual Recognition Challenge. International Journal of Computer Vision (IJCV), 115(3):211–252, 2015. doi: 10.1007/s11263-015-0816-y.   \nMasaki Saito, Eiichi Matsumoto, and Shunta Saito. Temporal generative adversarial nets with singular value clipping. In ICCV, 2017.   \nTim Salimans, Ian Goodfellow, Wojciech Zaremba, Vicki Cheung, Alec Radford, and Xi Chen. Improved techniques for training GANs. In NIPS, pp. 2226–2234, 2016.   \nKumar Sricharan, Raja Bala, Matthew Shreve, Hui Ding, Kumar Saketh, and Jin Sun. Semi-supervised conditional GANs. arXiv preprint arXiv:1708.05789, 2017.   \nChristian Szegedy, Wei Liu, Yangqing Jia, Pierre Sermanet, Scott Reed, Dragomir Anguelov, Dumitru Erhan, Vincent Vanhoucke, and Andrew Rabinovich. Going deeper with convolutions. In CVPR, pp. 1–9, 2015.   \nSeiya Tokui, Kenta Oono, Shohei Hido, and Justin Clayton. Chainer: a next-generation open source framework for deep learning. In Proceedings of workshop on machine learning systems (LearningSys) in the twentyninth annual conference on neural information processing systems (NIPS), 2015.   \nAntonio Torralba, Rob Fergus, and William T Freeman. 80 million tiny images: A large data set for nonparametric object and scene recognition. IEEE transactions on pattern analysis and machine intelligence, 30 (11):1958–1970, 2008.   \nDustin Tran, Rajesh Ranganath, and David M Blei. Deep and hierarchical implicit models. arXiv preprint arXiv:1702.08896, 2017.   \nZhou Wang, Eero P Simoncelli, and Alan C Bovik. Multiscale structural similarity for image quality assessment. In Asilomar Conference on Signals, Systems and Computers, pp. 1398–1402, 2003.   \nHan Zhang, Tao Xu, Hongsheng Li, Shaoting Zhang, Xiaolei Huang, Xiaogang Wang, and Dimitris Metaxas. Stackgan: Text to photo-realistic image synthesis with stacked generative adversarial networks. In ICCV, 2017.   \nJun-Yan Zhu, Taesung Park, Phillip Isola, and Alexei A Efros. Unpaired image-to-image translation using cycle-consistent adversarial networks. In ICCV, 2017. ",
+        "bbox": [
+            171,
+            107,
+            828,
+            922
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            104,
+            825,
+            219
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A RESULTS OF CLASS CONDITIONAL IMAGE GENERATION ON CIFAR-10 AND CIFAR-100 ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            103,
+            792,
+            135
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "As a preliminary experiment, we compared the performance of conditional image generation on CIFAR-10 and CIFAR-100 3. For the discriminator and the generator, we reused the same architecture used in Miyato et al. (2018) for the task on CIFAR-10. For the adversarial objective functions, we used (9), and trained both machine learners with the same optimizer with same hyper parameters we used in Section 5. For our projection model, we added the projection layer to the discriminator in the same way we did in the ImageNet experiment (before the last linear layer). Our projection model achieved better performance than other methods on both CIFAR-10 and CIFAR-100. Concatenation at hidden layer (hidden concat) was performed on the output of second ResBlock of the discriminator. We tested hidden concat as a comparative method in our main experiments on ImageNet, because the concatenation at hidden layer performed better than the concatenation at the input layer (input concat) when the number of classes was large (CIFAR-100). ",
+        "bbox": [
+            173,
+            150,
+            825,
+            304
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "To explore how the hyper-parameters affect the performance of our proposed architecture, we conducted hyper-parameter search on CIFAR-100 about the Adam hyper-parameters (learning rate $\\alpha$ and 1st order momentum $\\beta _ { 1 . }$ ) for both our proposed architecture and the baselines. Namely, we varied each one of these parameters while keeping the other constant, and reported the inception scores for all methods including several versions of concat architectures to compare. We tested with concat module introduced at (a) input layer, (b) hidden layer, and at (c) output layer. As we can see in Figure 11, our projection architecture excelled over all other architectures for all choice of the parameters, and achieved the inception score of 9.53. Meanwhile, concat architectures were able to achieve all 8.82 at most. The best concat model in term of the inception score on CIFAR-100 was the hidden concat with $\\alpha = 0 . 0 0 0 2$ and $\\beta _ { 1 } = 0$ , which turns out to be the very choice of the parameters we picked for our ImageNet experiment. ",
+        "bbox": [
+            174,
+            310,
+            825,
+            463
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/baa3887b3395c30b05eed89fddb8582caa340696979b968f628597bc38a9b3a2.jpg",
+        "table_caption": [
+            "Table 3: The performance of class conditional image generation on CIFAR-10 (C10) and CIFAR100 (C100). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>Inception score C10</td><td>C100</td><td>FID C10 C100</td></tr><tr><td>(Real data)</td><td>11.24</td><td>14.79</td><td>7.60 8.94</td></tr><tr><td>AC-GAN</td><td>8.22</td><td>8.80</td><td>19.7 25.4</td></tr><tr><td> input concat</td><td>8.25</td><td>7.93</td><td>19.2 31.4</td></tr><tr><td>hidden concat</td><td>8.14</td><td>8.82</td><td>19.2 24.8</td></tr><tr><td>(ours) projection</td><td>8.62</td><td>9.04</td><td>17.5 23.2</td></tr></table>",
+        "bbox": [
+            320,
+            515,
+            678,
+            635
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/802214d0fe7e313b4d57605ad6721c042423588c1ef245e8806e4e681daed633.jpg",
+        "image_caption": [
+            "Figure 11: Inception scores on CIFAR-100 with different discriminator models varying hyperparameters ( $\\overset { \\cdot } { \\alpha }$ and $\\beta _ { 1 }$ ) of Adam optimizer. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            241,
+            656,
+            754,
+            875
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/f09ac1616c4b5401905190295c7ea6c94be9035139cf2497f1add48c249565d7.jpg",
+        "image_caption": [
+            "Figure 12: Effect of the finetuning with auxiliary classifier loss. Same coordinate in panel (a) and (b) corresponds to same value of $_ z$ "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            241,
+            106,
+            759,
+            470
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/dd205bd3e6d94a01d42fa265fc7bddeadf3975071db36d87b88f83b3c592cd6f.jpg",
+        "table_caption": [
+            "Table 4: Inception score and intra FIDs on ImageNet with a pretrained model on classification tasks for ILSVRC2012 dataset. $^ { \\ddag \\mathrm { N } }$ guyen et al. (2017) "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>Inception Score</td><td>Intra FID</td></tr><tr><td>PPGNs+</td><td>47.4</td><td>N/A</td></tr><tr><td>projection(finetuned)</td><td>210</td><td>54.2</td></tr></table>",
+        "bbox": [
+            315,
+            564,
+            679,
+            625
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "B OBJECTIVE FUNCTION WITH AN AUXILIARY CLASSIFIER COST ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            648,
+            728,
+            664
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "In this experiment, we followed the footsteps of Plug and Play Generative model (PPGNs) (Nguyen et al., 2017) and augmented the original generator loss with an additional auxiliary classifier loss. In particular, we used the losses given by : ",
+        "bbox": [
+            174,
+            678,
+            826,
+            722
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "equation",
+        "img_path": "images/78e468b0c7bcfba71446938c55770f085e6fdd2e6c76bbb703bdc9c3dae0493e.jpg",
+        "text": "$$\nL \\left( G , \\hat { D } , \\hat { p } _ { \\mathrm { p r e } } ( y | x ) \\right) = - E _ { q ( y ) } \\left[ E _ { p ( z ) } \\left[ \\hat { D } ( G ( z , y ) , y ) - L _ { C } ( \\hat { p } _ { \\mathrm { p r e } } ( y | G ( z , y ) ) ) \\right] \\right] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            212,
+            728,
+            758,
+            756
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "where $\\hat { p } _ { \\mathrm { p r e } } ( y | \\pmb { x } )$ is the fixed model pretrained for ILSVRC2012 classification task. For the actual experiment, we trained the generator with the original adversarial loss for the first 400K updates, and used the augmented loss for the last 50K updates. For the learning rate hyper parameter, we adopted the same values as other experiments we described above. For the pretrained classifier, we used ResNet50 model used in He et al. (2016a). Figure 12 compares the results generated by vanilla objective function and the results generated by the augmented objective function. As we can see in Table 4, we were able to significantly outperform PPGNs in terms of inception score. However, note that the images generated here are images that are easy to classify. The method with auxiliary classifier loss seems effective in improving the visual appearance, but not in training faithful generative model. ",
+        "bbox": [
+            173,
+            761,
+            825,
+            901
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/f238ed8ab5746c733f3277093cc6d7d4f752a7154edca57a4e2729674c208ddc.jpg",
+        "image_caption": [
+            "(b) ResBlock for the generator. ",
+            "Figure 13: Architecture of the ResBlocks used in all experiments. For the generator generator’s Resblock, conditional batch normalization layer (Dumoulin et al., 2017b; de Vries et al., 2017) was used in place of the standard batch normalization layer. For the ResBlock in the generator for the super resolution tasks that implements the upsampling, the random vector $_ z$ was fed to the model by concatenating the vector to the embedded low resolution image vector $\\textbf {  { y } }$ prior to the first convolution layer within the block. For the procedure of downsampling and upsampling, we followed the implementation by Gulrajani et al. (2017). For the discriminator, we performed downsampling (average pool) after the second conv of the ResBlock. For the generator, we performed upsampling before the first conv of the ResBlock. For the ResBlock that is performing the downsampling, we replaced the identity mapping with 1x1 conv layer followed by downsampling to balance the dimension. We did the essentially same for the Resblock that is performing the upsampling, except that we applied the upsampling before the 1x1 conv. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            253,
+            138,
+            745,
+            477
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/0962bcbc2b0a16a4cbcffc020e1ce5de4d97aeba750dbdaba02271b1d9825325.jpg",
+        "image_caption": [
+            "Figure 14: The models we used for the conditional image generation task. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            235,
+            290,
+            758,
+            713
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/7b40023e7636d6e1a08658472654e4381183c33e10a7a39b9b5bc264eeb17eb3.jpg",
+        "image_caption": [
+            "Figure 15: The models we used for the super resolution task. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            209,
+            244,
+            777,
+            761
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "D MORE RESULTS ON THE CONDITIONAL IMAGE GENERATION TASK ",
+        "text_level": 1,
+        "bbox": [
+            171,
+            102,
+            766,
+            118
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "image",
+        "img_path": "images/0f88dc2f1d5027682f9a8cbc76dc727127c9850e184973291aceaf1e5e03b3a7.jpg",
+        "image_caption": [
+            "Figure 16: $1 2 8 \\times 1 2 8$ generated examples on various categories with projection architecture. Each panel corresponds to a class. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            137,
+            823,
+            762
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "image",
+        "img_path": "images/c3c43653d190b9d75ed4a9dbf3c52426e9fa1f96f9619a209df81e9f13d0bf00.jpg",
+        "image_caption": [
+            "Figure 17: $1 2 8 \\times 1 2 8$ generated examples on various categories with projection architecture. Each panel corresponds to a class. From top to bottom, tench, papillon, grey whale, desktop computer, altar, whiskey jug and volcano. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            142,
+            823,
+            825
+        ],
+        "page_idx": 19
+    },
+    {
+        "type": "text",
+        "text": "E RESULTS OF CATEGORY MORPHING ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            102,
+            509,
+            118
+        ],
+        "page_idx": 20
+    },
+    {
+        "type": "image",
+        "img_path": "images/c39939af00d1bc3e38ace98572a248bb753f5e0040afc2c750739e6aa68d435e.jpg",
+        "image_caption": [
+            "Figure 18: Dog (Lhasa apso) to different categories "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            238,
+            127,
+            759,
+            834
+        ],
+        "page_idx": 20
+    },
+    {
+        "type": "image",
+        "img_path": "images/8dcf7a13ceec1ddeab354971f2ff49d4d26e578f77d9410c76b46963807f944c.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            238,
+            146,
+            758,
+            267
+        ],
+        "page_idx": 21
+    },
+    {
+        "type": "image",
+        "img_path": "images/9c0c5542463d8ec56923d821210439ac6bdcda4b65eb43285ced64c953798cad.jpg",
+        "image_caption": [
+            "(a) Hip to Yellow lady’s slipper "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            240,
+            286,
+            758,
+            409
+        ],
+        "page_idx": 21
+    },
+    {
+        "type": "image",
+        "img_path": "images/d8e5962ed122548ba7ade6a52a637b935d99506fc2ef25b5e540938e74af4c28.jpg",
+        "image_caption": [
+            "(b) Pirate ship to Yawl "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            240,
+            426,
+            758,
+            547
+        ],
+        "page_idx": 21
+    },
+    {
+        "type": "image",
+        "img_path": "images/35db938603fe17ce553f1c7b8cb4514a49e7342feb40dfd50cf6fd4cdbb781d0.jpg",
+        "image_caption": [
+            "(c) Yurt to Castle "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            240,
+            568,
+            758,
+            690
+        ],
+        "page_idx": 21
+    },
+    {
+        "type": "image",
+        "img_path": "images/d47dffd614af997cc2fe31335db973ea33bed8759b0c4099c0a12ffcd0256452.jpg",
+        "image_caption": [
+            "(d) Chiffonier to Chinese cabinet ",
+            "Figure 19: Morphing between different categories "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            238,
+            708,
+            759,
+            848
+        ],
+        "page_idx": 21
+    },
+    {
+        "type": "text",
+        "text": "F MORE RESULTS WITH SUPER-RESOLUTION ",
+        "bbox": [
+            173,
+            103,
+            563,
+            118
+        ],
+        "page_idx": 22
+    },
+    {
+        "type": "image",
+        "img_path": "images/8d2019cccf7dd72ba2705b4c679d73810796567bcba7ac7537deb84373a45ff8.jpg",
+        "image_caption": [
+            "Figure 20: $3 2 \\mathrm { x } 3 2 $ to $1 2 8 \\mathrm { x } 1 2 8$ super-resolution results "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            143,
+            820,
+            776
+        ],
+        "page_idx": 22
+    }
+]

parse/train/H1BLjgZCb/H1BLjgZCb.md

@@ -0,0 +1,330 @@
+# GENERATING NATURAL ADVERSARIAL EXAMPLES
+
+# Zhengli Zhao
+
+Dheeru Dua University of California Irvine, CA 92697, USA ddua@uci.edu
+
+University of California Irvine, CA 92697, USA zhengliz@uci.edu
+
+Sameer Singh University of California Irvine, CA 92697, USA sameer@uci.edu
+
+# ABSTRACT
+
+Due to their complex nature, it is hard to characterize the ways in which machine learning models can misbehave or be exploited when deployed. Recent work on adversarial examples, i.e. inputs with minor perturbations that result in substantially different model predictions, is helpful in evaluating the robustness of these models by exposing the adversarial scenarios where they fail. However, these malicious perturbations are often unnatural, not semantically meaningful, and not applicable to complicated domains such as language. In this paper, we propose a framework to generate natural and legible adversarial examples that lie on the data manifold, by searching in semantic space of dense and continuous data representation, utilizing the recent advances in generative adversarial networks. We present generated adversaries to demonstrate the potential of the proposed approach for black-box classifiers for a wide range of applications such as image classification, textual entailment, and machine translation. We include experiments to show that the generated adversaries are natural, legible to humans, and useful in evaluating and analyzing black-box classifiers.
+
+# 1 INTRODUCTION
+
+With the impressive success and extensive use of machine learning models in various securitysensitive applications, it has become crucial to study vulnerabilities in these systems. Dalvi et al. (2004) show that adversarial manipulations of input data often result in incorrect predictions from classifiers. This raises serious concerns regarding the security and integrity of existing machine learning algorithms, especially when even state-of-the-art models including deep neural networks have been shown to be highly vulnerable to adversarial attacks with intentionally worst-case perturbations to the input (Szegedy et al., 2014; Goodfellow et al., 2015; Kurakin et al., 2016; Papernot et al., 2016b; Kurakin et al., 2017). These adversaries are generated effectively with access to the gradients of target models, resulting in much higher successful attack rates than data perturbed by random noise of even larger magnitude. Further, training models by including such adversaries can provide machine learning models with additional regularization benefits (Goodfellow et al., 2015).
+
+Although these adversarial examples expose “blind spots” in machine learning models, they are unnatural, i.e. these worst-case perturbed instances are not ones the classifier is likely to face when deployed. Due to this, it is difficult to gain helpful insights into the fundamental decision behavior inside the black-box classifier: why is the decision different for the adversary, what can we change in order to prevent this behavior, and is the classifier robust to natural variations in the data when not in an adversarial scenario? Moreover, there is often a mismatch between the input space and the semantic space that we can understand. Changes to the input we may not think meaningful, like slight rotation or translation in images, often lead to substantial differences in the input instance. For example, Pei et al. (2017) show that minimal changes in the lighting conditions can fool automated-driving systems, a behavior adversarial examples are unable to discover. Due to the unnatural perturbations, these approaches cannot be applied to complex domains such as language, in which enforcing grammar and semantic similarity is difficult when perturbing instances. Therefore, existing approaches that find adversarial examples for text often result in ungrammatical sentences, as in the examples generated by Li et al. (2016), or require manual intervention, as in Jia & Liang (2017).
+
+In this paper, we introduce a framework to generate natural adversarial examples, i.e. instances that are meaningfully similar, valid/legible, and helpful for interpretation. The primary intuition behind our proposed approach is to perform the search for adversaries in a dense and continuous representation of the data instead of searching in the input data space directly. We use generative adversarial networks (GANs) (Goodfellow et al., 2014) to learn a projection to map normally distributed fixed-length vectors to data instances. Given an input instance, we search for adversaries in the neighborhood of its corresponding representation in latent space by sampling within a range that is recursively tightened. Figure 1 provides an example of adversaries for digit recognition. Given a multi-layer perceptron (MLP) for MNIST and an image from test data (Figure 1a), our approach generates a natural adversarial example (Figure 1e) which is classified incorrectly as $z '$ by the classifier. Compared to the adversary generated by the existing Fast Gradient Sign Method (FGSM) (Goodfellow et al., 2015) that adds gradient-based noise (Figures 1c and 1b), our adversary (Figure 1e) looks like a hand-written digit similar to the original input. Further, the difference (Figure 1d) provides some insight into the classifier’s behavior, such as the fact that slightly thickening (blue) the bottom stroke and thinning (red) the one above it, fools the classifier.
+
+![](images/a634c435db2dc9f45da75e2007e12906940986463122f6302d7f34beb1939ab4.jpg)  
+Figure 1: Adversarial examples. Given an instance (a), existing FGSM approach (Goodfellow et al., 2015) adds small perturbations in (b), that change the prediction of the model (to be “2”, in this case). Instead of such random-looking noise, our framework generates natural adversarial examples, such as in (e), where the differences, shown in (d) (with blue $^ { \prime } +$ , red/-), are meaningful changes to the strokes.
+
+We apply our approach to both image and text domains, and generate adversaries that are more natural and grammatical, semantically close to the input, and helpful to interpret the local behavior of black-box models. We present examples of natural adversaries for image classification, textual entailment, and machine translation. Experiments and human evaluation also demonstrate that our approach can help evaluate the robustness of black-box classifiers, even without labeled training data.
+
+# 2 FRAMEWORK FOR GENERATING NATURAL ADVERSARIES
+
+In this section, we describe the problem setup and details of our framework for generating natural adversarial examples of both continuous images and discrete text data. Given a black-box classifier $f$ and a corpus of unlabeled data $X$ , the goal here is to generate adversarial example $x ^ { * }$ for a given data instance $x$ that results in a different prediction, i.e. $f ( x ^ { * } ) \neq f ( x )$ . In general, the instance $x$ may not be in $X$ , but comes from the same underlying distribution ${ \mathcal P } _ { x }$ , which is the distribution we want to generate $x ^ { * }$ from as well. We want $x ^ { * }$ to be the nearest such instance to $x$ in terms of the manifold that defines the data distribution ${ \mathcal P } _ { x }$ , instead of in the original data representation.
+
+Unlike other existing approaches that search directly in the input space for adversaries, we propose to search in a corresponding dense representation of $z$ space. In other words, instead of finding the adversarial $x ^ { * }$ directly, we find the adversarial $z ^ { * }$ in an underlying dense vector space which defines the distribution ${ \mathcal P } _ { x }$ , and then map it back to $x ^ { * }$ with the help of a generative model. By searching for samples in the latent low-dimensional $z$ space and mapping them to $x$ space to identify the adversaries, we encourage these adversaries to be valid (legible for images, and grammatical for sentences) and semantically close to the original input.
+
+Background: Generative Adversarial Networks To tackle the problem described above, we need powerful generative models to learn a mapping from the latent low-dimensional representation to the distribution ${ \mathcal P } _ { x }$ , which we estimate using samples in $X$ . GANs are a class of such generative models that can be trained via procedures of minimax game between two competing networks (Goodfellow et al., 2014): given a large amount of unlabeled instances $X$ as training data, the generator $\mathcal { G } _ { \theta }$ learns to map some noise with distribution $p _ { z } ( z )$ where $z \in \mathbb { R } ^ { \mathrm { d } }$ to synthetic data that is as close to the training data as possible; on the other hand, the critic $\mathcal { C } _ { \omega }$ is trained to discriminate the output of the generator from real data samples from $X$ . The original objective function of GANs has been found to be hard to optimize in practice, for reasons theoretically investigated in Arjovsky & Bottou (2017). Arjovsky et al. (2017) refine the objective with Wasserstein-1 distance as:
+
+![](images/fbd590f51dff339cf1f3d2bcf07c11aa224881ffb40df40adc7c593a4eb5ccf8.jpg)  
+Figure 2: Training Architecture with a GAN and an Inverter. Loss of the inverter combines reconstruction error of $x$ with divergence between Gaussian distribution $z$ and $\mathcal { T } _ { \gamma } ( \mathcal { G } _ { \theta } ( z ) )$ .
+
+$$
+\operatorname* { m i n } _ { \theta } \operatorname* { m a x } _ { \omega } \mathbb { E } _ { x \sim p _ { x } ( x ) } [ \mathcal { C } _ { \omega } ( x ) ] - \mathbb { E } _ { z \sim p _ { z } ( z ) } [ \mathcal { C } _ { \omega } ( \mathcal { G } _ { \theta } ( z ) ) ] .
+$$
+
+Wasserstein GAN achieves improvement in the stability of learning and provides useful learning curves. A number of further improvements to the GAN framework have been introduced (Salimans et al., 2016; Arjovsky & Bottou, 2017; Gulrajani et al., 2017; Rosca et al., 2017) that we discuss in Section 6. We incorporate the structure of WGAN and relevant improvements as a part of our framework for generating natural examples close to the training data distribution, as we describe next.
+
+Natural Adversaries In order to represent natural instances of the domain, we first train a WGAN on corpus $X$ , which provides a generator $\mathcal { G } _ { \theta }$ that maps random dense vectors $z \in \mathbb { R } ^ { \mathrm { d } }$ to samples $x$ from the domain of $X$ . We separately train a matching inverter $\mathcal { T } _ { \gamma }$ to map data instances to corresponding dense representations. As in Figure 2, we minimize the reconstruction error of $x$ , and the divergence between sampled $z$ and $\mathcal { T } _ { \gamma } ( \mathcal { G } _ { \theta } ( z ) )$ to encourage the latent space to be normally distributed:
+
+$$
+\operatorname* { m i n } _ { \gamma } \mathbb { E } _ { x \sim p _ { x } ( x ) } \lVert \mathcal { G } _ { \theta } ( \mathbb { Z } _ { \gamma } ( x ) ) - x \rVert + \lambda \cdot \mathbb { E } _ { z \sim p _ { z } ( z ) } [ \mathcal { L } ( z , \mathbb { Z } _ { \gamma } ( \mathcal { G } _ { \theta } ( z ) ) ) ] .
+$$
+
+Using these learned functions, we define the natural adversarial example $x ^ { * }$ as the following:
+
+$$
+\mathcal G _ { \boldsymbol \theta } ( z ^ { * } ) \mathrm { w h e r e } z ^ { * } = \mathrm { a r g m i n } \| \tilde { z } - \mathcal T _ { \gamma } ( x ) \| \mathrm { s . t . } f ( \mathcal G _ { \boldsymbol \theta } ( \tilde { z } ) ) \neq f ( x ) .
+$$
+
+Instead of $x$ , we perturb its dense representation $z ^ { \prime } = \mathcal { T } _ { \gamma } ( x )$ , and use the generator to test whether a perturbation $\tilde { z }$ fools the classifier by querying $f$ with $\dot { \tilde { x } } = \mathcal { G } _ { \theta } ( \tilde { z } )$ . Figure 3 shows our generation process. A synthetic example is included for further intuition in Appendix A. As for the divergence $\mathcal { L }$ , we use $L _ { 2 }$ distance with $\lambda = . 1$ for images and Jensen-Shannon distance with $\lambda = 1$ for text data.
+
+Search Algorithms We propose two approaches to identify the adversary (pseudocode in Appendix B), both of which utilize the inverter to obtain the latent vector $z ^ { \prime } = \mathcal { T } _ { \gamma } ( x )$ of $x$ , and feed perturbations $\tilde { z }$ in the neighborhood of $z ^ { \prime }$ to the generator to generate natural samples $\tilde { x } = \mathcal { G } _ { \theta } ( \tilde { z } )$ . In iterative stochastic search (Algorithm 1), we incrementally increase the search range (by $\Delta r$ ) within which the perturbations $\tilde { z }$ are randomly sampled $N$ samples for each iteration), until we have generated samples $\check { x }$ that change the prediction. Among these samples $\check { x }$ , we choose the one which has the closest $z ^ { * }$ to the original $z ^ { \prime }$ as an adversarial example $x ^ { * }$ . To improve the efficiency beyond this naive search, we propose a coarse-to-fine strategy we call hybrid shrinking search (Algorithm 2). We first search for adversaries in a wide search range, and recursively tighten the upper bound of the search range with denser sampling in bisections. Extra iterative search steps are taken to further tighten the upper bound of the optimal $\Delta z$ . With the hybrid shrinking search in Algorithm 2, we observe a $4 \times$ speedup while achieving similar results as Algorithm 1. Both these search algorithms are sample-based and applicable to black-box classifiers with no need of access to their gradients. Further, they are guaranteed to find an adversary, i.e. one that upper bounds the optimal adversary.
+
+![](images/7bd1c82ecb7bef6ba77a957ce29e0c2547c954936bc007117d26479ee174d243.jpg)  
+Figure 3: Natural Adversary Generation. Given an instance $x$ , our framework generates natural adversaries by perturbing inverted $z ^ { \prime }$ and decoding perturbations $\tilde { z }$ via $\mathcal { G } _ { \theta }$ to query the classifier $f$ .
+
+![](images/a8bb26b880a446aed676fd7319d6dbcb20d8faad1ec9b6397a2e5bd116f67c2f.jpg)
+
+# 3 ILLUSTRATIVE EXAMPLES
+
+We demonstrate the potential of our approach (Algorithm 1) in generating informative, legible, and natural adversaries by applying it to a number of classifiers for both visual and textual domains.
+
+# 3.1 GENERATING IMAGE ADVERSARIES
+
+Image classification has been a focus for adversarial example generation due to the recent successes in computer vision. We apply our approach to two standard datasets, MNIST and LSUN, and present generated natural adversaries. We use $\Delta r = 0 . 0 1$ and $N = 5 0 0 0$ with model details in Appendix C.
+
+Handwritten Digits Scans of human-written text provide an intuitive definition of what is natural, i.e. do the generated images look like something a person would write? In other words, how would a human change a digit in order to fool a classifier? We train a WGAN with $z \in \mathbb { R } ^ { 6 4 }$ on 60,000 MNIST images following similar procedures as in Gulrajani et al. (2017), with the generator consisting of transposed convolutional layers and the critic consisting of convolutional layers. We include the inverter with fully connected layers on top of the critic’s last hidden layer. We train two target classifiers to generate adversaries against: Random Forests (RF) with 5 trees (test accuracy $9 0 . 4 5 \%$ ), and LeNet, as trained in LeCun et al. (1998) (test accuracy $9 8 . 7 1 \%$ ). We treat both these classifiers as black-boxes, and present the generated adversaries in Table 1 with examples of each digit (from test instances that the GAN or classifiers never observed). Adversaries generated by FGSM look like the original digits eroded by uninterpretable noise (these may not be representative of the approach, as changing $\epsilon$ for the method results in substantially different results). Our natural adversaries against both classifiers are quite similar to the original inputs in overall style and shape, yet provide informative insights into classifiers’ decision behavior around the input. Take the digit $\cdot 5 ^ { \mathrm { , } }$ as an example: dimming the vertical stroke can fool LeNet into predicting $\mathbf { \ddot { \delta } } ^ { 6 } 3 ^ { 9 }$ . Further we observe that adversaries against RF often look closer to the original images in overall shape than those against LeNet. Although generating as impressive natural adversaries against more accurate LeNet is difficult, it implies that compared to RF, LeNet requires more substantial changes to the inputs to be fooled; in other words, RF is less robust than LeNet in classification. We will return to this observation later.
+
+Church vs Tower We apply our approach to outdoor, color images of higher resolution. We choose the category of “Church Outdoor” in LSUN dataset (Yu et al., 2015), randomly sample the same amount of 126,227 images from the category of “Tower”, and resize them to resolution of $6 4 \times 6 4$
+
+![](images/50dfe89b67539b53c864ae1055490c0805c96f3f5d5028392a00fdaa59df7beb.jpg)
+
+Table 2: Adversarial examples against MLP classifier of LSUN by our approach. 4 original images each of “Church” and “Tower”, with their adversaries of the flipped class in the bottom row.   
+Table 3: Textual Entailment. For a pair of premise $( \mathbf { p } : )$ and hypothesis $( \mathbf { h } : )$ , we present the generated adversaries for three classifiers by perturbing the hypothesis $( \mathbf { h } ^ { \prime } : \mathbf { \epsilon } )$ . The last column provides the true label, followed by the changes in the prediction for each classifier.   
+
+<table><tr><td>Classifiers</td><td>Sentences</td><td>Label</td></tr><tr><td>Original</td><td>p : The man wearing blue jean shorts is grilling. h : The man is walking his dog.</td><td>Contradiction</td></tr><tr><td>Embedding</td><td>h&#x27; : The man is walking by the dog.</td><td>Contradiction →Entailment</td></tr><tr><td>LSTM</td><td>h&#x27;: The person is walking a dog.</td><td>Contradiction →Entailment</td></tr><tr><td>TreeLSTM</td><td>h&#x27;:A man is winning a race.</td><td>Contradiction →Neutral</td></tr></table>
+
+The training procedure is similar to MNIST, except that the generator and critic in WGAN are deep residual networks (He et al., 2016) and $z \in \mathbb { R } ^ { 1 2 8 }$ . We train an MLP classifier on these two classes with test accuracy of $7 1 . 3 \%$ . Table 2 presents original images for both classes and corresponding adversarial examples. From looking at these pairs, we can observe that the generated adversaries make changes that are natural for this domain. For example, to change the classifier’s prediction from “Church” to “Tower”, the adversaries sharpen the roof, narrow the buildings, or change a tree into a tower. We can observe similar behavior in the other direction: the image with the Eiffel Tower is changed to a “church” by converting a woman into a building, and narrowing the tower.
+
+# 3.2 GENERATING TEXT ADVERSARIES
+
+Generating grammatical and linguistically coherent adversarial sentences is a challenging task due to the discrete nature of text: adding imperceptible noise is impossible, and most actual changes to $x$ may not result in grammatical text. Prior approaches on generating textual adversaries (Li et al., 2016; Alvarez-Melis & Jaakkola, 2017; Jia & Liang, 2017) perform word erasures and replacements directly on text input space $x$ , using domain-specific rule based or heuristic based approaches, or require manual intervention. Our approach, on the other hand, performs perturbations in the continuous space $z$ , that has been trained to produce semantically and syntactically coherent sentences automatically.
+
+We use the adversarially regularized autoencoder (ARAE) (Zhao et al., 2017) for encoding discrete text into continuous codes. ARAE model encodes a sentence with an LSTM encoder into continuous code and then performs adversarial training on these codes to capture the data distribution. We introduce an inverter that maps these continuous codes into the Gaussian space of $z \in \mathbb { R } ^ { 1 0 0 }$ . We use a 4-layer strided CNN for the encoder as it yields more coherent sentences than LSTMs from the ARAE model, however LSTM works well as the decoder. We train two MLP models for the generator and the inverter, to learn mappings between noise and continuous codes. We train our framework on the Stanford Natural Language Inference (SNLI) (Bowman et al., 2015) data of 570k labeled human-written English sentence pairs with the same preprocessing as Zhao et al. (2017), using $\Delta r =$ 0.01 and $N = 1 0 0$ . We present details of the architecture and sample perturbations in Appendix D.
+
+Textual Entailment Textual Entailment (TE) is a task designed to evaluate common-sense reasoning for language, requiring both natural language understanding and logical inferences for text snippets. In this task, we classify a pair of sentences, a premise and a hypothesis, into three categories depending on whether the hypothesis is entailed by the premise, contradicts the premise, or is neutral to it. For instance, the sentence “There are children present” is entailed by the sentence “Children smiling and waving at camera”, while the sentence “The kids are frowning” contradicts it. We use our approach to generate adversaries by perturbing the hypothesis to deceive classifiers, keeping the premise unchanged. We train three classifiers of varying complexity, namely, an embedding classifier that is a single layer on top of the average word embeddings, an LSTM based model consisting of a single layer on top of the sentence representations, and TreeLSTM (Chen et al., 2017) that uses a hierarchical LSTM on the parses and is a top-performing classifier for this task. A few examples comparing the three classifiers are shown in Table 3 (more examples in Appendix D.1). Although all classifiers correctly predict the label, as the classifiers get more accurate (from embedding to LSTM to TreeLSTM), they require much more substantial changes to the sentences to be fooled.
+
+Table 4: Machine Translation. “Adversary” that introduces the word “stehen” into the translation.   
+
+<table><tr><td>Source Sentence (English)</td><td>Generated Translation (German)</td></tr><tr><td>s : A man and woman sitting on the sidewalk.</td><td>Ein Mann und eine Frau, die auf dem Bürgersteig sitzen.</td></tr><tr><td>s&#x27; : A man and woman stand on the bench.</td><td>Ein Mann und eine Frau stehen auf der Bank.</td></tr></table>
+
+Table 5: “Adversaries” to find dropped verbs. The left column contains the original sentence s and its adversary $s ^ { \prime }$ , while the right contains their translations, with English translation in red.   
+
+<table><tr><td>Source Sentence (English)</td><td>Generated Translation (German)</td></tr><tr><td>s : People sitting in a dim restaurant eating. s&#x27; : People sitting in a living room eating.</td><td>Leute,die in einem dim Restaurant essen sitzen. Leute,die in einem Wohnzimmeressen sitzen.</td></tr><tr><td>s : Elderly people walking down a city street. s&#x27; : A man walking down a street playing.</td><td>(People sitting in a living room.) Altere Menschen,die eine StadtstraBe hinuntergehen. Ein Mann,der eine StraBe entlang spielt. (A man playing along a street.)</td></tr></table>
+
+Machine translation We consider machine translation not only because it is one of the most successful applications of neural approaches to NLP, but also since most practical translation systems lie behind black-box access APIs. The notion of adversary, however, is not so clear here as the output of a translation system is not a class. Instead, we define adversary for machine translation relative to a probing function that tests the translation for certain properties, ones that may lead to linguistic insights into the languages, or detect potential vulnerabilities. We use the same generator and inverter as in entailment, and find such “adversaries” via API access to the currently deployed Google Translate model (as of October 15, 2017) from English to German.
+
+First, let us consider the scenario in which we want to generate adversarial English sentences such that a specific German word is introduced into the German translation. The probing function here would test the translation for the presence of that word, and we would have found an adversary (an English sentence) if the probing function passes for a translation. We provide an example of such a probing function that introduces the word “stehen” (“stand” in English) to the translation in Table 4 (more examples in Appendix D.2). Since the translation system is quite strong, such adversaries are not surfacing the vulnerabilities of the model, but instead can be used as a tool to understand or learn different languages (in this example, help a German speaker learn English).
+
+We can design more complex probing functions as well, especially ones that target specific vulnerabilities of the translation system. Let us consider translations of English sentences that contain two active verbs, e.g. “People sitting in a restaurant eating”, and see that the German translation has the two verbs as well, “essen” and “sitzen”, respectively. We now define a probing function that passes only if the perturbed English sentence $s ^ { \prime }$ contains both the verbs, but the translation only has one of them. An adversary for such a probing function will be an English sentence $( s ^ { \prime } )$ that is similar to the original sentence (s), but for some reason, its translation is missing one of the verbs. Table 5 presents examples of generated adversaries using such a probing function (with more in Appendix D.2). For example, one that tests whether “essen” is dropped from the translation when its English counterpart “eating” appears in the source sentence (“People sitting in a living room eating.”). These adversaries thus suggest a vulnerability in Google’s English to German translation system: a word acting as a gerund in English often gets dropped from the translation.
+
+Table 6: Statistics of adversaries against models for both MNIST and TE. We include the average $\Delta z$ for the adversaries and the proportion where each classifier’s adversary has the largest $\Delta z$ compared to the others for the same instance (significant with $p < 0 . 0 0 0 5$ using the sign test). The higher values correspond to stronger robustness, as is demonstrated by higher test accuracy.   
+
+<table><tr><td colspan="2"></td><td>Average △z</td><td>P(largest △z)</td><td>Test accuracy (%)</td></tr><tr><td rowspan="2">MNIST</td><td>Random Forests</td><td>1.24</td><td>0.22</td><td>90.45</td></tr><tr><td>LeNet</td><td>1.61</td><td>0.78</td><td>98.71</td></tr><tr><td rowspan="3">Entailment</td><td>Embeddings</td><td>0.12</td><td>0.15</td><td>62.04</td></tr><tr><td>LSTM</td><td>0.14</td><td>0.18</td><td>69.60</td></tr><tr><td>TreeLSTM</td><td>0.26</td><td>0.66</td><td>89.04</td></tr></table>
+
+![](images/c3d115fc778a6779f6074b50f9feffab09db6f379f1b040af37910cf9997b2aa.jpg)  
+Figure 4: Classifier accuracy and average $\Delta z$ of their adversaries. In (a) and (b) we vary the number of neurons and dropout rate, respectively. In (c) we present the correlation between accuracy and average $\Delta z$ for 80 different classifiers. (d) shows adversaries for an input image, against a set of classifiers with a single hidden layer, but varying number of neurons.
+
+# 4 EXPERIMENTS
+
+In this section, we demonstrate that our approach can be utilized to compare and evaluate the robustness of black-box models even without labeled data. We present experimental results on images and text data with evaluations from both statistical analysis and pilot user studies.
+
+Robustness of Black-box Classifiers We apply our framework to various black-box classifiers for both images and text, and observe that it is useful for evaluating and interpreting these models via comparisons. The primary intuition behind this analysis is that more accurate classifiers often require more substantial changes to the instance to change their predictions, as noted in the previous section. In the following experiments, we apply the more efficient hybrid shrinking search (Algorithm 2).
+
+In order to quantify the extent of change for an adversary, the change in the original $x$ representation may not be meaningful, such as RMSE of the pixels or string edit distances, for the same reason we are generating natural adversaries: they do not correspond to the semantic distance underlying the data manifold. Instead we use the distance of the adversary in the latent space, i.e. $\Delta z = \| \dot { z ^ { * } } - \bar { z } ^ { \prime } \|$ , in order to measure how much each adversary is modified to change the classifier prediction. We also consider the set of adversaries generated for each instance against a group of classifiers, and count how many times the adversary of each classifier has the highest $\Delta z$ . We present these statistics in Table 6 for both MNIST (over 100 test images, 10 per digit) and Textual Entailment (over 1260 test sentences), against the classifiers we described in Section 3. For both the tasks, we observe that more accurate classifiers require larger changes to the inputs (by both measures), indicating that generating such adversaries, even for unlabeled data, can evaluate the accuracy of black-box classifiers.
+
+Table 7: Pilot study with MNIST   
+
+<table><tr><td></td><td>RF</td><td>LeNet</td></tr><tr><td>Looks handwritten?</td><td>0.88</td><td>0.71</td></tr><tr><td>Which closer to original?</td><td>0.87</td><td>0.13</td></tr></table>
+
+Table 8: Pilot study with Textual Entailment   
+
+<table><tr><td></td><td>LSTM</td><td>TreeLSTM</td></tr><tr><td>Is adversary grammatical?</td><td>0.86</td><td>0.78</td></tr><tr><td>Is it similar to the original?</td><td>0.81</td><td>0.58</td></tr></table>
+
+We now consider evaluation on a broader set of classifiers, and study the effect of changing hyperparameters of models on the results (focusing on MNIST). We train a set of neural networks with one hidden layer by varying the number of neurons exponentially from 2 to 1024. In Figure 4a, we observe that the average $\Delta z$ of adversaries against these models has a similar trend as their test accuracy. The generated adversaries for a single digit “3” in Figure 4d verify this observation: the adversaries become increasingly different from the original input as classifiers become more complex. We provide similar analysis by fixing the model structure but varying the dropout rates from 0.9 to 0.0 in Figure 4b, and observe a similar trend. To confirm that this correlation holds generally, we train 80 total classifiers that differ in the layer sizes, regularization, and amount of training data, and plot their test set accuracy against the average magnitude of change in their adversaries in Figure 4c. Given this strong correlation, we are confident that our framework for generating natural adversaries can be useful for automatically evaluating black-box classifiers, even in the absence of labeled data.
+
+Human Evaluation We carry out a pilot study with human subjects to evaluate how natural the generated adversaries are, and whether the adversaries they think are similar to the original ones correspond with the less accurate classifiers (as in the evaluation above). For both image classification and textual entailment, we select a number of instances randomly, generate adversaries for each against two classifiers, and present a questionnaire to the subjects that evaluates: (1) how natural or legible each generated adversary is; (2) which of the two adversaries is closer to the original instance.
+
+For hand-written digits from MNIST, we pick 20 images (2 for each digit), generate adversaries against RF and LeNet (two adversaries for each image), and obtain 13 responses for each of the questions. In Table 7, we see that the subjects agree that our generated adversaries are quite natural, and also, they find RF adversaries to be much closer to the original image than LeNet (i.e. more accurate classifiers, as per test accuracy on their provided labels, have more distant adversaries). We also compare adversaries against LeNet generated by FGSM and our approach, and find that $7 8 \%$ of the time the subjects agree that our adversaries make changes to the original images that are more natural (it is worth noting that FGSM is not applicable to RF for comparison). We carry out a similar pilot study for the textual entailment task to evaluate the quality of the perturbed sentences. We present a set of 20 pairs of sentences (premise and hypothesis), and adversarial hypotheses against both LSTM and TreeLSTM classifiers, and receive 4 responses for each of the questions above. The results in Table 8 also validate our previous results: the generated sentences are found to be grammatical and legible, and classifiers that need more substantial changes to the hypothesis tend to be more accurate. We leave a more detailed user study for future work.
+
+# 5 RELATED WORK
+
+The fast gradient sign method (FGSM) has been proposed in Goodfellow et al. (2015) to generate adversarial examples fast rather than optimally. Intuitively, the method shifts the input by $\epsilon$ in the direction of minimizing the cost function. Kurakin et al. (2016) propose a simple extension of FGSM by applying it multiple times, which generates adversarial examples with a higher attack rate, but the underlying idea is the same. Another method known as the Jacobian-based saliency map attack (JSMA) has been introduced by Papernot et al. (2016b). Unlike FGSM, JSMA generates adversaries by greedily modifying the input instance feature-wise. A saliency map is computed with gradients to indicate how important each feature is for the prediction, and the most important one is modified repeatedly until the instance changes the resulting classification. Moreover, it has been observed in practice that adversarial examples designed against a model are often likely to successfully attack another model for the same task that has not been given access to. This transferability property of adversarial examples makes it more practical to attack and evaluate deployed machine learning systems in realistic scenarios (Papernot et al., 2016a; 2017).
+
+All these attacks above are based on gradients with access to the parameters of differentiable classifiers. Moosavi-Dezfooli et al. (2017) try to find a single noise vector which can cause imperceptible changes in most of data points, and meanwhile reduce the classifier accuracy significantly. Our method is capable of generating adversaries against black-box classifiers, even those without gradients such as Random Forests. Also, the noise added by these methods is uninterpretable, while the natural adversaries generated by our approach provide informative insights into classifiers’ decision behavior.
+
+Due to the discrete domains involved in text, adversaries for text have received less attention. Jia & Liang (2017) generate adversarial examples for evaluating reading comprehension systems with predefined rules and candidate words for substitution after analyzing and rephrasing the input sentences. Li et al. (2016) introduce a framework to understand neural network through different levels of representation erasure. However, erasure of words or phrases directly often harms text integrity, resulting in semantically or grammatically incorrect sentences. Ribeiro et al. (2018) replace tokens by random words of the same POS tag with probability proportional to embedding similarity. Belinkov & Bisk (2018) explore approaches to increase the robustness of character-based machine translation models on text corrupted with character-level noise. With the help of expressive generative models, our approach instead perturbs the latent coding of sentences, resulting in legible generated sentences that are grammatical and semantically similar to the original input. These merits make our framework suitable for text applications such as sentiment analysis, textual entailment, and machine translation.
+
+# 6 DISCUSSION AND FUTURE WORK
+
+Our framework builds upon GANs as the generative models, and thus the capabilities of GANs directly effects the quality of generated examples. In visual domains, although there have been lots of appealing results produced by GANs, the training is well known to be brittle. Many recent approaches address how to improve the training stability and the objective function of GANs (Salimans et al., 2016; Arjovsky et al., 2017). Gulrajani et al. (2017) further improve the training of WGAN with regularization of gradient penalty instead of weight clipping. In our practice, we observe that we need to carefully balance the capacities of the generator, the critic, and the inverter that we introduced, to avoid situations such as model collapse. For natural languages, because of the discrete nature and non-differentiability, applications related to text generation have been relatively less studied. Zhao et al. (2017) propose to incorporate a discrete structure autoencoder with continuous code space regularized by WGAN for text generation. Given that there are some concerns about whether GANs actually learn the distribution (Arora & Zhang, 2017), it is worth noting that we can also incorporate other generative models such as Variational Auto-Encoders (VAEs) (Kingma & Welling, 2014) into our framework, as used in Hu et al. (2017) to generate text with controllable attributes, which we will explore in the future. We focus on GANs because adversarial training often results in higher quality images, while VAEs tend to produce blurrier ones (Goodfellow, 2016). We also plan to apply the fusion and variant of VAEs and GANs such as $\alpha$ -GAN in Rosca et al. (2017) and Wasserstein Auto-Encoders in Tolstikhin et al. (2018). Note that as more advanced GANs are introduced to address these issues, they can be directly incorporated into our framework.
+
+Our iterative stochastic search algorithm for identifying adversaries is computationally expensive since it is based on naive sampling and local-search. Search based on gradients such as FGSM are not applicable to our setup because of black-box classifiers and discrete domain applications. We improve the efficiency with hybrid shrinking search by using a coarse-to-fine strategy that finds the upper-bounds by using fewer samples, and then performs finer search in the restricted range. We observe around $4 \times$ speedup with this search while achieving similar results as the iterative search. The accuracy of our inverter mapping the input to its corresponding dense vector in latent space is also important for searching adversaries in the right neighborhood. In our experiments, we find that fine-tuning the latent vector produced by the inverter with a fixed GAN can further refine the generated adversarial examples, and we will investigate other such extensions of the search in future. There is an implicit assumption in this work that the generated samples are within the same class if the added perturbations are small enough, and the generated samples look as if they belong to different classes when the perturbations are large. However, note that it is also the case for FGSM and other such approaches: when their $\epsilon$ is small, the noise is imperceptible; but with a large $\epsilon$ , one often finds noisy instances that might be in a different class (see Table 1, digit 8 for an example). While we do observe this behavior in some cases, the corresponding classifiers require much more substantial changes to the input, which is why we can utilize our approach to evaluate black-box classifiers.
+
+# 7 CONCLUSIONS
+
+In this paper, we propose a framework for generating natural adversaries against black-box classifiers, and apply the same approach to both visual and textual domains. We obtain adversaries that are legible, grammatical, and meaningfully similar to the input. We show that these natural adversaries can help in interpreting the decision behavior and evaluating the accuracy of black-box classifiers even in absence of labeled training data. We use our approach, built upon recent work in GANs, to generate adversaries for a wide range of applications including image classification, textual entailment, and machine translation (via the Google Translate API). Code used to generate such natural adversaries is available at https://github.com/zhengliz/natural-adversary.
+
+# ACKNOWLEDGMENTS
+
+We would like to thank Ananya, Casey Graff, Eric Nalisnick, Pouya Pezeshkpour, Robert Logan, and the anonymous reviewers for the discussions and feedback on earlier versions. We would also like to thank Ishaan Gulrajani and Junbo Jake Zhao for making their code available. This work is supported in part by Adobe Research and in part by FICO. The views expressed are those of the authors and do not reflect the official policy or position of the funding agencies.
+
+# REFERENCES
+
+David Alvarez-Melis and Tommi S. Jaakkola. A causal framework for explaining the predictions of black-box sequence-to-sequence models. In Empirical Methods in Natural Language Processing (EMNLP), 2017.
+
+Martin Arjovsky and Leon Bottou. Towards principled methods for training generative adversarial ´ networks. In International Conference on Learning Representations (ICLR), 2017.
+
+Martin Arjovsky, Soumith Chintala, and Leon Bottou. Wasserstein generative adversarial networks.´ In International Conference on Machine Learning (ICML), 2017.
+
+Sanjeev Arora and Yi Zhang. Do gans actually learn the distribution? an empirical study. arXiv preprint 1706.08224, 2017.
+
+Yonatan Belinkov and Yonatan Bisk. Synthetic and natural noise both break neural machine transla tion. In International Conference on Learning Representations (ICLR), 2018.
+
+Samuel R. Bowman, Gabor Angeli, Christopher Potts, and Christopher D. Manning. A large annotated corpus for learning natural language inference. In Empirical Methods in Natural Language Processing (EMNLP), 2015.
+
+Qian Chen, Xiaodan Zhu, Zhen-Hua Ling, Si Wei, Hui Jiang, and Diana Inkpen. Enhanced lstm for natural language inference. In Association for Computational Linguistics (ACL), 2017.
+
+Nilesh Dalvi, Pedro Domingos, Sumit Sanghai, and Deepak Verma. Adversarial classification. In Proceedings of the ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, 2004.
+
+Ian Goodfellow. NIPS 2016 Tutorial: Generative Adversarial Networks. arXiv preprint 1701.00160, 2016.
+
+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 (NIPS), 2014.
+
+Ian Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. In International Conference on Learning Representations (ICLR), 2015.
+
+Ishaan Gulrajani, Faruk Ahmed, Martin Arjovsky, Vincent Dumoulin, and Aaron Courville. Improved training of wasserstein gans. In Advances in Neural Information Processing Systems (NIPS), 2017.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2016.
+
+Zhiting Hu, Zichao Yang, Xiaodan Liang, Ruslan Salakhutdinov, and Eric P. Xing. Toward controlled generation of text. In International Conference on Machine Learning (ICML), 2017.
+
+Robin Jia and Percy Liang. Adversarial examples for evaluating reading comprehension systems. In Empirical Methods in Natural Language Processing (EMNLP), 2017.
+
+Diederik P. Kingma and Max Welling. Stochastic gradient vb and the variational auto-encoder. In International Conference on Learning Representations (ICLR), 2014.
+
+Alexey Kurakin, Ian Goodfellow, and Samy Bengio. Adversarial examples in the physical world. arXiv preprint 1607.02533, 2016.
+
+Alexey Kurakin, Ian Goodfellow, and Samy Bengio. Adversarial machine learning at scale. In International Conference on Learning Representations (ICLR), 2017.
+
+Yann LeCun, Leon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to ´ document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998.
+
+Jiwei Li, Will Monroe, and Dan Jurafsky. Understanding neural networks through representation erasure. arXiv preprint 1612.08220, 2016.
+
+Seyed-Mohsen Moosavi-Dezfooli, Alhussein Fawzi, Omar Fawzi, and Pascal Frossard. Universal adversarial perturbations. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2017.
+
+Nicolas Papernot, Patrick McDaniel, and Ian Goodfellow. Transferability in machine learning: from phenomena to black-box attacks using adversarial samples. arXiv preprint 1605.07277, 2016a.
+
+Nicolas Papernot, Patrick McDaniel, Somesh Jha, Matt Fredrikson, Z. Berkay Celik, and Ananthram Swami. The limitations of deep learning in adversarial settings. In IEEE European Symposium on Security and Privacy, 2016b.
+
+Nicolas Papernot, Patrick McDaniel, Ian Goodfellow, Somesh Jha, Z. Berkay Celik, and Ananthram Swami. Practical black-box attacks against machine learning. In Proceedings of the ACM on Asia Conference on Computer and Communications Security, 2017.
+
+Kexin Pei, Yinzhi Cao, Junfeng Yang, and Suman Jana. Deepxplore: Automated whitebox testing of deep learning systems. In the ACM Symposium on Operating Systems Principles, 2017.
+
+Marco Tulio Ribeiro, Sameer Singh, and Carlos Guestrin. Anchors: High-precision model-agnostic explanations. In AAAI Conference on Artificial Intelligence, 2018.
+
+Mihaela Rosca, Balaji Lakshminarayanan, David Warde-Farley, and Shakir Mohamed. Variational approaches for auto-encoding generative adversarial networks. arXiv preprint 1706.04987, 2017.
+
+Tim Salimans, Ian Goodfellow, Wojciech Zaremba, Vicki Cheung, Alec Radford, and Xi Chen. Improved techniques for training gans. In Advances in Neural Information Processing Systems (NIPS), 2016.
+
+Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. In International Conference on Learning Representations (ICLR), 2014.
+
+Ilya Tolstikhin, Olivier Bousquet, Sylvain Gelly, and Bernhard Schoelkopf. Wasserstein auto-encoders. In International Conference on Learning Representations (ICLR), 2018.
+
+Fisher Yu, Yinda Zhang, Shuran Song, Ari Seff, and Jianxiong Xiao. Lsun: Construction of a large-scale image dataset using deep learning with humans in the loop. arXiv preprint 1506.03365, 2015.
+
+Junbo Jake Zhao, Yoon Kim, Kelly Zhang, Alexander M. Rush, and Yann LeCun. Adversarially regularized autoencoders. arXiv preprint 1706.04223, 2017.
+
+# APPENDIX
+
+# A ILLUSTRATION WITH SYNTHETIC DATA
+
+As shown in Figure 5 with a toy example of synthetic data, we can effectively map data instance $x$ to its corresponding latent dense vector $z ^ { \prime }$ with the help of the inverter via ${ \mathcal { T } } _ { \gamma } ( x )$ , and then reconstruct $x$ with the help of the generator via $\mathcal { G } _ { \boldsymbol { \theta } } ( \mathcal { T } _ { \boldsymbol { \gamma } } ( \boldsymbol { x } ) )$ . For a naive classifier with the horizontal line as decision boundary, adversarial examples should be points above the line given input data $x$ in Figure 5c. By searching in corresponding latent space, our approach finds $x ^ { * }$ on the left as a natural adversary because it is the closest one in semantic space (along the curve trace) and it exists within the data manifold. However, the gradient-based approaches may find the $x ^ { * }$ right above $x$ as adversarial in input space regardless of the actual data distribution.
+
+# B ALGORITHMS
+
+Algorithm 1 shows the pseudocode of the iterative search of our framework. Starting from the corresponding $z$ of the input instance $x$ , we iteratively move the search range outward in latent space until we have generated samples that change the prediction of the classifier $f$ . We improve the efficiency with Algorithm 2 by using a coarse-to-fine strategy and combining recursive and iterative search. We first search for adversaries in a wide search range, and recursively tighten the upper bound of the search range with denser sampling in bisections. Extra iterative search steps are taken to further tighten the upper bound of the optimal $\Delta z$ . This hybrid shrinking search approach, shown in detail in Algorithm 2, is four times faster to achieve similar adversaries as the iterative search.
+
+# C ARCHITECTURE FOR CONTINUOUS IMAGES
+
+Figure 3 shows the architecture of our framework for continuous images. We adopt WGAN (Arjovsky et al., 2017) with the objective function in Equation 1, and apply gradient penalty as proposed in Gulrajani et al. (2017). On top of the generator obtained from WGAN, we train an inverter by optimizing Equation 2. For handwritten digits from MNIST dataset, we train a WGAN of latent $ { z ^ { \cdot } } \in \mathbb { R } ^ { 6 4 }$ , with a generator consisting of 3 transposed convolutional layers and ReLU activation, and a critic consisting of 3 convolutional layers with filter sizes (64, 128, 256) and strides (2, 2, 2). We include an inverter with 2 fully connected layers of dimensions (4096, 1024) on top of the critic’s last hidden layer. For “Church Outdoor” and “Tower” images from LSUN dataset, we follow similar procedures as in Gulrajani et al. (2017) training a WGAN of latent $z \in \mathbb { R } ^ { 1 2 8 }$ . The generator and critic are both residual networks. We use pre-activation residual blocks with two $3 \times 3$ convolutional layers each and ReLU activation. The critic of 4 residual blocks performs downsampling using mean pooling after the second convolution, while the generator contains 4 residual blocks performing nearest-neighbor upsampling before the second convolution. We include an inverter with 3 fully connected layers of dimensions (8192, 2048, 512) on top of the critic’s last hidden layer.
+
+![](images/d37ed3fdcf22f38faa49390a1becb9f26ab16da3786a9b33629deb293dd77940.jpg)  
+Figure 5: Illustration with synthetic data. With training data that lies on a complex manifold (a), the inverter maps input to compact gaussian latent $z ^ { \prime } = \mathcal { T } _ { \gamma } ( x )$ in (b), while the generator reconstructs the data via $\mathcal { G } _ { \boldsymbol { \theta } } ( \mathcal { T } _ { \boldsymbol { \gamma } } ( \boldsymbol { x } ) )$ in (c). Given $f$ as a binary classifier with decision boundary as the horizontal line in (c), for an input $x$ , our approach returns $x ^ { * }$ on the left as natural adversary that lies on the manifold, while existing approaches may find $x ^ { * }$ on the right as the adversary, which is the nearest but impossible.
+
+Algorithm 1 Iterative stochastic search in latent space for adversaries
+
+Require: a target black-box classifier $f$ , an input instance $x$ , and a corpus of relevant data $X$   
+1: Hyper-parameters: $N$ : number of samples in each iteration, $\Delta r$ : increment of search range   
+2: Train a generator $\mathcal { G } _ { \theta }$ and an inverter $\mathcal { T } _ { \gamma }$ on $X$   
+3: $y  f ( x )$ , $z ^ { \prime } \gets \mathcal { T } _ { \gamma } ( x )$ , radius $r \gets 0$   
+4: loop $\triangleright$ loop till we find an adversary   
+5: $\mathbf { \boldsymbol { \bar { S } } }  \emptyset$   
+6: for sample $N$ random noise vectors $\epsilon$ of norms within $( r , r + \Delta r ]$ do   
+7: $\tilde { z }  z ^ { \prime } + \epsilon$ , $\tilde { x }  \mathcal G _ { \theta } ( \tilde { z } ) , \tilde { y }  f ( \tilde { x } )$ $\triangleright$ perturbation, sample generation, prediction   
+8: if $\tilde { y } \ne y$ then   
+9: $S \gets S \cup \langle \tilde { x } , \tilde { y } , \tilde { z } \rangle$   
+10: if $S = \emptyset$ then $\triangleright$ no adversary generated   
+11: $r \gets r + \Delta r$ $\triangleright$ move search range outward   
+12: else $\triangleright$ certain adversary generated   
+13: $\begin{array} { r } { \mathbf { r e t u r n } \left. x ^ { * } , y ^ { * } , z ^ { * } \right. = \operatorname * { a r g m i n } _ { \langle \check { x } , \check { y } , \check { z } \rangle \in S } \| \check { z } - z ^ { \prime } \| } \end{array}$ $\triangleright$ return the closest sample   
+Require: a target black-box classifier $f$ , an input instance $x$ , and a corpus of relevant data $X$   
+1: Hyper-parameters: $N$ : number of samples in each iteration, $\Delta r$ : increment of search range, $B$ :   
+limit of iterations, $r$ : upper limit of search range   
+2: Train a generator $\mathcal { G } _ { \theta }$ and an inverter $\mathcal { T } _ { \gamma }$ on $X$   
+3: $y  f ( x )$ , $z ^ { \prime } \gets \mathcal { T } _ { \gamma } ( x )$ , $l \gets 0 , i \gets 0$   
+4: First, recursive search:   
+5: while $r - l \geq \Delta r$ do   
+6: $S \gets \emptyset$   
+7: for sample $N$ random noise vectors $\epsilon$ of magnitude within $( l , r ]$ do   
+8: z˜ ← z0 + , $\tilde { x }  \mathcal G _ { \theta } ( \tilde { z } ) , \tilde { y }  f ( \tilde { x } )$   
+9: if $\tilde { y } \ne y$ then   
+10: $S \gets S \cup \langle \tilde { x } , \tilde { y } , \tilde { z } \rangle$   
+11: if $S = \emptyset$ then $\triangleright$ no adversary generated   
+12: $l \gets ( l + r ) / 2$ $\triangleright$ shrink search range by half   
+13: else $\triangleright$ certain adversary generated   
+14: $\begin{array} { r l } & { \langle x ^ { * } , y ^ { * } , z ^ { * } \rangle = \mathrm { a r g m i n } _ { \langle \check { x } , \check { y } , \check { z } \rangle \in S } \| \check { z } - z ^ { \prime } \| } \\ & { l  0 , r  \| z ^ { * } - z ^ { \prime } \| } \end{array}$ $\triangleright$ store the closest sample   
+15: $\triangleright$ update upper bound of $\Delta z$   
+16: Then, iterative search:   
+17: while $i < B$ and $r > 0$ do   
+18: $S \gets \emptyset , l \gets \operatorname* { m a x } ( 0 , r - \Delta r )$   
+19: for sample $N$ random noise vectors $\epsilon$ of norms within $( l , r ]$ do   
+20: $\tilde { z } \gets z ^ { \prime } + \epsilon , \tilde { x } \gets \mathcal G _ { \theta } ( \tilde { z } ) , \tilde { y } \gets f ( \tilde { x } )$   
+21: if $\tilde { y } \ne y$ then   
+22: $S \gets S \cup \langle \tilde { x } , \tilde { y } , \tilde { z } \rangle$   
+23: if $S = \emptyset$ then   
+24: $i \gets i + 1 , r \gets r - \Delta r$ $\triangleright$ increase counter, continue searching   
+25: else   
+26: $\begin{array} { r l } & { \langle x ^ { * } , y ^ { * } , z ^ { * } \rangle = \mathrm { a r g m i n } _ { \langle \check { x } , \check { y } , \check { z } \rangle \in S } \| \check { z } - z ^ { \prime } \| } \\ & { i  0 , r  \| z ^ { * } - z ^ { \prime } \| } \end{array}$ $\triangleright$ store the closest sample   
+27: $\triangleright$ reset counter, update upper bound of $\Delta z$   
+28: return $\langle x ^ { * } , y ^ { * } , z ^ { * } \rangle$
+
+# D ARCHITECTURE FOR DISCRETE TEXT
+
+We use the adversarially regularized autoencoder (ARAE) (Zhao et al., 2017) for encoding discrete text into continuous codes as shown in Figure 6. ARAE model encodes a sentence with an LSTM encoder into continuous code and performs adversarial training on the codes generated from noise and data to approximate the data distribution. We introduce an inverter that maps these continuous codes
+
+$$
+\begin{array}{c} \begin{array} { r l } & { \mathrm { , ~ } \mathrm { ~ n o i s e ~ } \tilde { z }  [ \mathrm { g e n e r a t o r ~ } \mathcal { G } _ { \theta } ]  \mathrm { ~ c o d e s ~ } \tilde { c }  [ \operatorname* { d e c o d e r } \mathcal { D } _ { \psi } ]  \mathrm { ~ s a m p l e s ~ } \tilde { x } } \\ & { \mathrm { , ~ } } \\ & { \mathrm { ~ } \mathrm { ~ } \mathrm { ~ p e r t u r b a t i o n s ~ } } \\ & { \mathrm { ~ } \cdot } \\ & { \mathrm { ~ } \mathrm { ~ l a t e n t ~ } z ^ { \prime }  [ \mathrm { i n v e r t e r ~ } \mathcal { Z } _ { \gamma } ]  \mathrm { ~ c o d e ~ } c  [ \mathrm { e n c o d e r ~ } \mathcal { E } _ { \phi } ]  \mathrm { ~ d i s c r e t e ~ } x } \end{array}  \sum _ { \mathrm { ~ } \alpha = \nu \mathrm { ~ r a t e r s a r y ~ } } ^ { \mathrm { ~ n a t u r a l ~ } }  \end{array}
+$$
+
+Figure 6: Model Architecture for Text. Our model incorporates in the adversarially regularized autoencoder (ARAE) (Zhao et al., 2017) for encoding discrete $x$ into continuous code $c$ and decoding continuous $\tilde { c }$ into discrete $\tilde { x }$ when generating samples.
+
+into the Gaussian space of $z \in \mathbb { R } ^ { 1 0 0 }$ . We use 4 layers of CNN with varying filter sizes (300, 500, 700, and 1000), strides (2, 2, 2) and context windows (5, 5, 3) for encoding text $x$ , into continuous space $c \in \mathbb { R } ^ { 3 0 0 }$ . For the decoder, we use a single-layer LSTM with hidden dimension of 300. We also train two MLPs, one each for the generator and the inverter, to learn mappings from noise to continuous codes and continuous codes to noise respectively. The loss functions for different components of the ARAE model, which are autoencoder reconstruction loss and WGAN loss functions for generator and critic, are described in Equations (4), (5), (6) respectively. We first train the ARAE components of encoder, decoder and generator using WGAN strategy, followed by the inverter on top of these with loss function in (7), by minimizing the Jensen-Shannon divergence between the inverted continuous codes and noise samples.
+
+$$
+\begin{array} { r l } & { \displaystyle \operatorname* { m i n } _ { \phi , \phi } \mathcal { L } _ { \mathcal { E } , \mathcal { D } } ( \phi , \psi ) = \operatorname* { m a x } _ { \phi , \psi } \mathbb { E } _ { x } [ \log p _ { \psi } ( x | \mathcal { E } _ { \phi } ( x ) ) ] } \\ & { \quad \quad \quad \quad \quad \operatorname* { m i n } _ { \omega } \mathcal { L } _ { \mathcal { C } } ( \omega ) = \operatorname* { m a x } _ { \omega } \mathbb { E } _ { x } [ \mathcal { C } _ { \omega } ( \mathcal { E } _ { \phi } ( x ) ) ] - \mathbb { E } _ { z } [ \mathcal { C } _ { \omega } ( \mathcal { G } _ { \theta } ( z ) ) ] } \\ & { \displaystyle \operatorname* { m i n } _ { \phi , \theta } \mathcal { L } _ { \mathcal { E } , \mathcal { G } } ( \phi , \theta ) = \operatorname* { m i n } _ { \phi , \theta } \mathbb { E } _ { x } [ \mathcal { C } _ { \omega } ( \mathcal { E } _ { \phi } ( x ) ) ] - \mathbb { E } _ { z } [ \mathcal { C } _ { \omega } ( \mathcal { G } _ { \theta } ( z ) ) ] } \\ & { \quad \quad \quad \quad \operatorname* { m i n } _ { \gamma } \mathcal { L } _ { \mathcal { T } } ( \gamma ) = \operatorname* { m i n } _ { \gamma } \mathbb { E } _ { x } \| \mathcal { G } _ { \theta } ( \mathcal { I } _ { \gamma } ( \mathcal { E } _ { \phi } ( x ) ) ) - \mathcal { E } _ { \phi } ( x ) \| + \mathbb { E } _ { z } [ \mathbf { J } \mathbf { S } \mathbf { D } ( z , \mathcal { L } _ { \gamma } ( \mathcal { G } _ { \theta } ( z ) ) ) ] } \end{array}
+$$
+
+We train our framework on the sentences up to length 10 from Stanford Natural Language Inference (SNLI) (Bowman et al., 2015) dataset, with hyper-parameters of $\Delta r = 0 . 0 1$ and $N = 1 0 0$ . Table 9 shows some examples of the perturbations generated automatically by our approach, which are grammatical and semantically close to the original sentences.
+
+# D.1 TEXTUAL ENTAILMENT EXAMPLES
+
+We provide additional examples of generated adversarial hypotheses for sentences from the SNLI corpus in Table 10, which corresponds to the examples in the main text in Table 3.
+
+# D.2 MACHINE TRANSLATION EXAMPLES
+
+We provide additional examples of the two probing functions in Table 11 and Table 12, corresponding to Table 4 and Table 5 in the main text, respectively.
+
+Table 9: Text perturbations. Examples are generated by perturbing the origins in semantic space.   
+
+<table><tr><td>Original</td><td></td><td>Some dogs are running on a deserted beach.A man playing an electric guitar on stage.</td></tr><tr><td rowspan="5">Perturbation</td><td>Some dogs are running on a grassy field.</td><td>A man is playing an electric guitar.</td></tr><tr><td>Some dogs are walking along a path.</td><td>A man is playing an acoustic guitar.</td></tr><tr><td>Some dogs are running down a hill.</td><td>A man is playing an accordion.</td></tr><tr><td>A dog is running on a grassy field.</td><td>A man is playing with an electronic device.</td></tr><tr><td>A dog is running down a trail.</td><td>A man is playing with an elephant.</td></tr></table>
+
+Table 10: Textual Entailment. For a pair of premise $\left( \mathbf { p } : \right)$ and hypothesis $( \mathbf { h } : )$ , we present the generated adversaries for three classifiers by perturbing the hypothesis $( \mathbf { h } ^ { \prime } : \mathbf { \epsilon } )$ . The last column provides the true label, followed by the changes in the prediction from each classifier.   
+
+<table><tr><td>Classifiers</td><td>Sentences</td><td>Label</td></tr><tr><td>Original</td><td>p : The man walks among the large trees. h : The man is lost in the woods.</td><td>Neutral</td></tr><tr><td>Embedding</td><td>h&#x27;: The man is lost at the woods.</td><td>Contradiction →Neutral</td></tr><tr><td>LSTM</td><td>h&#x27; : The man is crying in the woods.</td><td>Neutral→Contradiction</td></tr><tr><td>TreeLSTM</td><td>h&#x27;：The man is lost ina bed.</td><td>Neutral → Contradiction</td></tr></table>
+
+Table 11: Machine Translation. “Adversaries” that introduce the word “stehen” into the Google translation system by perturbing English sentences.   
+
+<table><tr><td>Source Sentence (English)</td><td>Generated Translation (German)</td></tr><tr><td>s :Asian women are sitting in a Restraunt.</td><td>Asiatische Frauen sitzen in einem Restaurant. s :Asian kids are standing in a Restraunt.Asiatische Kinder stehen in einem Restaurant.</td></tr><tr><td></td><td></td></tr><tr><td>s : People sitting on the floor.</td><td>Leute sitzen auf dem Boden.</td></tr><tr><td>s&#x27; : People standing on the field.</td><td>Leute,die auf dem Feld stehen.</td></tr></table>
+
+Table 12: “Adversaries” that find dropped verbs in English-To-German translation. The left column contains the original sentence $s$ and its adversary $s ^ { \prime }$ . The right column contains the translations of $s$ and $s ^ { \prime }$ , with English translation provided for legibility.   
+
+<table><tr><td>Source Sentence (English)</td><td>Generated Translation (German)</td></tr><tr><td>s : A man looks back while laughing and walking. s : A man is laughing walking down the ground.</td><td>Ein Mann schaut beim Lachen und Gehen zurck. Ein Mann lacht auf dem Boden. (A man laughs on the floor.)</td></tr><tr><td>s : She is cooking food while wearing a dress. s&#x27; : She is cooking dressed for a wedding.</td><td>Sie kocht Essen, whrend sie ein Kleid trgt. Sie kocht fr eine Hochzeit. (She cooks for a wedding.)</td></tr></table>

parse/train/H1BLjgZCb/H1BLjgZCb_content_list.json

@@ -0,0 +1,1558 @@
+[
+    {
+        "type": "text",
+        "text": "GENERATING NATURAL ADVERSARIAL EXAMPLES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            99,
+            787,
+            121
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Zhengli Zhao ",
+        "text_level": 1,
+        "bbox": [
+            184,
+            145,
+            279,
+            159
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Dheeru Dua University of California Irvine, CA 92697, USA ddua@uci.edu ",
+        "bbox": [
+            398,
+            145,
+            558,
+            200
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "University of California Irvine, CA 92697, USA zhengliz@uci.edu ",
+        "bbox": [
+            184,
+            161,
+            343,
+            202
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Sameer Singh University of California Irvine, CA 92697, USA sameer@uci.edu ",
+        "bbox": [
+            614,
+            145,
+            774,
+            200
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            238,
+            544,
+            252
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Due to their complex nature, it is hard to characterize the ways in which machine learning models can misbehave or be exploited when deployed. Recent work on adversarial examples, i.e. inputs with minor perturbations that result in substantially different model predictions, is helpful in evaluating the robustness of these models by exposing the adversarial scenarios where they fail. However, these malicious perturbations are often unnatural, not semantically meaningful, and not applicable to complicated domains such as language. In this paper, we propose a framework to generate natural and legible adversarial examples that lie on the data manifold, by searching in semantic space of dense and continuous data representation, utilizing the recent advances in generative adversarial networks. We present generated adversaries to demonstrate the potential of the proposed approach for black-box classifiers for a wide range of applications such as image classification, textual entailment, and machine translation. We include experiments to show that the generated adversaries are natural, legible to humans, and useful in evaluating and analyzing black-box classifiers. ",
+        "bbox": [
+            233,
+            268,
+            764,
+            477
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            503,
+            336,
+            518
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "With the impressive success and extensive use of machine learning models in various securitysensitive applications, it has become crucial to study vulnerabilities in these systems. Dalvi et al. (2004) show that adversarial manipulations of input data often result in incorrect predictions from classifiers. This raises serious concerns regarding the security and integrity of existing machine learning algorithms, especially when even state-of-the-art models including deep neural networks have been shown to be highly vulnerable to adversarial attacks with intentionally worst-case perturbations to the input (Szegedy et al., 2014; Goodfellow et al., 2015; Kurakin et al., 2016; Papernot et al., 2016b; Kurakin et al., 2017). These adversaries are generated effectively with access to the gradients of target models, resulting in much higher successful attack rates than data perturbed by random noise of even larger magnitude. Further, training models by including such adversaries can provide machine learning models with additional regularization benefits (Goodfellow et al., 2015). ",
+        "bbox": [
+            174,
+            535,
+            825,
+            686
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Although these adversarial examples expose “blind spots” in machine learning models, they are unnatural, i.e. these worst-case perturbed instances are not ones the classifier is likely to face when deployed. Due to this, it is difficult to gain helpful insights into the fundamental decision behavior inside the black-box classifier: why is the decision different for the adversary, what can we change in order to prevent this behavior, and is the classifier robust to natural variations in the data when not in an adversarial scenario? Moreover, there is often a mismatch between the input space and the semantic space that we can understand. Changes to the input we may not think meaningful, like slight rotation or translation in images, often lead to substantial differences in the input instance. For example, Pei et al. (2017) show that minimal changes in the lighting conditions can fool automated-driving systems, a behavior adversarial examples are unable to discover. Due to the unnatural perturbations, these approaches cannot be applied to complex domains such as language, in which enforcing grammar and semantic similarity is difficult when perturbing instances. Therefore, existing approaches that find adversarial examples for text often result in ungrammatical sentences, as in the examples generated by Li et al. (2016), or require manual intervention, as in Jia & Liang (2017). ",
+        "bbox": [
+            174,
+            694,
+            825,
+            888
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we introduce a framework to generate natural adversarial examples, i.e. instances that are meaningfully similar, valid/legible, and helpful for interpretation. The primary intuition behind our proposed approach is to perform the search for adversaries in a dense and continuous representation of the data instead of searching in the input data space directly. We use generative adversarial networks (GANs) (Goodfellow et al., 2014) to learn a projection to map normally distributed fixed-length vectors to data instances. Given an input instance, we search for adversaries in the neighborhood of its corresponding representation in latent space by sampling within a range that is recursively tightened. Figure 1 provides an example of adversaries for digit recognition. Given a multi-layer perceptron (MLP) for MNIST and an image from test data (Figure 1a), our approach generates a natural adversarial example (Figure 1e) which is classified incorrectly as $z '$ by the classifier. Compared to the adversary generated by the existing Fast Gradient Sign Method (FGSM) (Goodfellow et al., 2015) that adds gradient-based noise (Figures 1c and 1b), our adversary (Figure 1e) looks like a hand-written digit similar to the original input. Further, the difference (Figure 1d) provides some insight into the classifier’s behavior, such as the fact that slightly thickening (blue) the bottom stroke and thinning (red) the one above it, fools the classifier. ",
+        "bbox": [
+            173,
+            896,
+            821,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/a634c435db2dc9f45da75e2007e12906940986463122f6302d7f34beb1939ab4.jpg",
+        "image_caption": [
+            "Figure 1: Adversarial examples. Given an instance (a), existing FGSM approach (Goodfellow et al., 2015) adds small perturbations in (b), that change the prediction of the model (to be “2”, in this case). Instead of such random-looking noise, our framework generates natural adversarial examples, such as in (e), where the differences, shown in (d) (with blue $^ { \\prime } +$ , red/-), are meaningful changes to the strokes. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            191,
+            99,
+            810,
+            199
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            296,
+            825,
+            477
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We apply our approach to both image and text domains, and generate adversaries that are more natural and grammatical, semantically close to the input, and helpful to interpret the local behavior of black-box models. We present examples of natural adversaries for image classification, textual entailment, and machine translation. Experiments and human evaluation also demonstrate that our approach can help evaluate the robustness of black-box classifiers, even without labeled training data. ",
+        "bbox": [
+            174,
+            484,
+            825,
+            554
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 FRAMEWORK FOR GENERATING NATURAL ADVERSARIES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            579,
+            684,
+            595
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this section, we describe the problem setup and details of our framework for generating natural adversarial examples of both continuous images and discrete text data. Given a black-box classifier $f$ and a corpus of unlabeled data $X$ , the goal here is to generate adversarial example $x ^ { * }$ for a given data instance $x$ that results in a different prediction, i.e. $f ( x ^ { * } ) \\neq f ( x )$ . In general, the instance $x$ may not be in $X$ , but comes from the same underlying distribution ${ \\mathcal P } _ { x }$ , which is the distribution we want to generate $x ^ { * }$ from as well. We want $x ^ { * }$ to be the nearest such instance to $x$ in terms of the manifold that defines the data distribution ${ \\mathcal P } _ { x }$ , instead of in the original data representation. ",
+        "bbox": [
+            174,
+            613,
+            825,
+            712
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Unlike other existing approaches that search directly in the input space for adversaries, we propose to search in a corresponding dense representation of $z$ space. In other words, instead of finding the adversarial $x ^ { * }$ directly, we find the adversarial $z ^ { * }$ in an underlying dense vector space which defines the distribution ${ \\mathcal P } _ { x }$ , and then map it back to $x ^ { * }$ with the help of a generative model. By searching for samples in the latent low-dimensional $z$ space and mapping them to $x$ space to identify the adversaries, we encourage these adversaries to be valid (legible for images, and grammatical for sentences) and semantically close to the original input. ",
+        "bbox": [
+            174,
+            718,
+            825,
+            816
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Background: Generative Adversarial Networks To tackle the problem described above, we need powerful generative models to learn a mapping from the latent low-dimensional representation to the distribution ${ \\mathcal P } _ { x }$ , which we estimate using samples in $X$ . GANs are a class of such generative models that can be trained via procedures of minimax game between two competing networks (Goodfellow et al., 2014): given a large amount of unlabeled instances $X$ as training data, the generator $\\mathcal { G } _ { \\theta }$ learns to map some noise with distribution $p _ { z } ( z )$ where $z \\in \\mathbb { R } ^ { \\mathrm { d } }$ to synthetic data that is as close to the training data as possible; on the other hand, the critic $\\mathcal { C } _ { \\omega }$ is trained to discriminate the output of the generator from real data samples from $X$ . The original objective function of GANs has been found to be hard to optimize in practice, for reasons theoretically investigated in Arjovsky & Bottou (2017). Arjovsky et al. (2017) refine the objective with Wasserstein-1 distance as: ",
+        "bbox": [
+            174,
+            827,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/fbd590f51dff339cf1f3d2bcf07c11aa224881ffb40df40adc7c593a4eb5ccf8.jpg",
+        "image_caption": [
+            "Figure 2: Training Architecture with a GAN and an Inverter. Loss of the inverter combines reconstruction error of $x$ with divergence between Gaussian distribution $z$ and $\\mathcal { T } _ { \\gamma } ( \\mathcal { G } _ { \\theta } ( z ) )$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            200,
+            98,
+            810,
+            209
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            273,
+            826,
+            315
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/10a38b07ab597a5a16493d345844978d1e5ccc11b3540482fe2507f8675434c3.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { \\theta } \\operatorname* { m a x } _ { \\omega } \\mathbb { E } _ { x \\sim p _ { x } ( x ) } [ \\mathcal { C } _ { \\omega } ( x ) ] - \\mathbb { E } _ { z \\sim p _ { z } ( z ) } [ \\mathcal { C } _ { \\omega } ( \\mathcal { G } _ { \\theta } ( z ) ) ] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            328,
+            321,
+            668,
+            344
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Wasserstein GAN achieves improvement in the stability of learning and provides useful learning curves. A number of further improvements to the GAN framework have been introduced (Salimans et al., 2016; Arjovsky & Bottou, 2017; Gulrajani et al., 2017; Rosca et al., 2017) that we discuss in Section 6. We incorporate the structure of WGAN and relevant improvements as a part of our framework for generating natural examples close to the training data distribution, as we describe next. ",
+        "bbox": [
+            173,
+            349,
+            825,
+            421
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Natural Adversaries In order to represent natural instances of the domain, we first train a WGAN on corpus $X$ , which provides a generator $\\mathcal { G } _ { \\theta }$ that maps random dense vectors $z \\in \\mathbb { R } ^ { \\mathrm { d } }$ to samples $x$ from the domain of $X$ . We separately train a matching inverter $\\mathcal { T } _ { \\gamma }$ to map data instances to corresponding dense representations. As in Figure 2, we minimize the reconstruction error of $x$ , and the divergence between sampled $z$ and $\\mathcal { T } _ { \\gamma } ( \\mathcal { G } _ { \\theta } ( z ) )$ to encourage the latent space to be normally distributed: ",
+        "bbox": [
+            173,
+            430,
+            825,
+            502
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8a4754b83c29e7adda115437893432325188d6a85215c4932a7b912d59c9ed0a.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { \\gamma } \\mathbb { E } _ { x \\sim p _ { x } ( x ) } \\lVert \\mathcal { G } _ { \\theta } ( \\mathbb { Z } _ { \\gamma } ( x ) ) - x \\rVert + \\lambda \\cdot \\mathbb { E } _ { z \\sim p _ { z } ( z ) } [ \\mathcal { L } ( z , \\mathbb { Z } _ { \\gamma } ( \\mathcal { G } _ { \\theta } ( z ) ) ) ] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            282,
+            506,
+            715,
+            531
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Using these learned functions, we define the natural adversarial example $x ^ { * }$ as the following: ",
+        "bbox": [
+            171,
+            536,
+            787,
+            551
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f80f3098ce669833cae8dd64677ef5948ee5863b684224dd814d3b7458855ec3.jpg",
+        "text": "$$\n\\mathcal G _ { \\boldsymbol \\theta } ( z ^ { * } ) \\mathrm { w h e r e } z ^ { * } = \\mathrm { a r g m i n } \\| \\tilde { z } - \\mathcal T _ { \\gamma } ( x ) \\| \\mathrm { s . t . } f ( \\mathcal G _ { \\boldsymbol \\theta } ( \\tilde { z } ) ) \\neq f ( x ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            307,
+            556,
+            725,
+            579
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Instead of $x$ , we perturb its dense representation $z ^ { \\prime } = \\mathcal { T } _ { \\gamma } ( x )$ , and use the generator to test whether a perturbation $\\tilde { z }$ fools the classifier by querying $f$ with $\\dot { \\tilde { x } } = \\mathcal { G } _ { \\theta } ( \\tilde { z } )$ . Figure 3 shows our generation process. A synthetic example is included for further intuition in Appendix A. As for the divergence $\\mathcal { L }$ , we use $L _ { 2 }$ distance with $\\lambda = . 1$ for images and Jensen-Shannon distance with $\\lambda = 1$ for text data. ",
+        "bbox": [
+            174,
+            585,
+            826,
+            643
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Search Algorithms We propose two approaches to identify the adversary (pseudocode in Appendix B), both of which utilize the inverter to obtain the latent vector $z ^ { \\prime } = \\mathcal { T } _ { \\gamma } ( x )$ of $x$ , and feed perturbations $\\tilde { z }$ in the neighborhood of $z ^ { \\prime }$ to the generator to generate natural samples $\\tilde { x } = \\mathcal { G } _ { \\theta } ( \\tilde { z } )$ . In iterative stochastic search (Algorithm 1), we incrementally increase the search range (by $\\Delta r$ ) within which the perturbations $\\tilde { z }$ are randomly sampled $N$ samples for each iteration), until we have generated samples $\\check { x }$ that change the prediction. Among these samples $\\check { x }$ , we choose the one which has the closest $z ^ { * }$ to the original $z ^ { \\prime }$ as an adversarial example $x ^ { * }$ . To improve the efficiency beyond this naive search, we propose a coarse-to-fine strategy we call hybrid shrinking search (Algorithm 2). We first search for adversaries in a wide search range, and recursively tighten the upper bound of the search range with denser sampling in bisections. Extra iterative search steps are taken to further tighten the upper bound of the optimal $\\Delta z$ . With the hybrid shrinking search in Algorithm 2, we observe a $4 \\times$ speedup while achieving similar results as Algorithm 1. Both these search algorithms are sample-based and applicable to black-box classifiers with no need of access to their gradients. Further, they are guaranteed to find an adversary, i.e. one that upper bounds the optimal adversary. ",
+        "bbox": [
+            173,
+            652,
+            826,
+            792
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/7bd1c82ecb7bef6ba77a957ce29e0c2547c954936bc007117d26479ee174d243.jpg",
+        "image_caption": [
+            "Figure 3: Natural Adversary Generation. Given an instance $x$ , our framework generates natural adversaries by perturbing inverted $z ^ { \\prime }$ and decoding perturbations $\\tilde { z }$ via $\\mathcal { G } _ { \\theta }$ to query the classifier $f$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            209,
+            813,
+            787,
+            882
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/a8bb26b880a446aed676fd7319d6dbcb20d8faad1ec9b6397a2e5bd116f67c2f.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            147,
+            825,
+            343
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            373,
+            825,
+            429
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 ILLUSTRATIVE EXAMPLES ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            450,
+            426,
+            467
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We demonstrate the potential of our approach (Algorithm 1) in generating informative, legible, and natural adversaries by applying it to a number of classifiers for both visual and textual domains. ",
+        "bbox": [
+            174,
+            482,
+            825,
+            511
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 GENERATING IMAGE ADVERSARIES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            529,
+            462,
+            542
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Image classification has been a focus for adversarial example generation due to the recent successes in computer vision. We apply our approach to two standard datasets, MNIST and LSUN, and present generated natural adversaries. We use $\\Delta r = 0 . 0 1$ and $N = 5 0 0 0$ with model details in Appendix C. ",
+        "bbox": [
+            176,
+            555,
+            823,
+            597
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Handwritten Digits Scans of human-written text provide an intuitive definition of what is natural, i.e. do the generated images look like something a person would write? In other words, how would a human change a digit in order to fool a classifier? We train a WGAN with $z \\in \\mathbb { R } ^ { 6 4 }$ on 60,000 MNIST images following similar procedures as in Gulrajani et al. (2017), with the generator consisting of transposed convolutional layers and the critic consisting of convolutional layers. We include the inverter with fully connected layers on top of the critic’s last hidden layer. We train two target classifiers to generate adversaries against: Random Forests (RF) with 5 trees (test accuracy $9 0 . 4 5 \\%$ ), and LeNet, as trained in LeCun et al. (1998) (test accuracy $9 8 . 7 1 \\%$ ). We treat both these classifiers as black-boxes, and present the generated adversaries in Table 1 with examples of each digit (from test instances that the GAN or classifiers never observed). Adversaries generated by FGSM look like the original digits eroded by uninterpretable noise (these may not be representative of the approach, as changing $\\epsilon$ for the method results in substantially different results). Our natural adversaries against both classifiers are quite similar to the original inputs in overall style and shape, yet provide informative insights into classifiers’ decision behavior around the input. Take the digit $\\cdot 5 ^ { \\mathrm { , } }$ as an example: dimming the vertical stroke can fool LeNet into predicting $\\mathbf { \\ddot { \\delta } } ^ { 6 } 3 ^ { 9 }$ . Further we observe that adversaries against RF often look closer to the original images in overall shape than those against LeNet. Although generating as impressive natural adversaries against more accurate LeNet is difficult, it implies that compared to RF, LeNet requires more substantial changes to the inputs to be fooled; in other words, RF is less robust than LeNet in classification. We will return to this observation later. ",
+        "bbox": [
+            174,
+            607,
+            825,
+            871
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Church vs Tower We apply our approach to outdoor, color images of higher resolution. We choose the category of “Church Outdoor” in LSUN dataset (Yu et al., 2015), randomly sample the same amount of 126,227 images from the category of “Tower”, and resize them to resolution of $6 4 \\times 6 4$ ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/50dfe89b67539b53c864ae1055490c0805c96f3f5d5028392a00fdaa59df7beb.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            132,
+            818,
+            265
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/4ccaef3da9589e2ad7f7066baaa20f7aace31faeb5b079214cbabd1408e4298f.jpg",
+        "table_caption": [
+            "Table 2: Adversarial examples against MLP classifier of LSUN by our approach. 4 original images each of “Church” and “Tower”, with their adversaries of the flipped class in the bottom row. ",
+            "Table 3: Textual Entailment. For a pair of premise $( \\mathbf { p } : )$ and hypothesis $( \\mathbf { h } : )$ , we present the generated adversaries for three classifiers by perturbing the hypothesis $( \\mathbf { h } ^ { \\prime } : \\mathbf { \\epsilon } )$ . The last column provides the true label, followed by the changes in the prediction for each classifier. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Classifiers</td><td>Sentences</td><td>Label</td></tr><tr><td>Original</td><td>p : The man wearing blue jean shorts is grilling. h : The man is walking his dog.</td><td>Contradiction</td></tr><tr><td>Embedding</td><td>h&#x27; : The man is walking by the dog.</td><td>Contradiction →Entailment</td></tr><tr><td>LSTM</td><td>h&#x27;: The person is walking a dog.</td><td>Contradiction →Entailment</td></tr><tr><td>TreeLSTM</td><td>h&#x27;:A man is winning a race.</td><td>Contradiction →Neutral</td></tr></table>",
+        "bbox": [
+            205,
+            328,
+            789,
+            426
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The training procedure is similar to MNIST, except that the generator and critic in WGAN are deep residual networks (He et al., 2016) and $z \\in \\mathbb { R } ^ { 1 2 8 }$ . We train an MLP classifier on these two classes with test accuracy of $7 1 . 3 \\%$ . Table 2 presents original images for both classes and corresponding adversarial examples. From looking at these pairs, we can observe that the generated adversaries make changes that are natural for this domain. For example, to change the classifier’s prediction from “Church” to “Tower”, the adversaries sharpen the roof, narrow the buildings, or change a tree into a tower. We can observe similar behavior in the other direction: the image with the Eiffel Tower is changed to a “church” by converting a woman into a building, and narrowing the tower. ",
+        "bbox": [
+            173,
+            454,
+            825,
+            565
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 GENERATING TEXT ADVERSARIES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            587,
+            454,
+            601
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Generating grammatical and linguistically coherent adversarial sentences is a challenging task due to the discrete nature of text: adding imperceptible noise is impossible, and most actual changes to $x$ may not result in grammatical text. Prior approaches on generating textual adversaries (Li et al., 2016; Alvarez-Melis & Jaakkola, 2017; Jia & Liang, 2017) perform word erasures and replacements directly on text input space $x$ , using domain-specific rule based or heuristic based approaches, or require manual intervention. Our approach, on the other hand, performs perturbations in the continuous space $z$ , that has been trained to produce semantically and syntactically coherent sentences automatically. ",
+        "bbox": [
+            174,
+            613,
+            825,
+            712
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We use the adversarially regularized autoencoder (ARAE) (Zhao et al., 2017) for encoding discrete text into continuous codes. ARAE model encodes a sentence with an LSTM encoder into continuous code and then performs adversarial training on these codes to capture the data distribution. We introduce an inverter that maps these continuous codes into the Gaussian space of $z \\in \\mathbb { R } ^ { 1 0 0 }$ . We use a 4-layer strided CNN for the encoder as it yields more coherent sentences than LSTMs from the ARAE model, however LSTM works well as the decoder. We train two MLP models for the generator and the inverter, to learn mappings between noise and continuous codes. We train our framework on the Stanford Natural Language Inference (SNLI) (Bowman et al., 2015) data of 570k labeled human-written English sentence pairs with the same preprocessing as Zhao et al. (2017), using $\\Delta r =$ 0.01 and $N = 1 0 0$ . We present details of the architecture and sample perturbations in Appendix D. ",
+        "bbox": [
+            174,
+            718,
+            825,
+            857
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Textual Entailment Textual Entailment (TE) is a task designed to evaluate common-sense reasoning for language, requiring both natural language understanding and logical inferences for text snippets. In this task, we classify a pair of sentences, a premise and a hypothesis, into three categories depending on whether the hypothesis is entailed by the premise, contradicts the premise, or is neutral to it. For instance, the sentence “There are children present” is entailed by the sentence “Children smiling and waving at camera”, while the sentence “The kids are frowning” contradicts it. We use our approach to generate adversaries by perturbing the hypothesis to deceive classifiers, keeping the premise unchanged. We train three classifiers of varying complexity, namely, an embedding classifier that is a single layer on top of the average word embeddings, an LSTM based model consisting of a single layer on top of the sentence representations, and TreeLSTM (Chen et al., 2017) that uses a hierarchical LSTM on the parses and is a top-performing classifier for this task. A few examples comparing the three classifiers are shown in Table 3 (more examples in Appendix D.1). Although all classifiers correctly predict the label, as the classifiers get more accurate (from embedding to LSTM to TreeLSTM), they require much more substantial changes to the sentences to be fooled. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/780dc86cbb906909ec7e60783c54728c2f4b5e6a149da0776083107a1925538e.jpg",
+        "table_caption": [
+            "Table 4: Machine Translation. “Adversary” that introduces the word “stehen” into the translation. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Source Sentence (English)</td><td>Generated Translation (German)</td></tr><tr><td>s : A man and woman sitting on the sidewalk.</td><td>Ein Mann und eine Frau, die auf dem Bürgersteig sitzen.</td></tr><tr><td>s&#x27; : A man and woman stand on the bench.</td><td>Ein Mann und eine Frau stehen auf der Bank.</td></tr></table>",
+        "bbox": [
+            174,
+            117,
+            823,
+            171
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/fe990707cef0ef1108186dbbb59a7e9d284e1b7a27317ed709ab44d98957cf60.jpg",
+        "table_caption": [
+            "Table 5: “Adversaries” to find dropped verbs. The left column contains the original sentence s and its adversary $s ^ { \\prime }$ , while the right contains their translations, with English translation in red. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Source Sentence (English)</td><td>Generated Translation (German)</td></tr><tr><td>s : People sitting in a dim restaurant eating. s&#x27; : People sitting in a living room eating.</td><td>Leute,die in einem dim Restaurant essen sitzen. Leute,die in einem Wohnzimmeressen sitzen.</td></tr><tr><td>s : Elderly people walking down a city street. s&#x27; : A man walking down a street playing.</td><td>(People sitting in a living room.) Altere Menschen,die eine StadtstraBe hinuntergehen. Ein Mann,der eine StraBe entlang spielt. (A man playing along a street.)</td></tr></table>",
+        "bbox": [
+            179,
+            226,
+            813,
+            334
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            371,
+            825,
+            510
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Machine translation We consider machine translation not only because it is one of the most successful applications of neural approaches to NLP, but also since most practical translation systems lie behind black-box access APIs. The notion of adversary, however, is not so clear here as the output of a translation system is not a class. Instead, we define adversary for machine translation relative to a probing function that tests the translation for certain properties, ones that may lead to linguistic insights into the languages, or detect potential vulnerabilities. We use the same generator and inverter as in entailment, and find such “adversaries” via API access to the currently deployed Google Translate model (as of October 15, 2017) from English to German. ",
+        "bbox": [
+            174,
+            520,
+            825,
+            632
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "First, let us consider the scenario in which we want to generate adversarial English sentences such that a specific German word is introduced into the German translation. The probing function here would test the translation for the presence of that word, and we would have found an adversary (an English sentence) if the probing function passes for a translation. We provide an example of such a probing function that introduces the word “stehen” (“stand” in English) to the translation in Table 4 (more examples in Appendix D.2). Since the translation system is quite strong, such adversaries are not surfacing the vulnerabilities of the model, but instead can be used as a tool to understand or learn different languages (in this example, help a German speaker learn English). ",
+        "bbox": [
+            174,
+            638,
+            825,
+            751
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We can design more complex probing functions as well, especially ones that target specific vulnerabilities of the translation system. Let us consider translations of English sentences that contain two active verbs, e.g. “People sitting in a restaurant eating”, and see that the German translation has the two verbs as well, “essen” and “sitzen”, respectively. We now define a probing function that passes only if the perturbed English sentence $s ^ { \\prime }$ contains both the verbs, but the translation only has one of them. An adversary for such a probing function will be an English sentence $( s ^ { \\prime } )$ that is similar to the original sentence (s), but for some reason, its translation is missing one of the verbs. Table 5 presents examples of generated adversaries using such a probing function (with more in Appendix D.2). For example, one that tests whether “essen” is dropped from the translation when its English counterpart “eating” appears in the source sentence (“People sitting in a living room eating.”). These adversaries thus suggest a vulnerability in Google’s English to German translation system: a word acting as a gerund in English often gets dropped from the translation. ",
+        "bbox": [
+            173,
+            757,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/cc0959b52ec3322f12b3811ffa8a3a547bcda5f1d20b9fe677bd03afba43e7b4.jpg",
+        "table_caption": [
+            "Table 6: Statistics of adversaries against models for both MNIST and TE. We include the average $\\Delta z$ for the adversaries and the proportion where each classifier’s adversary has the largest $\\Delta z$ compared to the others for the same instance (significant with $p < 0 . 0 0 0 5$ using the sign test). The higher values correspond to stronger robustness, as is demonstrated by higher test accuracy. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"2\"></td><td>Average △z</td><td>P(largest △z)</td><td>Test accuracy (%)</td></tr><tr><td rowspan=\"2\">MNIST</td><td>Random Forests</td><td>1.24</td><td>0.22</td><td>90.45</td></tr><tr><td>LeNet</td><td>1.61</td><td>0.78</td><td>98.71</td></tr><tr><td rowspan=\"3\">Entailment</td><td>Embeddings</td><td>0.12</td><td>0.15</td><td>62.04</td></tr><tr><td>LSTM</td><td>0.14</td><td>0.18</td><td>69.60</td></tr><tr><td>TreeLSTM</td><td>0.26</td><td>0.66</td><td>89.04</td></tr></table>",
+        "bbox": [
+            200,
+            159,
+            790,
+            263
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/c3d115fc778a6779f6074b50f9feffab09db6f379f1b040af37910cf9997b2aa.jpg",
+        "image_caption": [
+            "Figure 4: Classifier accuracy and average $\\Delta z$ of their adversaries. In (a) and (b) we vary the number of neurons and dropout rate, respectively. In (c) we present the correlation between accuracy and average $\\Delta z$ for 80 different classifiers. (d) shows adversaries for an input image, against a set of classifiers with a single hidden layer, but varying number of neurons. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            292,
+            818,
+            497
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            602,
+            326,
+            617
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this section, we demonstrate that our approach can be utilized to compare and evaluate the robustness of black-box models even without labeled data. We present experimental results on images and text data with evaluations from both statistical analysis and pilot user studies. ",
+        "bbox": [
+            174,
+            641,
+            823,
+            684
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Robustness of Black-box Classifiers We apply our framework to various black-box classifiers for both images and text, and observe that it is useful for evaluating and interpreting these models via comparisons. The primary intuition behind this analysis is that more accurate classifiers often require more substantial changes to the instance to change their predictions, as noted in the previous section. In the following experiments, we apply the more efficient hybrid shrinking search (Algorithm 2). ",
+        "bbox": [
+            174,
+            694,
+            825,
+            763
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In order to quantify the extent of change for an adversary, the change in the original $x$ representation may not be meaningful, such as RMSE of the pixels or string edit distances, for the same reason we are generating natural adversaries: they do not correspond to the semantic distance underlying the data manifold. Instead we use the distance of the adversary in the latent space, i.e. $\\Delta z = \\| \\dot { z ^ { * } } - \\bar { z } ^ { \\prime } \\|$ , in order to measure how much each adversary is modified to change the classifier prediction. We also consider the set of adversaries generated for each instance against a group of classifiers, and count how many times the adversary of each classifier has the highest $\\Delta z$ . We present these statistics in Table 6 for both MNIST (over 100 test images, 10 per digit) and Textual Entailment (over 1260 test sentences), against the classifiers we described in Section 3. For both the tasks, we observe that more accurate classifiers require larger changes to the inputs (by both measures), indicating that generating such adversaries, even for unlabeled data, can evaluate the accuracy of black-box classifiers. ",
+        "bbox": [
+            174,
+            771,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/a2bf820095ae17c6491b97053331c2e4fb76e0f44c9f427316a4fae68907263d.jpg",
+        "table_caption": [
+            "Table 7: Pilot study with MNIST "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>RF</td><td>LeNet</td></tr><tr><td>Looks handwritten?</td><td>0.88</td><td>0.71</td></tr><tr><td>Which closer to original?</td><td>0.87</td><td>0.13</td></tr></table>",
+        "bbox": [
+            174,
+            117,
+            449,
+            171
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/1dff5927ce09999f65a5de6fc03e9255f68bef85b9f2c262482cc3566bb0d4b1.jpg",
+        "table_caption": [
+            "Table 8: Pilot study with Textual Entailment "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>LSTM</td><td>TreeLSTM</td></tr><tr><td>Is adversary grammatical?</td><td>0.86</td><td>0.78</td></tr><tr><td>Is it similar to the original?</td><td>0.81</td><td>0.58</td></tr></table>",
+        "bbox": [
+            477,
+            117,
+            810,
+            171
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We now consider evaluation on a broader set of classifiers, and study the effect of changing hyperparameters of models on the results (focusing on MNIST). We train a set of neural networks with one hidden layer by varying the number of neurons exponentially from 2 to 1024. In Figure 4a, we observe that the average $\\Delta z$ of adversaries against these models has a similar trend as their test accuracy. The generated adversaries for a single digit “3” in Figure 4d verify this observation: the adversaries become increasingly different from the original input as classifiers become more complex. We provide similar analysis by fixing the model structure but varying the dropout rates from 0.9 to 0.0 in Figure 4b, and observe a similar trend. To confirm that this correlation holds generally, we train 80 total classifiers that differ in the layer sizes, regularization, and amount of training data, and plot their test set accuracy against the average magnitude of change in their adversaries in Figure 4c. Given this strong correlation, we are confident that our framework for generating natural adversaries can be useful for automatically evaluating black-box classifiers, even in the absence of labeled data. ",
+        "bbox": [
+            173,
+            194,
+            826,
+            361
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Human Evaluation We carry out a pilot study with human subjects to evaluate how natural the generated adversaries are, and whether the adversaries they think are similar to the original ones correspond with the less accurate classifiers (as in the evaluation above). For both image classification and textual entailment, we select a number of instances randomly, generate adversaries for each against two classifiers, and present a questionnaire to the subjects that evaluates: (1) how natural or legible each generated adversary is; (2) which of the two adversaries is closer to the original instance. ",
+        "bbox": [
+            174,
+            372,
+            825,
+            455
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "For hand-written digits from MNIST, we pick 20 images (2 for each digit), generate adversaries against RF and LeNet (two adversaries for each image), and obtain 13 responses for each of the questions. In Table 7, we see that the subjects agree that our generated adversaries are quite natural, and also, they find RF adversaries to be much closer to the original image than LeNet (i.e. more accurate classifiers, as per test accuracy on their provided labels, have more distant adversaries). We also compare adversaries against LeNet generated by FGSM and our approach, and find that $7 8 \\%$ of the time the subjects agree that our adversaries make changes to the original images that are more natural (it is worth noting that FGSM is not applicable to RF for comparison). We carry out a similar pilot study for the textual entailment task to evaluate the quality of the perturbed sentences. We present a set of 20 pairs of sentences (premise and hypothesis), and adversarial hypotheses against both LSTM and TreeLSTM classifiers, and receive 4 responses for each of the questions above. The results in Table 8 also validate our previous results: the generated sentences are found to be grammatical and legible, and classifiers that need more substantial changes to the hypothesis tend to be more accurate. We leave a more detailed user study for future work. ",
+        "bbox": [
+            174,
+            462,
+            825,
+            656
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            676,
+            343,
+            693
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The fast gradient sign method (FGSM) has been proposed in Goodfellow et al. (2015) to generate adversarial examples fast rather than optimally. Intuitively, the method shifts the input by $\\epsilon$ in the direction of minimizing the cost function. Kurakin et al. (2016) propose a simple extension of FGSM by applying it multiple times, which generates adversarial examples with a higher attack rate, but the underlying idea is the same. Another method known as the Jacobian-based saliency map attack (JSMA) has been introduced by Papernot et al. (2016b). Unlike FGSM, JSMA generates adversaries by greedily modifying the input instance feature-wise. A saliency map is computed with gradients to indicate how important each feature is for the prediction, and the most important one is modified repeatedly until the instance changes the resulting classification. Moreover, it has been observed in practice that adversarial examples designed against a model are often likely to successfully attack another model for the same task that has not been given access to. This transferability property of adversarial examples makes it more practical to attack and evaluate deployed machine learning systems in realistic scenarios (Papernot et al., 2016a; 2017). ",
+        "bbox": [
+            174,
+            708,
+            825,
+            888
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "All these attacks above are based on gradients with access to the parameters of differentiable classifiers. Moosavi-Dezfooli et al. (2017) try to find a single noise vector which can cause imperceptible changes in most of data points, and meanwhile reduce the classifier accuracy significantly. Our method is capable of generating adversaries against black-box classifiers, even those without gradients such as Random Forests. Also, the noise added by these methods is uninterpretable, while the natural adversaries generated by our approach provide informative insights into classifiers’ decision behavior. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            159
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Due to the discrete domains involved in text, adversaries for text have received less attention. Jia & Liang (2017) generate adversarial examples for evaluating reading comprehension systems with predefined rules and candidate words for substitution after analyzing and rephrasing the input sentences. Li et al. (2016) introduce a framework to understand neural network through different levels of representation erasure. However, erasure of words or phrases directly often harms text integrity, resulting in semantically or grammatically incorrect sentences. Ribeiro et al. (2018) replace tokens by random words of the same POS tag with probability proportional to embedding similarity. Belinkov & Bisk (2018) explore approaches to increase the robustness of character-based machine translation models on text corrupted with character-level noise. With the help of expressive generative models, our approach instead perturbs the latent coding of sentences, resulting in legible generated sentences that are grammatical and semantically similar to the original input. These merits make our framework suitable for text applications such as sentiment analysis, textual entailment, and machine translation. ",
+        "bbox": [
+            174,
+            166,
+            825,
+            347
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 DISCUSSION AND FUTURE WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            378,
+            485,
+            395
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Our framework builds upon GANs as the generative models, and thus the capabilities of GANs directly effects the quality of generated examples. In visual domains, although there have been lots of appealing results produced by GANs, the training is well known to be brittle. Many recent approaches address how to improve the training stability and the objective function of GANs (Salimans et al., 2016; Arjovsky et al., 2017). Gulrajani et al. (2017) further improve the training of WGAN with regularization of gradient penalty instead of weight clipping. In our practice, we observe that we need to carefully balance the capacities of the generator, the critic, and the inverter that we introduced, to avoid situations such as model collapse. For natural languages, because of the discrete nature and non-differentiability, applications related to text generation have been relatively less studied. Zhao et al. (2017) propose to incorporate a discrete structure autoencoder with continuous code space regularized by WGAN for text generation. Given that there are some concerns about whether GANs actually learn the distribution (Arora & Zhang, 2017), it is worth noting that we can also incorporate other generative models such as Variational Auto-Encoders (VAEs) (Kingma & Welling, 2014) into our framework, as used in Hu et al. (2017) to generate text with controllable attributes, which we will explore in the future. We focus on GANs because adversarial training often results in higher quality images, while VAEs tend to produce blurrier ones (Goodfellow, 2016). We also plan to apply the fusion and variant of VAEs and GANs such as $\\alpha$ -GAN in Rosca et al. (2017) and Wasserstein Auto-Encoders in Tolstikhin et al. (2018). Note that as more advanced GANs are introduced to address these issues, they can be directly incorporated into our framework. ",
+        "bbox": [
+            174,
+            416,
+            825,
+            680
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Our iterative stochastic search algorithm for identifying adversaries is computationally expensive since it is based on naive sampling and local-search. Search based on gradients such as FGSM are not applicable to our setup because of black-box classifiers and discrete domain applications. We improve the efficiency with hybrid shrinking search by using a coarse-to-fine strategy that finds the upper-bounds by using fewer samples, and then performs finer search in the restricted range. We observe around $4 \\times$ speedup with this search while achieving similar results as the iterative search. The accuracy of our inverter mapping the input to its corresponding dense vector in latent space is also important for searching adversaries in the right neighborhood. In our experiments, we find that fine-tuning the latent vector produced by the inverter with a fixed GAN can further refine the generated adversarial examples, and we will investigate other such extensions of the search in future. There is an implicit assumption in this work that the generated samples are within the same class if the added perturbations are small enough, and the generated samples look as if they belong to different classes when the perturbations are large. However, note that it is also the case for FGSM and other such approaches: when their $\\epsilon$ is small, the noise is imperceptible; but with a large $\\epsilon$ , one often finds noisy instances that might be in a different class (see Table 1, digit 8 for an example). While we do observe this behavior in some cases, the corresponding classifiers require much more substantial changes to the input, which is why we can utilize our approach to evaluate black-box classifiers. ",
+        "bbox": [
+            174,
+            688,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "7 CONCLUSIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            328,
+            117
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we propose a framework for generating natural adversaries against black-box classifiers, and apply the same approach to both visual and textual domains. We obtain adversaries that are legible, grammatical, and meaningfully similar to the input. We show that these natural adversaries can help in interpreting the decision behavior and evaluating the accuracy of black-box classifiers even in absence of labeled training data. We use our approach, built upon recent work in GANs, to generate adversaries for a wide range of applications including image classification, textual entailment, and machine translation (via the Google Translate API). Code used to generate such natural adversaries is available at https://github.com/zhengliz/natural-adversary. ",
+        "bbox": [
+            174,
+            133,
+            825,
+            244
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            261,
+            326,
+            273
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We would like to thank Ananya, Casey Graff, Eric Nalisnick, Pouya Pezeshkpour, Robert Logan, and the anonymous reviewers for the discussions and feedback on earlier versions. We would also like to thank Ishaan Gulrajani and Junbo Jake Zhao for making their code available. This work is supported in part by Adobe Research and in part by FICO. The views expressed are those of the authors and do not reflect the official policy or position of the funding agencies. ",
+        "bbox": [
+            174,
+            284,
+            825,
+            353
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            375,
+            285,
+            388
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "David Alvarez-Melis and Tommi S. Jaakkola. A causal framework for explaining the predictions of black-box sequence-to-sequence models. In Empirical Methods in Natural Language Processing (EMNLP), 2017. ",
+        "bbox": [
+            174,
+            397,
+            825,
+            439
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Martin Arjovsky and Leon Bottou. Towards principled methods for training generative adversarial ´ networks. In International Conference on Learning Representations (ICLR), 2017. ",
+        "bbox": [
+            173,
+            446,
+            823,
+            477
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Martin Arjovsky, Soumith Chintala, and Leon Bottou. Wasserstein generative adversarial networks.´ In International Conference on Machine Learning (ICML), 2017. ",
+        "bbox": [
+            174,
+            484,
+            823,
+            513
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sanjeev Arora and Yi Zhang. Do gans actually learn the distribution? an empirical study. arXiv preprint 1706.08224, 2017. ",
+        "bbox": [
+            173,
+            521,
+            821,
+            550
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yonatan Belinkov and Yonatan Bisk. Synthetic and natural noise both break neural machine transla tion. In International Conference on Learning Representations (ICLR), 2018. ",
+        "bbox": [
+            173,
+            558,
+            821,
+            587
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Samuel R. Bowman, Gabor Angeli, Christopher Potts, and Christopher D. Manning. A large annotated corpus for learning natural language inference. In Empirical Methods in Natural Language Processing (EMNLP), 2015. ",
+        "bbox": [
+            173,
+            594,
+            826,
+            638
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Qian Chen, Xiaodan Zhu, Zhen-Hua Ling, Si Wei, Hui Jiang, and Diana Inkpen. Enhanced lstm for natural language inference. In Association for Computational Linguistics (ACL), 2017. ",
+        "bbox": [
+            174,
+            645,
+            823,
+            675
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nilesh Dalvi, Pedro Domingos, Sumit Sanghai, and Deepak Verma. Adversarial classification. In Proceedings of the ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, 2004. ",
+        "bbox": [
+            173,
+            683,
+            825,
+            726
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ian Goodfellow. NIPS 2016 Tutorial: Generative Adversarial Networks. arXiv preprint 1701.00160, 2016. ",
+        "bbox": [
+            171,
+            733,
+            823,
+            762
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In Advances in Neural Information Processing Systems (NIPS), 2014. ",
+        "bbox": [
+            173,
+            770,
+            826,
+            813
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ian Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. In International Conference on Learning Representations (ICLR), 2015. ",
+        "bbox": [
+            173,
+            820,
+            823,
+            851
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ishaan Gulrajani, Faruk Ahmed, Martin Arjovsky, Vincent Dumoulin, and Aaron Courville. Improved training of wasserstein gans. In Advances in Neural Information Processing Systems (NIPS), 2017. ",
+        "bbox": [
+            173,
+            858,
+            823,
+            887
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2016. ",
+        "bbox": [
+            173,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Zhiting Hu, Zichao Yang, Xiaodan Liang, Ruslan Salakhutdinov, and Eric P. Xing. Toward controlled generation of text. In International Conference on Machine Learning (ICML), 2017. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            133
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Robin Jia and Percy Liang. Adversarial examples for evaluating reading comprehension systems. In Empirical Methods in Natural Language Processing (EMNLP), 2017. ",
+        "bbox": [
+            173,
+            140,
+            823,
+            171
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Diederik P. Kingma and Max Welling. Stochastic gradient vb and the variational auto-encoder. In International Conference on Learning Representations (ICLR), 2014. ",
+        "bbox": [
+            171,
+            178,
+            823,
+            208
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alexey Kurakin, Ian Goodfellow, and Samy Bengio. Adversarial examples in the physical world. arXiv preprint 1607.02533, 2016. ",
+        "bbox": [
+            171,
+            215,
+            825,
+            246
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alexey Kurakin, Ian Goodfellow, and Samy Bengio. Adversarial machine learning at scale. In International Conference on Learning Representations (ICLR), 2017. ",
+        "bbox": [
+            173,
+            253,
+            825,
+            284
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun, Leon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to ´ document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998. ",
+        "bbox": [
+            173,
+            291,
+            823,
+            321
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jiwei Li, Will Monroe, and Dan Jurafsky. Understanding neural networks through representation erasure. arXiv preprint 1612.08220, 2016. ",
+        "bbox": [
+            173,
+            329,
+            823,
+            359
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Seyed-Mohsen Moosavi-Dezfooli, Alhussein Fawzi, Omar Fawzi, and Pascal Frossard. Universal adversarial perturbations. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2017. ",
+        "bbox": [
+            176,
+            367,
+            823,
+            410
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nicolas Papernot, Patrick McDaniel, and Ian Goodfellow. Transferability in machine learning: from phenomena to black-box attacks using adversarial samples. arXiv preprint 1605.07277, 2016a. ",
+        "bbox": [
+            173,
+            419,
+            823,
+            448
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nicolas Papernot, Patrick McDaniel, Somesh Jha, Matt Fredrikson, Z. Berkay Celik, and Ananthram Swami. The limitations of deep learning in adversarial settings. In IEEE European Symposium on Security and Privacy, 2016b. ",
+        "bbox": [
+            173,
+            457,
+            823,
+            500
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nicolas Papernot, Patrick McDaniel, Ian Goodfellow, Somesh Jha, Z. Berkay Celik, and Ananthram Swami. Practical black-box attacks against machine learning. In Proceedings of the ACM on Asia Conference on Computer and Communications Security, 2017. ",
+        "bbox": [
+            173,
+            507,
+            825,
+            551
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kexin Pei, Yinzhi Cao, Junfeng Yang, and Suman Jana. Deepxplore: Automated whitebox testing of deep learning systems. In the ACM Symposium on Operating Systems Principles, 2017. ",
+        "bbox": [
+            174,
+            559,
+            825,
+            589
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Marco Tulio Ribeiro, Sameer Singh, and Carlos Guestrin. Anchors: High-precision model-agnostic explanations. In AAAI Conference on Artificial Intelligence, 2018. ",
+        "bbox": [
+            173,
+            597,
+            825,
+            627
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Mihaela Rosca, Balaji Lakshminarayanan, David Warde-Farley, and Shakir Mohamed. Variational approaches for auto-encoding generative adversarial networks. arXiv preprint 1706.04987, 2017. ",
+        "bbox": [
+            173,
+            635,
+            825,
+            665
+        ],
+        "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 Advances in Neural Information Processing Systems (NIPS), 2016. ",
+        "bbox": [
+            173,
+            672,
+            826,
+            715
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. In International Conference on Learning Representations (ICLR), 2014. ",
+        "bbox": [
+            171,
+            724,
+            825,
+            767
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ilya Tolstikhin, Olivier Bousquet, Sylvain Gelly, and Bernhard Schoelkopf. Wasserstein auto-encoders. In International Conference on Learning Representations (ICLR), 2018. ",
+        "bbox": [
+            169,
+            776,
+            825,
+            806
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Fisher Yu, Yinda Zhang, Shuran Song, Ari Seff, and Jianxiong Xiao. Lsun: Construction of a large-scale image dataset using deep learning with humans in the loop. arXiv preprint 1506.03365, 2015. ",
+        "bbox": [
+            176,
+            814,
+            825,
+            857
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Junbo Jake Zhao, Yoon Kim, Kelly Zhang, Alexander M. Rush, and Yann LeCun. Adversarially regularized autoencoders. arXiv preprint 1706.04223, 2017. ",
+        "bbox": [
+            173,
+            866,
+            825,
+            895
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            263,
+            117
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A ILLUSTRATION WITH SYNTHETIC DATA ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            135,
+            539,
+            151
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "As shown in Figure 5 with a toy example of synthetic data, we can effectively map data instance $x$ to its corresponding latent dense vector $z ^ { \\prime }$ with the help of the inverter via ${ \\mathcal { T } } _ { \\gamma } ( x )$ , and then reconstruct $x$ with the help of the generator via $\\mathcal { G } _ { \\boldsymbol { \\theta } } ( \\mathcal { T } _ { \\boldsymbol { \\gamma } } ( \\boldsymbol { x } ) )$ . For a naive classifier with the horizontal line as decision boundary, adversarial examples should be points above the line given input data $x$ in Figure 5c. By searching in corresponding latent space, our approach finds $x ^ { * }$ on the left as a natural adversary because it is the closest one in semantic space (along the curve trace) and it exists within the data manifold. However, the gradient-based approaches may find the $x ^ { * }$ right above $x$ as adversarial in input space regardless of the actual data distribution. ",
+        "bbox": [
+            174,
+            165,
+            825,
+            277
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "B ALGORITHMS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            297,
+            325,
+            313
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 shows the pseudocode of the iterative search of our framework. Starting from the corresponding $z$ of the input instance $x$ , we iteratively move the search range outward in latent space until we have generated samples that change the prediction of the classifier $f$ . We improve the efficiency with Algorithm 2 by using a coarse-to-fine strategy and combining recursive and iterative search. We first search for adversaries in a wide search range, and recursively tighten the upper bound of the search range with denser sampling in bisections. Extra iterative search steps are taken to further tighten the upper bound of the optimal $\\Delta z$ . This hybrid shrinking search approach, shown in detail in Algorithm 2, is four times faster to achieve similar adversaries as the iterative search. ",
+        "bbox": [
+            173,
+            327,
+            825,
+            439
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "C ARCHITECTURE FOR CONTINUOUS IMAGES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            458,
+            571,
+            474
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Figure 3 shows the architecture of our framework for continuous images. We adopt WGAN (Arjovsky et al., 2017) with the objective function in Equation 1, and apply gradient penalty as proposed in Gulrajani et al. (2017). On top of the generator obtained from WGAN, we train an inverter by optimizing Equation 2. For handwritten digits from MNIST dataset, we train a WGAN of latent $ { z ^ { \\cdot } } \\in \\mathbb { R } ^ { 6 4 }$ , with a generator consisting of 3 transposed convolutional layers and ReLU activation, and a critic consisting of 3 convolutional layers with filter sizes (64, 128, 256) and strides (2, 2, 2). We include an inverter with 2 fully connected layers of dimensions (4096, 1024) on top of the critic’s last hidden layer. For “Church Outdoor” and “Tower” images from LSUN dataset, we follow similar procedures as in Gulrajani et al. (2017) training a WGAN of latent $z \\in \\mathbb { R } ^ { 1 2 8 }$ . The generator and critic are both residual networks. We use pre-activation residual blocks with two $3 \\times 3$ convolutional layers each and ReLU activation. The critic of 4 residual blocks performs downsampling using mean pooling after the second convolution, while the generator contains 4 residual blocks performing nearest-neighbor upsampling before the second convolution. We include an inverter with 3 fully connected layers of dimensions (8192, 2048, 512) on top of the critic’s last hidden layer. ",
+        "bbox": [
+            173,
+            489,
+            825,
+            684
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/d37ed3fdcf22f38faa49390a1becb9f26ab16da3786a9b33629deb293dd77940.jpg",
+        "image_caption": [
+            "Figure 5: Illustration with synthetic data. With training data that lies on a complex manifold (a), the inverter maps input to compact gaussian latent $z ^ { \\prime } = \\mathcal { T } _ { \\gamma } ( x )$ in (b), while the generator reconstructs the data via $\\mathcal { G } _ { \\boldsymbol { \\theta } } ( \\mathcal { T } _ { \\boldsymbol { \\gamma } } ( \\boldsymbol { x } ) )$ in (c). Given $f$ as a binary classifier with decision boundary as the horizontal line in (c), for an input $x$ , our approach returns $x ^ { * }$ on the left as natural adversary that lies on the manifold, while existing approaches may find $x ^ { * }$ on the right as the adversary, which is the nearest but impossible. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            215,
+            704,
+            789,
+            825
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 Iterative stochastic search in latent space for adversaries ",
+        "bbox": [
+            173,
+            103,
+            630,
+            118
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Require: a target black-box classifier $f$ , an input instance $x$ , and a corpus of relevant data $X$   \n1: Hyper-parameters: $N$ : number of samples in each iteration, $\\Delta r$ : increment of search range   \n2: Train a generator $\\mathcal { G } _ { \\theta }$ and an inverter $\\mathcal { T } _ { \\gamma }$ on $X$   \n3: $y  f ( x )$ , $z ^ { \\prime } \\gets \\mathcal { T } _ { \\gamma } ( x )$ , radius $r \\gets 0$   \n4: loop $\\triangleright$ loop till we find an adversary   \n5: $\\mathbf { \\boldsymbol { \\bar { S } } }  \\emptyset$   \n6: for sample $N$ random noise vectors $\\epsilon$ of norms within $( r , r + \\Delta r ]$ do   \n7: $\\tilde { z }  z ^ { \\prime } + \\epsilon$ , $\\tilde { x }  \\mathcal G _ { \\theta } ( \\tilde { z } ) , \\tilde { y }  f ( \\tilde { x } )$ $\\triangleright$ perturbation, sample generation, prediction   \n8: if $\\tilde { y } \\ne y$ then   \n9: $S \\gets S \\cup \\langle \\tilde { x } , \\tilde { y } , \\tilde { z } \\rangle$   \n10: if $S = \\emptyset$ then $\\triangleright$ no adversary generated   \n11: $r \\gets r + \\Delta r$ $\\triangleright$ move search range outward   \n12: else $\\triangleright$ certain adversary generated   \n13: $\\begin{array} { r } { \\mathbf { r e t u r n } \\left. x ^ { * } , y ^ { * } , z ^ { * } \\right. = \\operatorname * { a r g m i n } _ { \\langle \\check { x } , \\check { y } , \\check { z } \\rangle \\in S } \\| \\check { z } - z ^ { \\prime } \\| } \\end{array}$ $\\triangleright$ return the closest sample   \nRequire: a target black-box classifier $f$ , an input instance $x$ , and a corpus of relevant data $X$   \n1: Hyper-parameters: $N$ : number of samples in each iteration, $\\Delta r$ : increment of search range, $B$ :   \nlimit of iterations, $r$ : upper limit of search range   \n2: Train a generator $\\mathcal { G } _ { \\theta }$ and an inverter $\\mathcal { T } _ { \\gamma }$ on $X$   \n3: $y  f ( x )$ , $z ^ { \\prime } \\gets \\mathcal { T } _ { \\gamma } ( x )$ , $l \\gets 0 , i \\gets 0$   \n4: First, recursive search:   \n5: while $r - l \\geq \\Delta r$ do   \n6: $S \\gets \\emptyset$   \n7: for sample $N$ random noise vectors $\\epsilon$ of magnitude within $( l , r ]$ do   \n8: z˜ ← z0 + \u000f, $\\tilde { x }  \\mathcal G _ { \\theta } ( \\tilde { z } ) , \\tilde { y }  f ( \\tilde { x } )$   \n9: if $\\tilde { y } \\ne y$ then   \n10: $S \\gets S \\cup \\langle \\tilde { x } , \\tilde { y } , \\tilde { z } \\rangle$   \n11: if $S = \\emptyset$ then $\\triangleright$ no adversary generated   \n12: $l \\gets ( l + r ) / 2$ $\\triangleright$ shrink search range by half   \n13: else $\\triangleright$ certain adversary generated   \n14: $\\begin{array} { r l } & { \\langle x ^ { * } , y ^ { * } , z ^ { * } \\rangle = \\mathrm { a r g m i n } _ { \\langle \\check { x } , \\check { y } , \\check { z } \\rangle \\in S } \\| \\check { z } - z ^ { \\prime } \\| } \\\\ & { l  0 , r  \\| z ^ { * } - z ^ { \\prime } \\| } \\end{array}$ $\\triangleright$ store the closest sample   \n15: $\\triangleright$ update upper bound of $\\Delta z$   \n16: Then, iterative search:   \n17: while $i < B$ and $r > 0$ do   \n18: $S \\gets \\emptyset , l \\gets \\operatorname* { m a x } ( 0 , r - \\Delta r )$   \n19: for sample $N$ random noise vectors $\\epsilon$ of norms within $( l , r ]$ do   \n20: $\\tilde { z } \\gets z ^ { \\prime } + \\epsilon , \\tilde { x } \\gets \\mathcal G _ { \\theta } ( \\tilde { z } ) , \\tilde { y } \\gets f ( \\tilde { x } )$   \n21: if $\\tilde { y } \\ne y$ then   \n22: $S \\gets S \\cup \\langle \\tilde { x } , \\tilde { y } , \\tilde { z } \\rangle$   \n23: if $S = \\emptyset$ then   \n24: $i \\gets i + 1 , r \\gets r - \\Delta r$ $\\triangleright$ increase counter, continue searching   \n25: else   \n26: $\\begin{array} { r l } & { \\langle x ^ { * } , y ^ { * } , z ^ { * } \\rangle = \\mathrm { a r g m i n } _ { \\langle \\check { x } , \\check { y } , \\check { z } \\rangle \\in S } \\| \\check { z } - z ^ { \\prime } \\| } \\\\ & { i  0 , r  \\| z ^ { * } - z ^ { \\prime } \\| } \\end{array}$ $\\triangleright$ store the closest sample   \n27: $\\triangleright$ reset counter, update upper bound of $\\Delta z$   \n28: return $\\langle x ^ { * } , y ^ { * } , z ^ { * } \\rangle$ ",
+        "bbox": [
+            178,
+            122,
+            826,
+            327
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            368,
+            826,
+            803
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "D ARCHITECTURE FOR DISCRETE TEXT ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            833,
+            524,
+            849
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We use the adversarially regularized autoencoder (ARAE) (Zhao et al., 2017) for encoding discrete text into continuous codes as shown in Figure 6. ARAE model encodes a sentence with an LSTM encoder into continuous code and performs adversarial training on the codes generated from noise and data to approximate the data distribution. We introduce an inverter that maps these continuous codes ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b225da031e8b914c3e393286a235c87a27aa8ad38d6262a61fd148f64e912018.jpg",
+        "text": "$$\n\\begin{array}{c} \\begin{array} { r l } & { \\mathrm { , ~ } \\mathrm { ~ n o i s e ~ } \\tilde { z }  [ \\mathrm { g e n e r a t o r ~ } \\mathcal { G } _ { \\theta } ]  \\mathrm { ~ c o d e s ~ } \\tilde { c }  [ \\operatorname* { d e c o d e r } \\mathcal { D } _ { \\psi } ]  \\mathrm { ~ s a m p l e s ~ } \\tilde { x } } \\\\ & { \\mathrm { , ~ } } \\\\ & { \\mathrm { ~ } \\mathrm { ~ } \\mathrm { ~ p e r t u r b a t i o n s ~ } } \\\\ & { \\mathrm { ~ } \\cdot } \\\\ & { \\mathrm { ~ } \\mathrm { ~ l a t e n t ~ } z ^ { \\prime }  [ \\mathrm { i n v e r t e r ~ } \\mathcal { Z } _ { \\gamma } ]  \\mathrm { ~ c o d e ~ } c  [ \\mathrm { e n c o d e r ~ } \\mathcal { E } _ { \\phi } ]  \\mathrm { ~ d i s c r e t e ~ } x } \\end{array}  \\sum _ { \\mathrm { ~ } \\alpha = \\nu \\mathrm { ~ r a t e r s a r y ~ } } ^ { \\mathrm { ~ n a t u r a l ~ } }  \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            183,
+            98,
+            834,
+            188
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "",
+        "image_caption": [
+            "Figure 6: Model Architecture for Text. Our model incorporates in the adversarially regularized autoencoder (ARAE) (Zhao et al., 2017) for encoding discrete $x$ into continuous code $c$ and decoding continuous $\\tilde { c }$ into discrete $\\tilde { x }$ when generating samples. "
+        ],
+        "image_footnote": [],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "into the Gaussian space of $z \\in \\mathbb { R } ^ { 1 0 0 }$ . We use 4 layers of CNN with varying filter sizes (300, 500, 700, and 1000), strides (2, 2, 2) and context windows (5, 5, 3) for encoding text $x$ , into continuous space $c \\in \\mathbb { R } ^ { 3 0 0 }$ . For the decoder, we use a single-layer LSTM with hidden dimension of 300. We also train two MLPs, one each for the generator and the inverter, to learn mappings from noise to continuous codes and continuous codes to noise respectively. The loss functions for different components of the ARAE model, which are autoencoder reconstruction loss and WGAN loss functions for generator and critic, are described in Equations (4), (5), (6) respectively. We first train the ARAE components of encoder, decoder and generator using WGAN strategy, followed by the inverter on top of these with loss function in (7), by minimizing the Jensen-Shannon divergence between the inverted continuous codes and noise samples. ",
+        "bbox": [
+            173,
+            273,
+            825,
+            415
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/cf246e13bd84e160b06e67afc0507fcfb4d409540e5de505fe932fbeb4a3563e.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\displaystyle \\operatorname* { m i n } _ { \\phi , \\phi } \\mathcal { L } _ { \\mathcal { E } , \\mathcal { D } } ( \\phi , \\psi ) = \\operatorname* { m a x } _ { \\phi , \\psi } \\mathbb { E } _ { x } [ \\log p _ { \\psi } ( x | \\mathcal { E } _ { \\phi } ( x ) ) ] } \\\\ & { \\quad \\quad \\quad \\quad \\quad \\operatorname* { m i n } _ { \\omega } \\mathcal { L } _ { \\mathcal { C } } ( \\omega ) = \\operatorname* { m a x } _ { \\omega } \\mathbb { E } _ { x } [ \\mathcal { C } _ { \\omega } ( \\mathcal { E } _ { \\phi } ( x ) ) ] - \\mathbb { E } _ { z } [ \\mathcal { C } _ { \\omega } ( \\mathcal { G } _ { \\theta } ( z ) ) ] } \\\\ & { \\displaystyle \\operatorname* { m i n } _ { \\phi , \\theta } \\mathcal { L } _ { \\mathcal { E } , \\mathcal { G } } ( \\phi , \\theta ) = \\operatorname* { m i n } _ { \\phi , \\theta } \\mathbb { E } _ { x } [ \\mathcal { C } _ { \\omega } ( \\mathcal { E } _ { \\phi } ( x ) ) ] - \\mathbb { E } _ { z } [ \\mathcal { C } _ { \\omega } ( \\mathcal { G } _ { \\theta } ( z ) ) ] } \\\\ & { \\quad \\quad \\quad \\quad \\operatorname* { m i n } _ { \\gamma } \\mathcal { L } _ { \\mathcal { T } } ( \\gamma ) = \\operatorname* { m i n } _ { \\gamma } \\mathbb { E } _ { x } \\| \\mathcal { G } _ { \\theta } ( \\mathcal { I } _ { \\gamma } ( \\mathcal { E } _ { \\phi } ( x ) ) ) - \\mathcal { E } _ { \\phi } ( x ) \\| + \\mathbb { E } _ { z } [ \\mathbf { J } \\mathbf { S } \\mathbf { D } ( z , \\mathcal { L } _ { \\gamma } ( \\mathcal { G } _ { \\theta } ( z ) ) ) ] } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            236,
+            429,
+            761,
+            532
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We train our framework on the sentences up to length 10 from Stanford Natural Language Inference (SNLI) (Bowman et al., 2015) dataset, with hyper-parameters of $\\Delta r = 0 . 0 1$ and $N = 1 0 0$ . Table 9 shows some examples of the perturbations generated automatically by our approach, which are grammatical and semantically close to the original sentences. ",
+        "bbox": [
+            173,
+            546,
+            826,
+            604
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "D.1 TEXTUAL ENTAILMENT EXAMPLES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            632,
+            464,
+            646
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We provide additional examples of generated adversarial hypotheses for sentences from the SNLI corpus in Table 10, which corresponds to the examples in the main text in Table 3. ",
+        "bbox": [
+            173,
+            662,
+            823,
+            690
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "D.2 MACHINE TRANSLATION EXAMPLES",
+        "text_level": 1,
+        "bbox": [
+            176,
+            719,
+            472,
+            734
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We provide additional examples of the two probing functions in Table 11 and Table 12, corresponding to Table 4 and Table 5 in the main text, respectively. ",
+        "bbox": [
+            173,
+            750,
+            823,
+            779
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/20e7648ebbb7607e9d8fd5ba8a6abad464fa22a0ff92227e243a622f8529be1b.jpg",
+        "table_caption": [
+            "Table 9: Text perturbations. Examples are generated by perturbing the origins in semantic space. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Original</td><td></td><td>Some dogs are running on a deserted beach.A man playing an electric guitar on stage.</td></tr><tr><td rowspan=\"5\">Perturbation</td><td>Some dogs are running on a grassy field.</td><td>A man is playing an electric guitar.</td></tr><tr><td>Some dogs are walking along a path.</td><td>A man is playing an acoustic guitar.</td></tr><tr><td>Some dogs are running down a hill.</td><td>A man is playing an accordion.</td></tr><tr><td>A dog is running on a grassy field.</td><td>A man is playing with an electronic device.</td></tr><tr><td>A dog is running down a trail.</td><td>A man is playing with an elephant.</td></tr></table>",
+        "bbox": [
+            173,
+            829,
+            820,
+            921
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/33a5bf1ee63a150cd359d649a99f2d5d6019c6fb095dcd2668d0de77bb32be3e.jpg",
+        "table_caption": [
+            "Table 10: Textual Entailment. For a pair of premise $\\left( \\mathbf { p } : \\right)$ and hypothesis $( \\mathbf { h } : )$ , we present the generated adversaries for three classifiers by perturbing the hypothesis $( \\mathbf { h } ^ { \\prime } : \\mathbf { \\epsilon } )$ . The last column provides the true label, followed by the changes in the prediction from each classifier. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Classifiers</td><td>Sentences</td><td>Label</td></tr><tr><td>Original</td><td>p : The man walks among the large trees. h : The man is lost in the woods.</td><td>Neutral</td></tr><tr><td>Embedding</td><td>h&#x27;: The man is lost at the woods.</td><td>Contradiction →Neutral</td></tr><tr><td>LSTM</td><td>h&#x27; : The man is crying in the woods.</td><td>Neutral→Contradiction</td></tr><tr><td>TreeLSTM</td><td>h&#x27;：The man is lost ina bed.</td><td>Neutral → Contradiction</td></tr></table>",
+        "bbox": [
+            235,
+            155,
+            758,
+            253
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/7abcee71ae60877307b43068841c3f0c19346b1a086f762201c100b0f790734a.jpg",
+        "table_caption": [
+            "Table 11: Machine Translation. “Adversaries” that introduce the word “stehen” into the Google translation system by perturbing English sentences. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Source Sentence (English)</td><td>Generated Translation (German)</td></tr><tr><td>s :Asian women are sitting in a Restraunt.</td><td>Asiatische Frauen sitzen in einem Restaurant. s :Asian kids are standing in a Restraunt.Asiatische Kinder stehen in einem Restaurant.</td></tr><tr><td></td><td></td></tr><tr><td>s : People sitting on the floor.</td><td>Leute sitzen auf dem Boden.</td></tr><tr><td>s&#x27; : People standing on the field.</td><td>Leute,die auf dem Feld stehen.</td></tr></table>",
+        "bbox": [
+            210,
+            323,
+            782,
+            410
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/e32763f05b9d7e6d4408cf78d38fce1317ee750c93ed2ecf7787fa118d02d008.jpg",
+        "table_caption": [
+            "Table 12: “Adversaries” that find dropped verbs in English-To-German translation. The left column contains the original sentence $s$ and its adversary $s ^ { \\prime }$ . The right column contains the translations of $s$ and $s ^ { \\prime }$ , with English translation provided for legibility. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Source Sentence (English)</td><td>Generated Translation (German)</td></tr><tr><td>s : A man looks back while laughing and walking. s : A man is laughing walking down the ground.</td><td>Ein Mann schaut beim Lachen und Gehen zurck. Ein Mann lacht auf dem Boden. (A man laughs on the floor.)</td></tr><tr><td>s : She is cooking food while wearing a dress. s&#x27; : She is cooking dressed for a wedding.</td><td>Sie kocht Essen, whrend sie ein Kleid trgt. Sie kocht fr eine Hochzeit. (She cooks for a wedding.)</td></tr></table>",
+        "bbox": [
+            181,
+            492,
+            812,
+            604
+        ],
+        "page_idx": 14
+    }
+]

parse/train/i80OPhOCVH2/i80OPhOCVH2.md

@@ -0,0 +1,366 @@
+# ON THE BOTTLENECK OF GRAPH NEURAL NETWORKS AND ITS PRACTICAL IMPLICATIONS
+
+Uri Alon & Eran Yahav   
+Technion, Israel   
+{urialon,yahave}@cs.technion.ac.il
+
+# ABSTRACT
+
+Since the proposal of the graph neural network (GNN) by Gori et al. (2005) and Scarselli et al. (2008), one of the major problems in training GNNs was their struggle to propagate information between distant nodes in the graph. We propose a new explanation for this problem: GNNs are susceptible to a bottleneck when aggregating messages across a long path. This bottleneck causes the over-squashing of exponentially growing information into fixed-size vectors. As a result, GNNs fail to propagate messages originating from distant nodes and perform poorly when the prediction task depends on long-range interaction. In this paper, we highlight the inherent problem of over-squashing in GNNs: we demonstrate that the bottleneck hinders popular GNNs from fitting long-range signals in the training data; we further show that GNNs that absorb incoming edges equally, such as GCN and GIN, are more susceptible to over-squashing than GAT and GGNN; finally, we show that prior work, which extensively tuned GNN models of long-range problems, suffer from over-squashing, and that breaking the bottleneck improves their state-of-the-art results without any tuning or additional weights. Our code is available at https://github.com/tech-srl/bottleneck/ .
+
+# 1 INTRODUCTION
+
+Graph neural networks (GNNs) (Gori et al., 2005; Scarselli et al., 2008; Micheli, 2009) have seen sharply growing popularity over the last few years (Duvenaud et al., 2015; Hamilton et al., 2017; Xu et al., 2019). GNNs provide a general framework to model complex structural data containing elements (nodes) with relationships (edges) between them. A variety of real-world domains such as social networks, computer programs, chemical and biological systems can be naturally represented as graphs. Thus, many graph-structured domains are commonly modeled using GNNs.
+
+A GNN layer can be viewed as a message-passing step (Gilmer et al., 2017), where each node updates its state by aggregating messages flowing from its direct neighbors. GNN variants (Li et al., 2016; Velickovi ˇ c et al., 2018; Kipf and Welling, 2017) mostly differ in how each node aggregates the ´ representations of its neighbors with its own representation. However, most problems also require the interaction between nodes that are not directly connected, and they achieve this by stacking multiple GNN layers. Different learning problems require different ranges of interaction between nodes in the graph to be solved. We call this required range of interaction between nodes – the problem radius.
+
+In practice, GNNs were observed not to benefit from more than few layers. The accepted explanation for this phenomenon is over-smoothing: node representations become indistinguishable when the number of layers increases (Wu et al., 2020). Nonetheless, over-smoothing was mostly demonstrated in short-range tasks (Li et al., 2018; Klicpera et al., 2018; Chen et al., 2020a; Oono and Suzuki, 2020; Zhao and Akoglu, 2020; Rong et al., 2020; Chen et al., 2020b) – tasks that have small problem radii, where a node’s correct prediction mostly depends on its local neighborhood. Such tasks include paper subject classification (Sen et al., 2008) and product category classification (Shchur et al., 2018). Since the learning problems depend mostly on short-range information in these datasets, it makes sense why more layers than the problem radius might be extraneous. In contrast, in tasks that also depend on long-range information (and thus have larger problem radii), we hypothesize that the explanation for limited performance is over-squashing. We further discuss the differences between over-squashing and over-smoothing in Section 6.
+
+![](images/8407bf079c7c5171bd2ed7821254a824983cb2959bb1186fbf6ece862d24d3c3.jpg)  
+Figure 1: The bottleneck that existed in RNN seq2seq models (before attention) is strictly more harmful in GNNs: information from a node’s exponentially-growing receptive field is compressed into a fixed-size vector. Black arrows are graph edges; red curved arrows illustrate information flow.
+
+To allow a node to receive information from other nodes at a radius of $K$ , the GNN needs to have at least $K$ layers, or otherwise, it will suffer from under-reaching – these distant nodes will simply not be aware of each other. Clearly, to avoid under-reaching, problems that depend on long-range interaction require as many GNN layers as the range of the interaction. However, as the number of layers increases, the number of nodes in each node’s receptive field grows exponentially. This causes over-squashing: information from the exponentially-growing receptive field is compressed into fixed-length node vectors. Consequently, the graph fails to propagate messages flowing from distant nodes, and learns only short-range signals from the training data.
+
+In fact, the GNN bottleneck is analogous to the bottleneck of sequential RNN models. Traditional seq2seq models (Sutskever et al., 2014; Cho et al., 2014a;b) suffered from a bottleneck at every decoder state – the model had to encapsulate the entire input sequence into a fixed-size vector. In RNNs, the receptive field of a node grows linearly with the number of recursive applications. However in GNNs, the bottleneck is asymptotically more harmful, because the receptive field of a node grows exponentially. This difference is illustrated in Figure 1.
+
+This work does not aim to propose a new GNN variant. Rather, our main contribution is introducing the over-squashing phenomenon – a novel explanation for the major and well-known issue of training GNNs for long-range problems, and showing its harmful practical implications. We use a controlled problem to demonstrate how over-squashing prevents GNNs from fitting long-range patterns in the data, and to provide theoretical lower bounds for the required hidden size given the problem radius (Section 5). We show, analytically and empirically, that GCN (Kipf and Welling, 2017) and GIN (Xu et al., 2019) are susceptible to over-squashing more than other types of GNNs such as GAT (Velickovi ˇ c et al., 2018) and GGNN (Li et al., 2016). We further show that prior work that extensively ´ tuned GNNs to real-world datasets suffer from over-squashing: breaking the bottleneck using a simple fully adjacent layer reduces the error rate by $42 \%$ in the QM9 dataset, by $12 \%$ in ENZYMES, by $4 . 8 \%$ in NCI1, and improves accuracy in VARMISUSE, without any additional tuning.
+
+# 2 PRELIMINARIES
+
+A directed graph $\mathcal { G } = ( \nu , \mathcal { E } )$ contains nodes $\nu$ and edges $\mathcal { E }$ , where $( u , v ) \in \mathcal { E }$ denotes an edge from a node $u$ to a node $v$ . For brevity, in the following definitions we treat all edges as having the same type; in general, every edge can have a type and features (Schlichtkrull et al., 2018).
+
+Graph neural networks Graph neural networks operate by propagating neural messages between neighboring nodes. At every propagation step (a graph layer): the network computes each node’s sent message; every node aggregates its received messages; and each node updates its representation by combining the aggregated incoming messages with its own previous representation.
+
+Formally, each node is associated with an initial representation $\mathbf { h } _ { v } ^ { ( 0 ) } \in \mathcal { R } ^ { d _ { 0 } }$ . This representation is usually derived from the node’s label or its given features. Then, a GNN layer updates each node’s representation given its neighbors, yielding $\mathbf { h } _ { v } ^ { ( 1 ) } \in \mathcal { R } ^ { d }$ . In general, the $k$ -th layer of a GNN is a parametric function $f _ { k }$ that is applied to each node by considering its neighbors:
+
+![](images/9e6301e40ec83ebbb2857dd270e87de35b9baea6b4b06af69d18e8c42e7cfa21.jpg)  
+Figure 2: The NEIGHBORSMATCH: green nodes $\textcircled{4}$ , $\textcircled{8}$ , $\textcircled{ C} )$ have blue neighbors $\textcircled{)}$ and an alphabetical label. The goal is to predict the label (A, B, or C) of the green node that has the same number of blue neighbors as the target node $\textcircled{2}$ in the same graph. In this example, the correct label is $\mathbf { C }$ , because the target node has two blue neighbors, like the node marked with $\textrm { C }$ in the same graph.
+
+$$
+\mathbf h _ { v } ^ { ( k ) } = f _ { k } \left( \mathbf h _ { v } ^ { ( k - 1 ) } , \{ \mathbf h _ { u } ^ { ( k - 1 ) } \ | \ u \in \mathcal N _ { v } \} ; \theta _ { k } \right)
+$$
+
+where $\mathcal { N } _ { v }$ is the set of nodes that have edges to $v$ : $\mathcal { N } _ { v } = \{ u \in \mathcal { V } | ( u , v ) \in \mathcal { E } \}$ . The total number of layers $K$ is usually determined empirically as a hyperparameter.
+
+The design of the function $f$ is what mostly distinguishes one type of GNN from the other. For example, graph convolutional networks (GCN) define $f$ as:
+
+$$
+\mathbf { h } _ { v } ^ { ( k ) } = \sigma \left( \sum _ { u \in \mathcal { N } _ { v } \cup \{ v \} } \frac { 1 } { c _ { u , v } } W ^ { ( k ) } \mathbf { h } _ { u } ^ { ( k - 1 ) } \right)
+$$
+
+where $\sigma$ is a nonlinearity such as $R e L U$ , and $c _ { u , v }$ is a normalization factor often set to $\sqrt { \left| \mathcal { N } _ { v } \right| \cdot \left| \mathcal { N } _ { u } \right| }$ or $| \mathcal { N } _ { v } |$ (Hamilton et al., 2017). As another example, graph isomorphism networks (GIN) (Xu et al., 2019) update a node’s representation using the following definition:
+
+$$
+\mathbf { h } _ { v } ^ { ( k ) } = M L P ^ { ( k ) } \left( \left( 1 + \epsilon ^ { ( k ) } \right) \mathbf { h } _ { v } ^ { ( k - 1 ) } + \sum _ { u \in \mathcal { N } _ { v } } \mathbf { h } _ { u } ^ { ( k - 1 ) } \right)
+$$
+
+Usually, the last ( $K$ -th) layer’s output is used for prediction: in node-prediction, $\mathbf { h } _ { v } ^ { ( K ) }$ is used to predict a label for $v$ ; in graph-prediction, a permutation-invariant “readout” function aggregates the nodes of the final layer using summation, averaging, or a weighted sum (Li et al., 2016).
+
+# 3 THE GNN BOTTLENECK
+
+Given a graph $\mathcal { G } = ( \nu , \mathcal { E } )$ and a given node $v$ , we denote the problem’s required range of interaction, the problem radius, by $r , \ r$ is generally unknown in advance, and usually approximated empirically by tuning the number of layers $K$ . We denote the set of nodes in the receptive field of $v$ by $\mathcal { N } _ { v } ^ { \breve { K } }$ , which is defined recursively as $\mathcal { N } _ { v } ^ { 1 } : = \mathcal { N } _ { v }$ and $\mathcal { N } _ { v } ^ { K } : = \mathcal { N } _ { v } ^ { K - 1 } \cup \{ w \mid ( w , u ) \in \mathcal { E } \wedge u \in \mathcal { N } _ { v } ^ { K ^ { - 1 } } \}$ .
+
+When a prediction problem relies on long-range interaction between nodes, the GNN must have as many layers $K$ as the estimated range of these interactions, or otherwise, these distant nodes would not be able to interact. It is thus required that $K \geq r$ . However, the number of nodes in each node’s receptive field grows exponentially with the number of layers: $\left| \mathcal { N } _ { v } ^ { K } \right| = \mathcal { O } \left( \exp \left( K \right) \right)$ (Chen et al., 2018). As a result, an exponentially-growing amount of information is squashed into a fixed-length vector (the vector resulting from the $\bar { \sum }$ in Equations (2) and (3)), and crucial messages fail to reach their distant destinations. Instead, the model learns only short-ranged signals from the training data and consequently might generalize poorly at test time.
+
+Example Consider the NEIGHBORSMATCH problem of Figure 2. Green nodes $( \textcircled { \textbf { A } } , \textcircled { \textbf { B } } , \textcircled { \textbf { C } } )$ have a varying number of blue neighbors $\textcircled{)}$ and an alphabetical label. Each example in the dataset is a different graph that has a different mapping from numbers of neighbors to labels. The rest of the graph (marked as ) represents a general, unknown, graph structure. The goal is to predict a label for the target node, which is marked with a question mark $\textcircled{2}$ , according to its number of blue neighbors. The correct answer is C in this case, because the target node has two blue neighbors, like the node marked with C in the same graph. Every example in the dataset has a different mapping from numbers of neighbors to labels, and thus message propagation and matching between the target node and all the green nodes must be performed for every graph in the dataset.
+
+Since the model must propagate information from all green nodes before predicting the label, a bottleneck at the target node is inevitable. This bottleneck causes over-squashing, which can prevent the model from fitting the training data perfectly. We demonstrate the bottleneck empirically in this problem in Section 4; in Section 5, we provide theoretical lower bounds for the GNN’s hidden size. Obviously, adding direct edges between the target node and the green nodes, or making the existing edges bidirectional, could ease information flow for this specific problem. However, in real-life domains (e.g., molecules), we do not know the optimal message propagation structure a priori, and must use the given relations (such as bonds between atoms) as the graph’s edges.
+
+Although this is a contrived problem, it resembles real-world problems that are often modeled as graphs. For example, a computer program in a language such as Python may declare multiple variables (i.e., the green nodes in Figure 2) along with their types and values (their numbers of blue neighbors in Figure 2); later in the program, predicting which variable should be used in a specific location (predict the alphabetical label in Figure 2) must use one of the variables that are available in scope based on the required type and the required value at that point. We experiment with this VARMISUSE problem in Section 4.4.
+
+Short- vs. long-range problems Much of prior GNN work has focused on problems that were local in nature, with small problem radii, where the underlying inductive bias was that a node’s most relevant context is its local neighborhood, and long-range interaction was not necessarily needed. With the growing popularity of GNNs, their adoption expanded to domains that required longer-range information propagation as well, without addressing the inherent bottleneck. In this paper, we focus on problems that require long-range information. That is, a correct prediction requires considering the local environment of a node and interactions beyond the close neighborhood. For example, a chemical property of a molecule (Ramakrishnan et al., 2014; Gilmer et al., 2017) can depend on the combination of atoms that reside in the molecule’s opposite sides. Problems of this kind require long-range interaction, and thus, a large number of GNN layers. Since the receptive field of each node grows exponentially with the number of layers, the more layers – over-squashing is more harmful.
+
+In problems that are local in nature (small $r$ ) – the bottleneck is less troublesome, because a GNN can perform well with only few layers (e.g., $K { = } 2$ layers in Kipf and Welling (2017)), and the receptive field of a node can be exponentially smaller. Domains such as citation networks (Sen et al., 2008), social networks (Leskovec and Mcauley, 2012), and product recommendations (Shchur et al., 2018) usually raise short-range problems and are thus not the focus of this paper. So, how long is long-range? We discuss and analyze this question in Section 5.
+
+# 4 EVALUATION
+
+First, we wish to empirically show that the GNN bottleneck exists, and find the smallest values of $r$ that raise over-squashing. We generated a synthetic benchmark that is theoretically solvable; however, in practice, all GNNs fail to reach $100 \%$ training accuracy because of the bottleneck (Section 4.1). Second, we examine whether the bottleneck exists in prior work, which addressed real-world problems (Sections 4.2 to 4.4).
+
+# 4.1 SYNTHETIC BENCHMARK: NEIGHBORSMATCH
+
+The NEIGHBORSMATCH problem (Figure 2) is a contrived problem that we designed to provide an intuition to the extent of the effect of over-squashing, while allowing us to control the problem radius $r$ , and thus control the intensity of over-squashing. We focus on the training accuracy of a model, to show that over-squashing prevents models from fitting long-range signals in the training set.
+
+TREE-NEIGHBORSMATCH From the perspective of a single node $v$ , the rest of the graph may look like a tree of height $K$ , rooted at $v$ ( $\mathrm { { X u } }$ et al., 2018; Garg et al., 2020). To simulate this exponentially-growing receptive field, we created an instance of the general NEIGHBORSMATCH problem that we described in Section 3 and portrayed in Figure 2. We instantiated the subgraph in the middle of the graph (marked as $\textcircled{8}$ in Figure 2) as a binary tree of depth depth where the green nodes are its leaves, and the target node is the tree’s root. All edges are directed toward the root, such that information is propagated from all nodes toward the target node. The goal, as in Section 3, is to predict a label for the target node, where the correct answer is the label of the green node that has the same number of blue neighbors as the target node. An illustration is shown in Figure 5 in the appendix. This allows us to control the problem radius, i.e., $\begin{array} { r } { r = d e p t h { } } \end{array}$ . In this section we observe the bottleneck empirically; in Section 5 we provide a lower bound for the GNN’s hidden size given $r$
+
+Model We implemented a network with $r { \mathrm { + } } 1$ graph layers to allow an additional nonlinearity after the information from the leaves reaches the target node. Our PyTorch Geometric (Fey and Lenssen, 2019) implementation is available at https://github.com/tech-srl/bottleneck/. Our training configuration and hyperparameter ranges are detailed in Appendix A.
+
+Results Figure 3 shows the following surprising results: some GNNs fail to fit the dataset starting from $r { = } 4$ . For example, the training accuracy of GCN (Kipf and Welling, 2017) at $r { = } 4$ is $70 \%$ . At $r { = } 5$ , all GNNs fail to perfectly fit the data. Starting from $r { = } 4$ , the models suffered from oversquashing that resulted in underfitting: the bottleneck prevented the models from distinguishing between different training examples, even after they were observed tens of thousands of times. These results clearly show the existence of over-squashing, starting from $r { = } 4$ .
+
+![](images/a9eb670cf23b5285f37ad7a8dd40f7843778c7fe3847a7a76d62059a2fd31c64.jpg)  
+Figure 3: Accuracy across problem radius (tree depth) in the NEIGHBORSMATCH problem. Over-squashing starts to affect GCN and GIN even at $r = 4$ .
+
+Why did some GNNs perform better than others? GCN and GIN managed to perfectly fit $r { = } 3$ at most, while GGNN and GAT also reached $100 \%$ accuracy at $r { = } 4$ . This difference can be explained by their neighbor aggregation computation: consider the target node that receives messages in the $r ^ { \mathrm { : } }$ ’th step. GCN and GIN aggregate all neighbors before combining them with the target node’s representation; they thus must compress the information flowing from all leaves into a single vector, and only afterward interact with the target node’s own representation (Equations (2) and (3)). In contrast, GAT uses attention to weight incoming messages given the target’s representation: at the last layer only, the target node can ignore the irrelevant incoming edge, and absorb only the relevant incoming edge, which contains information flowing from half of the leaves. That is, a single vector compresses only half of the information. Since the number of leaves grows exponentially with $r$ , it is expected that GNNs that need to compress only half of the information (GGNN and GAT) will succeed at an $r$ that is larger by 1. Following Levy et al. (2018), we hypothesize that the GRU cell in GGNNs filters incoming edges as GAT, but perform this filtering as element-wise attention.
+
+If all GNNs have reached low training accuracy, how do GNN-based models usually do fit the training data in public datasets of long-range problems? We hypothesize that they overfit shortrange signals and artifacts from the training set, rather than learning the long-range information that was squashed in the bottleneck, and thus generalize poorly at test time.
+
+# 4.2 QUANTUM CHEMISTRY: QM9
+
+We wish to measure over-squashing in existing models. But, how can we measure over-squashing? Instead, we measure whether breaking the bottleneck improves the results of long-range problems.
+
+Adding a fully-adjacent layer (FA) In Sections 4.2 to 4.4, we took extensively tuned models from previous work, and modified adjacency in the last layer: given a GNN with $K$ layers, we modified the $K$ -th layer to be a fully-adjacent layer (FA). A fully-adjacent layer is a GNN layer in which every pair of nodes is connected by an edge. In terms of Equations (1) to (3), converting an existing layer to be fully-adjacent means that $\mathcal { N } _ { v } : = \mathcal { V }$ for every node $v \in \mathcal V$ , in that layer only. This does not change the type of layer nor add weights, but only changes adjacency of a data sample in a single layer. Thus, the $K - 1$ graph layers exploit the graph structure using their original sparse topology, and only the
+
+Table 1: Average error rates (5 runs $\pm$ stdev for each property) on the QM9 dataset. The best result for every property in every GNN type is highlighted in bold. Results marked with $\dagger$ were previously reported by Brockschmidt (2020) and reproduced by us.   
+
+<table><tr><td rowspan="2">Property</td><td colspan="2">R-GIN</td><td colspan="2">R-GAT</td><td colspan="2">GGNN</td></tr><tr><td>baset</td><td>+FA</td><td>baset</td><td>+FA</td><td>baset</td><td>+FA</td></tr><tr><td>mu</td><td>2.64±0.11</td><td>2.54±0.09</td><td>2.68±0.06</td><td>2.73±0.07</td><td>3.85±0.16</td><td>3.53±0.13</td></tr><tr><td>alpha</td><td>4.67±0.52</td><td>2.28±0.04</td><td>4.65±0.44</td><td>2.32±0.16</td><td>5.22±0.86</td><td>2.72±0.12</td></tr><tr><td>HOMO</td><td>1.42±0.01</td><td>1.26±0.02</td><td>1.48±0.03</td><td>1.43±0.02</td><td>1.67±0.07</td><td>1.45±0.04</td></tr><tr><td>LUMO</td><td>1.50±0.09</td><td>1.34±0.04</td><td>1.53±0.07</td><td>1.41±0.03</td><td>1.74±0.06</td><td>1.63±0.06</td></tr><tr><td>gap</td><td>2.27±0.09</td><td>1.96±0.04</td><td>2.31±0.06</td><td>2.08±0.05</td><td>2.60±0.06</td><td>2.30±0.05</td></tr><tr><td>R2</td><td>15.63±1.40</td><td>12.61±0.37</td><td>52.39 ±42.5</td><td>15.76±1.17</td><td>35.94±35.7</td><td>14.33±0.47</td></tr><tr><td>ZPVE</td><td>12.93±1.81</td><td>5.03±0.36</td><td>14.87±2.88</td><td>5.98±0.43</td><td>17.84±3.61</td><td>5.24±0.30</td></tr><tr><td>UO</td><td>5.88±1.01</td><td>2.21±0.12</td><td>7.61±0.46</td><td>2.19±0.25</td><td>8.65±2.46</td><td>3.35±1.68</td></tr><tr><td>U</td><td>18.71±23.36</td><td>2.32±0.18</td><td>6.86±0.53</td><td>2.11±0.10</td><td>9.24±2.26</td><td>2.49±0.34</td></tr><tr><td>H</td><td>5.62±0.81</td><td>2.26±0.19</td><td>7.64±0.92</td><td>2.27±0.29</td><td>9.35±0.96</td><td>2.31±0.15</td></tr><tr><td>G</td><td>5.38±0.75</td><td>2.04±0.24</td><td>6.54±0.36</td><td>2.07±0.07</td><td>7.14±1.15</td><td>2.17±0.29</td></tr><tr><td>Cv</td><td>3.53±0.37</td><td>1.86±0.03</td><td>4.11±0.27</td><td>2.03±0.14</td><td>8.86±9.07</td><td>2.25±0.20</td></tr><tr><td>Omega</td><td>1.05±0.11</td><td>0.80±0.04</td><td>1.48±0.87</td><td>0.73±0.04</td><td>1.57±0.53</td><td>0.87±0.09</td></tr><tr><td>Relative:</td><td></td><td>-39.54%</td><td></td><td>-44.58%</td><td></td><td>-47.42%</td></tr></table>
+
+$K$ -th layer is an FA layer that allows the topology-aware node-representations to interact directly and consider nodes beyond their original neighbors. Hopefully, this would ease information flow, prevent over-squashing, and reduce the effect of the previously-existed bottleneck. We re-trained the models using the authors’ original code, without performing any additional tuning, to rule out hyperparameter tuning as the source of improvement. Statistics of all datasets can be found in Appendix D.
+
+We note that an FA layer is a simple solution. Its purpose is merely to demonstrate that over-squashing in GNNs is so prevalent and untreated that even the simplest solution helps. Our main contribution is not the solution, but rather, highlighting and explaining the over-squashing problem. This simple solution opens the path for a variety of follow-up improvements and solutions for over-squashing.
+
+Data The QM9 dataset (Ramakrishnan et al., 2014; Gilmer et al., 2017; Wu et al., 2018) contains \~130,000 graphs with ${ \sim } 1 8$ nodes. Each graph is a molecule where nodes are atoms, and undirected, typed edges are different types of bonds between the atoms. The goal is to regress each graph to 13 real-valued quantum chemical properties such as dipole moment and isotropic polarizability.
+
+Models We modified the implementation of Brockschmidt (2020) who performed an extensive hyperparameter tuning for multiple GNNs, by searching over 500 configurations; we took the same splits and their best-found configurations. For most GNNs, Brockschmidt found that the best results are achieved using $K { = } 8$ layers. This hints that this problem depends on long-range information and relies on both graph structure and distant nodes. We re-trained each modified model for each target property using the same code, configuration, and training scheme as Brockschmidt (2020), training each model five times (using different random seeds) for each target property task. We compare the “base” models, reported by Brockschmidt, with our modified and re-trained $ { \mathrm { \^ 6 + F A } } ^ {  { \gamma } }$ models.
+
+Results Results for the top GNNs are shown in Table 1. The main results are that breaking the bottleneck by modifying a single layer to be an FA layer significantly reduces the error rate, by $42 \%$ on average, across six GNN types. These experiments clearly show evidence for a bottleneck in the original GNN models. Results for the other GNNs are shown in Appendix B due to space limitation.
+
+Over-squashing or under-reaching? Barceló et al. (2020) discuss the inability of a GNN node to observe nodes that are farther away than the number of layers $K$ . We denote this limitation as underreaching: for every fixed number of layers $K$ , local information cannot travel farther than distance $K$ along edges. So, was the improvement of the FA layer in Table 1 achieved thanks to the reduction in over-squashing, or did the FA layer only extend the nodes’ reachability and prevent under-reaching? To answer this, we measured the graphs’ diameter in the QM9 dataset – the maximum shortest path between any two nodes in a graph. We found that the average diameter is $6 . 3 5 { \pm } 0 . 9 1 $ , the maximum diameter is 10, and the 90’th percentile is 8, while most models were trained with $K { = } 8$ layers. That is, at least $90 \%$ of the examples in the dataset certainly did not suffer from under-reaching, because the number of layers was greater or equal than their diameter. We trained another set of models with 10 layers, which did not show an improvement over the base models. We conclude that the source of improvement was clearly not the increased reachability, but instead, the reduction in over-squashing.
+
+Table 2: Average accuracy (30 runs $\pm$ stdev) on the biological datasets. $\dagger -$ previously reported by Errica et al. (2020).   
+
+<table><tr><td colspan="2"></td><td>NCI1</td><td>ENZYMES</td></tr><tr><td>No Struct</td><td></td><td>69.8±2.2</td><td>65.2±6.4</td></tr><tr><td>DiffPool</td><td>baset +FA</td><td>76.9±1.9 77.6±1.3</td><td>59.5±5.6 65.7±4.8</td></tr><tr><td>GraphSAGE</td><td>baset +FA</td><td>76.0±1.8 77.7±1.8</td><td>58.2±6.0 60.8±4.5</td></tr><tr><td>DGCNN</td><td>base† +FA</td><td>76.4±1.7 76.8±1.5</td><td>38.9±5.7 42.8±5.3</td></tr><tr><td>GIN</td><td>baset +FA</td><td>80.0±1.4 81.5±1.2</td><td>59.6±4.5 67.7±5.3</td></tr></table>
+
+Table 3: Average accuracy (5 runs±stdev) on VARMISUSE. † – previously reported by Brockschmidt (2020).   
+
+<table><tr><td colspan="3">SeenProj</td><td>UnseenProj</td></tr><tr><td rowspan="2">+ GGNN</td><td>baset</td><td>85.7±0.5</td><td>79.3±1.2</td></tr><tr><td>+FA</td><td>86.3±0.7</td><td>79.1±1.1</td></tr><tr><td rowspan="2">R-GCN</td><td>baset</td><td>88.3±0.4</td><td>82.9±0.8</td></tr><tr><td>+FA</td><td>88.4±0.7</td><td>83.8±1.0</td></tr><tr><td rowspan="2">R-GIN</td><td>baset</td><td>87.1±0.1</td><td>81.1±0.9</td></tr><tr><td>+FA</td><td>87.5±0.7</td><td>81.7±1.2</td></tr><tr><td rowspan="2">GNN-MLP</td><td>baset</td><td>86.9±0.3</td><td>81.4±0.7</td></tr><tr><td>+FA</td><td>87.3±0.2</td><td>81.2±0.5</td></tr><tr><td rowspan="2">R-GAT</td><td>baset</td><td>86.9±0.7</td><td>81.2±0.9</td></tr><tr><td>+FA</td><td>87.9±1.0</td><td>82.0±1.9</td></tr></table>
+
+Can larger hidden sizes achieve a similar improvement? We trained another set of models with doubled dimensions. These models achieved only $5 . 5 \%$ improvement over the base model (Appendix B.2), while adding the FA layer achieved $42 \%$ improvement using the original dimensions and without adding weights. Consistently, in Section 5 we present an analysis that shows how dimensionality increase is ineffective in preventing over-squashing.
+
+Is the entire FA layer needed? We experimented with using only a sampled fraction of edges in the FA layer. As Appendix B.3 shows, the fraction of added edges in the last layer correlates with the decrease in error. For example, using only half of the possible edges in the last layer (a “semi-adjacent” layer) still reduces the error rate by $3 1 . 5 \%$ on average compared to “base”.
+
+If all GNNs benefitted from direct interaction between all nodes, maybe the graph structure is not even needed? We trained another set of models (Appendix B.2) where all $K$ layers are FA layers, thus ignoring the original graph topology; these models produced $1 5 0 0 \%$ higher (worse) error.
+
+# 4.3 BIOLOGICAL BENCHMARKS
+
+Data The NCI1 dataset (Wale et al., 2008) contains 4110 graphs with ${ \sim } 3 0 $ nodes on average, and its task is to predict whether a biochemical compound contains anti-lung-cancer activity. ENZYMES (Borgwardt et al., 2005) contains 600 graphs with ${ \sim } 3 6$ nodes on average, and its task is to classify an enzyme to one out of six classes. We used the same 10-folds and split as Errica et al. (2020).
+
+Models We used the implementation of Errica et al. (2020) who performed a fair and thorough comparison between GNNs. The final reported result is the average of 30 test runs (10 folds $\times 3$ random seeds). Additional training details are provided in Appendix C.
+
+In ENZYMES, Errica et al. found that a baseline that does not use the graph topology at all (“No Struct”) performs better than all GNNs. In NCI1, GIN performed best. We converted the last layer into an FA layer by modifying the implementation of Errica et al., and repeated the same training procedure. We compare the “base” models from Errica et al. with our re-trained $\cdot _ { \mathrm { + F A } } ,$ models.
+
+Results Results are shown in Table 2. The main results are as follows: (a) in NCI1, $\mathrm { G I N + F A }$ improves by $1 . 5 \%$ over GIN-base, which was previously the best performing model; (b) in ENZYMES, where Errica et al. (2020) found that none of the GNNs exploit the topology of the graph, we find that $\mathrm { G I N + F A }$ does exploit the structure and improves by $8 . 1 \%$ over GIN-base and by $2 . 5 \%$ over No Struct.
+
+On average, models with FA layers relatively reduce the error rate by $12 \%$ in ENZYMES and by $4 . 8 \%$ in NCI1. These experiments clearly show evidence for a bottleneck in the original GNN models.
+
+# 4.4 PROGRAMS: VARMISUSE
+
+Data VARMISUSE (Allamanis et al., 2018) is a node-prediction problem that depends on long-range information in computer programs. We used the same splits as Allamanis et al. (2018).
+
+Models We use the implementation of Brockschmidt (2020) who performed an extensive hyperparameter tuning by searching over 30 configurations for each GNN type. The best results were found using 6-10 layers, which hints that this problem requires long-range information. We modified the last layer to be an FA layer, and used the resulting representations for node classification. We used the same best found configurations as Brockschmidt (2020) add re-trained each model five times.
+
+Results Results are shown in Table 3. The main result is that adding an FA layer to all GNNs improves their SeenProjTest accuracy, obtaining a new state-of-the-art of $8 8 . 4 \%$ . In the UnseenProjTest set, adding an an FA layer improves the results of some of most of the GNNs, obtaining a new stateof-the-art of $8 3 . 8 \%$ . These improvements are significant, especially since they were achieved on extensively tuned models, without any further tuning by us.
+
+# 5 HOW LONG IS LONG-RANGE?
+
+In this section, we analyze oversquashing combinatorially in the TREE-NEIGHBORSMATCH problem. We provide a combinatorial lower bound for the minimal hidden size that a GNN requires to perfectly fit the data (learn to $100 \%$ training accuracy) given its problem radius $r$ . We denote the arity of such a tree by $m$ ${ \bf \omega } ( = 2$ in our experiments); the counting base as $b { = } 2$ ; the number of bits in a floating-point variable as $f { = } 3 2$ ; and the hidden dimension of the GNN, i.e., the size of a node vector $\mathbf { h } _ { v } ^ { ( k ) }$ , as $d$ .
+
+![](images/a42cde334485d3ed02ad70fec04a3372e9c145897723a7f2bcd7fe12b437624a.jpg)  
+Figure 4: Combinatorial and empirical lower bounds of the model dimension given the problem radius.
+
+A full tree of arity $m$ and problem radius $r { = }$ depth has $m ^ { r }$ green label-nodes. All $( m ^ { r } ) !$ ! possible permutations of the labels $\{ \mathbf { A } , \mathbf { B } , \mathbf { C } , \mathbf { \Psi } . . . \}$ are valid, disregarding the
+
+order of sibling nodes. Thus, the number of label assignments of green nodes is $( m ^ { r } ) ! / \left( m ! \right) ^ { m ^ { r } - 1 }$ (there are $m ^ { r } - 1$ parent nodes, where the order of each of their $m$ siblings can be permutated). Right before interacting with the target node and predicting the label, a single vector of size $d$ must encapsulate the information flowing from all green nodes (Equations (2) and (3)).1 Such a vector contains $d$ floating-point elements, each of them is stored as $f$ bits. Overall, the number of possible cases that this vector can distinguish between is $b ^ { f \cdot d }$ . The number of possible cases that the vector can distinguish between must be greater than the number of different examples that this vector may encounter in the training data. This requirement is expressed in Equation (4). Considering binary trees $( m { = } 2 )$ , and floating-point values of $f { = } 3 2$ binary $\scriptstyle ( b = 2 )$ bits, we get Equation (5):
+
+$$
+b ^ { f \cdot d } > \frac { ( m ^ { r } ) ! } { { ( m ! ) } ^ { m ^ { r } - 1 } }
+$$
+
+$$
+2 ^ { 3 2 \cdot d } > \frac { ( 2 ^ { r } ) ! } { 2 ^ { 2 ^ { r } - 1 } }
+$$
+
+Since factorial grows faster than an exponent with a constant base, a small increase in $r$ requires a much larger increase in $d$ . Specifically, for $d { = } 3 2$ as in the experiments in Section 4.1, the maximal problem radius is as low as $r { = } 7$ . That is, a model with $d { = } 3 2$ cannot obtain $100 \%$ accuracy for $r { > } 7$
+
+In practice, the problem is worse; i.e., the empirical minimal $d$ is higher than the combinatorial, because even if a solution to storing some information in a vector of a certain size exists, a gradient descent-based algorithm is not guaranteed to find it. Figure 4 shows the combinatorial lower bound of $d$ given $r$ . We also repeated the experiments from Section 4.1 and report the minimal empirical $d$ for each value of $r$ . As shown in Figure 4, the empirical and the theoretical minimal $d$ grow exponentially with $r$ ; for example, even $d { = } 5 1 2$ can empirically fit $r { = } 7$ at most.
+
+# 6 RELATED WORK
+
+Under-reaching Barceló et al. (2020) found that the expressiveness of GNNs captures only a small fragment of first-order logic. The main limitation arises from the inability of a node to be aware of nodes that are farther away than the number of layers $K$ , while the existence of such nodes can be easily described using logic. We denote this limitation as under-reaching. Nevertheless, even when information is reachable within $K$ edges, we show that this information might be over-squashed along the way. Thus, the over-squashing limitation described in this paper is tighter than under-reaching.
+
+Over-smoothing As observed before, node representations become indistinguishable and prediction performance severely degrades as the number of layers increases. The accepted explanation to this phenomenon is over-smoothing (Li et al., 2018; Wu et al., 2020; Oono and Suzuki, 2020). This might explain the empirical optimality of few layers in short-range tasks (e.g., only $K { = } 2$ layers in Kipf and Welling (2017)). Nonetheless, some problems depend on longer-range information propagation and thus require more layers, to avoid under-reaching. We hypothesize that in long-range problems, the explanation for the degraded performance is over-squashing rather than over-smoothing. For further discussion of over-smoothing vs. over-squashing, see Appendix E.
+
+Avoiding over-squashing Some previous work avoid over-squashing by various profitable means: Gilmer et al. (2017) add “virtual edges” to shorten long distances; Scarselli et al. (2008) add “supersource nodes”; and Allamanis et al. (2018) designed program analyses that serve as 16 “shortcut” edge types. However, none of these explicitly explained these solutions using over-squashing, and did not identify the bottleneck and its negative cross-domain implications.
+
+# 7 CONCLUSION
+
+We propose a novel explanation to a well known limitation in training graph neural networks: a bottleneck that causes over-squashing. Problems that depend on long-range interaction require as many GNN layers as the desired radius of each node’s receptive field. This causes an exponentiallygrowing amount of information to be squashed into a fixed-length vector. As a result, the GNN fails to propagate long-range information, learns only short-range signals from the training data instead, and performs poorly when the prediction task depends on long-range interaction.
+
+We demonstrate the existence of the bottleneck in a controlled problem, provide theoretical lower bounds for the hidden size given the problem radius, and show that GCN and GIN are more susceptible to over-squashing than GAT and GGNN. We further show that prior models of chemical, biological and programmatical benchmarks suffer from over-squashing by showing that they can be dramatically improved using a simple FA layer. We conclude that over-squashing in GNNs is so prevalent and untreated in some benchmarks – that even the simplest solution helps. Our observations open the path for a variety of follow-up improvements and even better solutions for over-squashing.
+
+# ACKNOWLEDGMENTS
+
+We would like to thank Federico Errica and Marc Brockschmidt for their help in using their frameworks. We are also grateful to (alphabetically): Chen Zarfati, Elad Nachmias, Gail Weiss, Horace He, Jorge Perez, Lotem Fridman, Moritz Plenz, Pavol Bielik, Petar Velickovi ˇ c, Roy Sadaka, Shaked ´ Brody, Yoav Goldberg, and the anonymous reviewers for their useful comments and suggestions.
+
+# REFERENCES
+
+Miltiadis Allamanis, Marc Brockschmidt, and Mahmoud Khademi. Learning to represent programs with graphs. In International Conference on Learning Representations, 2018. URL https: //openreview.net/forum?id $\equiv$ BJOFETxR-.
+
+Pablo Barceló, Egor V. Kostylev, Mikael Monet, Jorge Pérez, Juan Reutter, and Juan Pablo Silva. The logical expressiveness of graph neural networks. In International Conference on Learning Representations, 2020. URL https://openreview.net/forum?id $\underline { { \underline { { \mathbf { \Pi } } } } } =$ r1lZ7AEKvB.
+
+Karsten M Borgwardt, Cheng Soon Ong, Stefan Schönauer, SVN Vishwanathan, Alex J Smola, and Hans-Peter Kriegel. Protein function prediction via graph kernels. Bioinformatics, 21(suppl_1): i47–i56, 2005.
+
+Marc Brockschmidt. Gnn-film: Graph neural networks with feature-wise linear modulation. Proceedings of the 36th International Conference on Machine Learning, ICML, 2020.
+
+Deli Chen, Yankai Lin, Wei Li, Peng Li, Jie Zhou, and Xu Sun. Measuring and relieving the oversmoothing problem for graph neural networks from the topological view. In Proceedings of the Thirty-Fourth Conference on Association for the Advancement of Artificial Intelligence (AAAI), 2020a.
+
+Jianfei Chen, Jun Zhu, and Le Song. Stochastic training of graph convolutional networks with variance reduction. In International Conference on Machine Learning, pages 942–950, 2018.
+
+Ming Chen, Zhewei Wei, Zengfeng Huang, Bolin Ding, and Yaliang Li. Simple and deep graph convolutional networks. In International Conference on Machine Learning, pages 1725–1735. PMLR, 2020b.
+
+Kyunghyun Cho, Bart van Merriënboer, Dzmitry Bahdanau, and Yoshua Bengio. On the properties of neural machine translation: Encoder–decoder approaches. In Proceedings of SSST-8, Eighth Workshop on Syntax, Semantics and Structure in Statistical Translation, pages 103–111, 2014a.
+
+Kyunghyun Cho, Bart Van Merriënboer, Caglar Gulcehre, Dzmitry Bahdanau, Fethi Bougares, Holger Schwenk, and Yoshua Bengio. Learning phrase representations using rnn encoder-decoder for statistical machine translation. arXiv preprint arXiv:1406.1078, 2014b.
+
+David K Duvenaud, Dougal Maclaurin, Jorge Iparraguirre, Rafael Bombarell, Timothy Hirzel, Alán Aspuru-Guzik, and Ryan P Adams. Convolutional networks on graphs for learning molecular fingerprints. In Advances in neural information processing systems, pages 2224–2232, 2015.
+
+Federico Errica, Marco Podda, Davide Bacciu, and Alessio Micheli. A fair comparison of graph neural networks for graph classification. In International Conference on Learning Representations, 2020. URL https://openreview.net/forum?id ${ . } = { }$ HygDF6NFPB.
+
+Matthias Fey and Jan E. Lenssen. Fast graph representation learning with PyTorch Geometric. In ICLR Workshop on Representation Learning on Graphs and Manifolds, 2019.
+
+Vikas K Garg, Stefanie Jegelka, and Tommi Jaakkola. Generalization and representational limits of graph neural networks. arXiv preprint arXiv:2002.06157, 2020.
+
+Justin Gilmer, Samuel S Schoenholz, Patrick F Riley, Oriol Vinyals, and George E Dahl. Neural message passing for quantum chemistry. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pages 1263–1272. JMLR. org, 2017.
+
+Marco Gori, Gabriele Monfardini, and Franco Scarselli. A new model for learning in graph domains. In Proceedings. 2005 IEEE International Joint Conference on Neural Networks, 2005., volume 2, pages 729–734. IEEE, 2005.
+
+Will Hamilton, Zhitao Ying, and Jure Leskovec. Inductive representation learning on large graphs. In Advances in neural information processing systems, pages 1024–1034, 2017.
+
+Thomas N Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. In ICLR, 2017.
+
+Johannes Klicpera, Aleksandar Bojchevski, and Stephan Günnemann. Predict then propagate: Graph neural networks meet personalized pagerank. In International Conference on Learning Representations, 2018.
+
+Jure Leskovec and Julian J Mcauley. Learning to discover social circles in ego networks. In Advances in neural information processing systems, pages 539–547, 2012.
+
+Omer Levy, Kenton Lee, Nicholas FitzGerald, and Luke Zettlemoyer. Long short-term memory as a dynamically computed element-wise weighted sum. In Proceedings of the 56th Annual Meeting of the Association for Computational Linguistics (Volume 2: Short Papers), pages 732–739, 2018.
+
+Qimai Li, Zhichao Han, and Xiao-Ming Wu. Deeper insights into graph convolutional networks for semi-supervised learning. In Thirty-Second AAAI Conference on Artificial Intelligence, 2018.
+
+Yujia Li, Daniel Tarlow, Marc Brockschmidt, and Richard Zemel. Gated graph sequence neural networks. In International Conference on Learning Representations, 2016.
+
+Alessio Micheli. Neural network for graphs: A contextual constructive approach. IEEE Transactions on Neural Networks, 20(3):498–511, 2009.
+
+Kenta Oono and Taiji Suzuki. Graph neural networks exponentially lose expressive power for node classification. In International Conference on Learning Representations, 2020. URL https://openreview.net/forum?id $\underline { { \underline { { \mathbf { \Pi } } } } } =$ S1ldO2EFPr.
+
+Raghunathan Ramakrishnan, Pavlo O Dral, Matthias Rupp, and O Anatole Von Lilienfeld. Quantum chemistry structures and properties of 134 kilo molecules. Scientific data, 1:140022, 2014.
+
+Yu Rong, Wenbing Huang, Tingyang Xu, and Junzhou Huang. Dropedge: Towards deep graph convolutional networks on node classification. In International Conference on Learning Representations, 2020. URL https://openreview.net/forum?id ${ . } = { }$ Hkx1qkrKPr.
+
+Franco Scarselli, Marco Gori, Ah Chung Tsoi, Markus Hagenbuchner, and Gabriele Monfardini. The graph neural network model. IEEE Transactions on Neural Networks, 20(1):61–80, 2008.
+
+Michael Schlichtkrull, Thomas N Kipf, Peter Bloem, Rianne Van Den Berg, Ivan Titov, and Max Welling. Modeling relational data with graph convolutional networks. In European Semantic Web Conference, pages 593–607. Springer, 2018.
+
+Prithviraj Sen, Galileo Namata, Mustafa Bilgic, Lise Getoor, Brian Galligher, and Tina Eliassi-Rad. Collective classification in network data. AI magazine, 29(3):93–93, 2008.
+
+Oleksandr Shchur, Maximilian Mumme, Aleksandar Bojchevski, and Stephan Günnemann. Pitfalls of graph neural network evaluation. Relational Representation Learning Workshop, NeurIPS 2018, 2018.
+
+Ilya Sutskever, Oriol Vinyals, and Quoc V Le. Sequence to sequence learning with neural networks. In Advances in Neural Information Processing Systems, pages 3104–3112, 2014.
+
+Petar Velickovi ˇ c, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Liò, and Yoshua ´ Bengio. Graph attention networks. In International Conference on Learning Representations, 2018.
+
+Nikil Wale, Ian A Watson, and George Karypis. Comparison of descriptor spaces for chemical compound retrieval and classification. Knowledge and Information Systems, 14(3):347–375, 2008.
+
+Zhenqin Wu, Bharath Ramsundar, Evan N Feinberg, Joseph Gomes, Caleb Geniesse, Aneesh S Pappu, Karl Leswing, and Vijay Pande. Moleculenet: a benchmark for molecular machine learning. Chemical science, 9(2):513–530, 2018.
+
+Zonghan Wu, Shirui Pan, Fengwen Chen, Guodong Long, Chengqi Zhang, and S Yu Philip. A comprehensive survey on graph neural networks. IEEE Transactions on Neural Networks and Learning Systems, 2020.
+
+Keyulu Xu, Chengtao Li, Yonglong Tian, Tomohiro Sonobe, Ken-ichi Kawarabayashi, and Stefanie Jegelka. Representation learning on graphs with jumping knowledge networks. In International Conference on Machine Learning, pages 5453–5462, 2018.
+
+Keyulu Xu, Weihua Hu, Jure Leskovec, and Stefanie Jegelka. How powerful are graph neural networks? In International Conference on Learning Representations, 2019. URL https: //openreview.net/forum?id $\underline { { \underline { { \mathbf { \Pi } } } } } =$ ryGs6iA5Km.
+
+Lingxiao Zhao and Leman Akoglu. Pairnorm: Tackling oversmoothing in gnns. In International Conference on Learning Representations, 2020. URL https://openreview.net/forum? id $=$ rkecl1rtwB.
+
+![](images/e3bfdbbfc6537790bf9570445b100eb496fab97ea7294f9e56265432a731cada.jpg)  
+Figure 5: An example of a TREE-NEIGHBORSMATCH, that is an instance of the general NEIGHBORSMATCH problem that we examine in Section 4. The target node $\textcircled{2}$ is the root of a tree of depth $\mathord { \left. \vert - 3 \right. }$ (from the target node to the green nodes). The green nodes ( $\textcircled{4}$ , $\textcircled{8}$ , $\textcircled{ C}$ , ...) have blue neighbors $\textcircled{)}$ and an alphabetical label. The node $\textcircled{8}$ has a single blue neighbor; the node $\textcircled{ C}$ has two blue neighbors; and the node $\textcircled{ D}$ has no blue neighbors; each other green node has another unique number of blue neighbors. The goal it to predict a label for the target node $\textcircled{2}$ according to its number of blue neighbors. The correct answer is C in this example, because the target node has two blue neighbors, like the green node that is marked with C in the same graph. To make a correct prediction, the network must propagate information from all leaves toward the target node, and make the decision given a single fixed-sized vector that compresses all this information.
+
+# A TREE-NEIGHBORSMATCH – TRAINING DETAILS
+
+Data We created a separate dataset for every tree depth (which is equal to $r$ , the problem radius) and sampled up to 32,000 examples per dataset. The label of each leaf (“A”, “B”, “C” in Figure 2) is represented as a one-hot vector. To tease the effect of the bottleneck from the ability of a GNN to count neighbors, we concatenated each leaf node’s initial representation with a 1-hot vector representing the number of blue neighbors, instead of creating the blue nodes. The target node is initialized with a learned vector as its (missing) label, concatenated with a 1-hot vector representing its number of blue neighbors. Intermediate nodes are initialized with another learned vector.
+
+Model The network has an initial linear layer, followed by $r + 1$ GNN layers. Afterward, the final target node representation goes through a linear layer and a softmax to predict its label. We experimented with GCN (Kipf and Welling, 2017), GGNN (Li et al., 2016), GIN (Xu et al., 2019) and GAT (Velickovi ˇ c et al., 2018) as the graph layers. ´
+
+In Section 4.1, we used model dimensions of $d { = } 3 2$ . Larger values led to the exact same trend. We added residual connections, summing every node with its own representation in the previous layer to increase expressivity, and layer normalization which eased convergence. We used the Adam optimizer with a learning rate of $1 0 ^ { - 3 }$ , decayed by 0.5 after every 1000 epochs without an increase in training accuracy, and stopped training after 2000 epochs of no training accuracy improvement. This usually led to tens of thousands of training epochs, sometimes reaching 100,000 epochs.
+
+Table 4: Average error rates and standard deviations on the QM9 targets. Best result for every property in every GNN type is highlighted in bold. Results marked with $\dagger$ were previously reported by Brockschmidt (2020).   
+
+<table><tr><td></td><td colspan="2">MLP</td><td colspan="2">R-GCN</td><td colspan="2">GNN-FiLM</td></tr><tr><td>Property</td><td>baset</td><td>+FA</td><td>baset</td><td>+FA</td><td>baset</td><td>+FA</td></tr><tr><td>mu</td><td>2.36±0.04</td><td>2.19±0.04</td><td>3.21±0.06</td><td>2.92±0.07</td><td>2.38±0.13</td><td>2.26±0.06</td></tr><tr><td>alpha</td><td>4.27±0.36</td><td>1.92±0.06</td><td>4.22±0.45</td><td>2.14±0.08</td><td>3.75±0.11</td><td>1.93±0.08</td></tr><tr><td>HOMO</td><td>1.25±0.04</td><td>1.19±0.04</td><td>1.45±0.01</td><td>1.37±0.02</td><td>1.22±0.07</td><td>1.11±0.01</td></tr><tr><td>LUMO</td><td>1.35±0.04</td><td>1.20±0.05</td><td>1.62±0.04</td><td>1.41±0.01</td><td>1.30±0.05</td><td>1.21±0.05</td></tr><tr><td>gap</td><td>2.04±0.05</td><td>1.82±0.05</td><td>2.42±0.14</td><td>2.03±0.03</td><td>1.96±0.06</td><td>1.79±0.07</td></tr><tr><td>R2</td><td>14.86±1.62</td><td>12.40±0.84</td><td>16.38±0.49</td><td>13.55±0.50</td><td>15.59±1.38</td><td>11.89±0.73</td></tr><tr><td>ZPVE</td><td>12.00±1.66</td><td>4.68±0.29</td><td>17.40±3.56</td><td>5.81±0.61</td><td>11.00±0.74</td><td>4.68±0.49</td></tr><tr><td>U0</td><td>5.55±0.38</td><td>1.71±0.13</td><td>7.82±0.80</td><td>1.75±0.18</td><td>5.43±0.96</td><td>1.60±0.12</td></tr><tr><td>U</td><td>6.20±0.88</td><td>1.72±0.12</td><td>8.24±1.25</td><td>1.88±0.22</td><td>5.95±0.46</td><td>1.75±0.08</td></tr><tr><td>H</td><td>5.96±0.45</td><td>1.70±0.08</td><td>9.05±1.21</td><td>1.85±0.18</td><td>5.59±0.57</td><td>1.93±0.42</td></tr><tr><td>G</td><td>5.09±0.57</td><td>1.53±0.15</td><td>7.00±1.51</td><td>1.76±0.15</td><td>5.17±1.13</td><td>1.77±0.05</td></tr><tr><td>Cv</td><td>3.38±0.20</td><td>1.69±0.08</td><td>3.93±0.48</td><td>1.90±0.07</td><td>3.46±0.21</td><td>1.64±0.10</td></tr><tr><td>Omega</td><td>0.84±0.02</td><td>0.63±0.04</td><td>1.02±0.05</td><td>0.75±0.04</td><td>0.98±0.06</td><td>0.69±0.05</td></tr><tr><td>Relative:</td><td></td><td>-40.33%</td><td></td><td>-43.40%</td><td></td><td>-39.53%</td></tr></table>
+
+To rule out hyperparameter tuning as the source of degraded performance, we experimented with changing activations (ReLu, tanh, MLP, none), using layer normalization and batch normalization, residual connections, various batch sizes, and whether or not the same GNN weights should be “unrolled” over time steps. The presented results were obtained using the configurations that achieved the best results.
+
+Over-squashing or just long-range? To rule out the possibility that the long-range itself is preventing the GNNs from fitting the data, we repeated the experiment of Figure 3 for depths 4 to 8, where the distance between the leaves and the target node remained the same, but the amount of over-squashing was as in $r { = } 2$ . That is, the graph looks like a tree of depth $\Longrightarrow 2$ , where the root is connected to a “chain” of length of up to 6, and the target node is at the other side of the chain. This setting maintains the long-range as in the original problem, but reduces the amount of information that needs to be squashed. In other words, This setting disentangles of the effect of the long-range itself from the effect of the growing amount of information (i.e., from over-squashing). In this setting, all GNN types managed to easily fit the data to close to $100 \%$ across all distances, showing that the problem is the amount of over-squashing, rather than the long-range itself.
+
+# B QM9 – ADDITIONAL RESULTS
+
+# B.1 ADDITIONAL GNN TYPES
+
+Because of space limitations, in Section 4.2 we presented results on the QM9 dataset only for R-GIN, R-GAT and GGNN. In this section, we show that additional GNN architectures benefit from breaking the bottleneck using a fully-adjacent layer: GNN-MLP , R-GCN (Schlichtkrull et al., 2018) and GNN-FiLM (Brockschmidt, 2020).
+
+All experiments were performed using the extensively-tuned implementation of Brockschmidt (2020) who experimented with over 500 hyperparameter configurations.
+
+Table 4 contains additional results for GGNN, R-GCN and R-GIN. As shown in Table 4, adding an FA layer significantly improves results across all GNN architectures, for all properties.
+
+# B.2 ALTERNATIVE SOLUTIONS
+
+Table 5 shows additional experiments, all performed using GCN. base† is the original model of Brockschmidt (2020) as in Table 4. $+ F A$ is the model that we re-trained with the last layer modified to an FA layer.
+
+Table 5: Average error rates and standard deviations on the QM9 targets with GCN using alternative solutions.   
+
+<table><tr><td>Property</td><td>baset</td><td>+FA</td><td>2xd</td><td>All FA</td><td>2×FA</td><td>Penultimate FA</td></tr><tr><td>mu</td><td>3.21±0.06</td><td>2.92±0.07</td><td>2.99±0.08</td><td>11.52</td><td>2.89±0.08</td><td>2.80±0.08</td></tr><tr><td>alpha</td><td>4.22±0.45</td><td>2.14±0.08</td><td>3.57±0.40</td><td>9.19</td><td>2.23±0.04</td><td>2.14±0.10</td></tr><tr><td>HOMO</td><td>1.45±0.01</td><td>1.37±0.02</td><td>1.36±1.87</td><td>9.95</td><td>1.39±0.02</td><td>1.34±0.03</td></tr><tr><td>LUMO</td><td>1.62±0.04</td><td>1.41±0.01</td><td>1.43±0.04</td><td>19.13</td><td>1.42±0.04</td><td>1.37±0.02</td></tr><tr><td>gap</td><td>2.42±0.14</td><td>2.03±0.03</td><td>2.33±0.23</td><td>24.62</td><td>2.06±0.05</td><td>2.00±0.03</td></tr><tr><td>R2</td><td>16.38±0.49</td><td>13.55±0.50</td><td>18.4±0.76</td><td>168.09</td><td>13.97±0.56</td><td>12.92±0.11</td></tr><tr><td>ZPVE</td><td>17.40±3.56</td><td>5.81±0.61</td><td>15.8±2.59</td><td>591.33</td><td>5.79±0.50</td><td>4.53±0.62</td></tr><tr><td>UO</td><td>7.82±0.80</td><td>1.75±0.18</td><td>7.60±2.07</td><td>188.59</td><td>1.90±0.1</td><td>1.98±0.25</td></tr><tr><td>U</td><td>8.24±1.25</td><td>1.88±0.22</td><td>7.65±1.51</td><td>189.72</td><td>1.71±0.16</td><td>2.05±0.23</td></tr><tr><td>H</td><td>9.05±1.21</td><td>1.85±0.18</td><td>8.67±1.10</td><td>191.11</td><td>1.83±0.11</td><td>1.73±0.14</td></tr><tr><td>G</td><td>7.00±1.51</td><td>1.76±0.15</td><td>2.90±1.15</td><td>173.68</td><td>1.93±0.11</td><td>1.96±0.42</td></tr><tr><td>Cv</td><td>3.93±0.48</td><td>1.90±0.07</td><td>3.99±0.07</td><td>64.18</td><td>1.90±0.14</td><td>1.83±0.11</td></tr><tr><td>Omega</td><td>1.02±0.05</td><td>0.75±0.04</td><td>1.03±0.54</td><td>23.89</td><td>0.69±0.06</td><td>0.67±0.01</td></tr><tr><td>relative</td><td>0.0%</td><td>-43.40%</td><td>-5.50%</td><td>+1520%</td><td>-43.30%</td><td>-45.2%</td></tr></table>
+
+$2 \times d$ is a model that was trained with a doubled hidden dimension size, $d = 2 5 6$ instead of $d = 1 2 8$ as in the base model. As shown, doubling the hidden dimension size leads to a small improvement of only $5 . 5 \%$ reduction in error. In comparison, the $+ \mathrm { F A }$ model used the original dimension sizes and achieves a much larger improvement of $4 3 . 4 0 \%$ .
+
+All FA is a model that was trained with all GNN layers converted into FA layers, practically ignoring the graph topology. This led to much worse results of more than $1 5 0 0 \%$ higher error. This shows that the graph topology is important in this benchmark, and that a direct interaction between nodes (as in a single FA layer) must be performed in addition to considering the topology.
+
+$2 \times F A$ is a model where the last layer was modified into an FA layer, and an additional FA layer was stacked on top of it. This led to results that are very similar to $+ \mathrm { F A }$ .
+
+Penultimate $F A$ is a model where the FA layer is the penultimate layer (the $K - 1$ -th), followed by a standard GNN layer as the $K$ -th layer. This led to results that are even slightly better than $+ \mathrm { F A }$ .
+
+Table 6: Average error rates and standard deviations on the QM9 targets with GCN, where we use only a fraction of the edges in the FA layer.   
+
+<table><tr><td></td><td>base†</td><td>0.25×FA</td><td>0.5× FA</td><td>0.75× FA</td><td>+FA (as in Table 4)</td></tr><tr><td>Avg. error compared to baset</td><td>-0%</td><td>-8.4%</td><td>-31.5%</td><td>-37.1%</td><td>-43.4%</td></tr></table>
+
+# B.3 PARTIAL-FA LAYERS
+
+We also examined whether instead of adding a “full fully-adjacent layer”, we can randomly sample only a fraction of these edges. We randomly sampled only $\{ 0 . 2 5 , 0 . 5 , 0 . 7 5 \}$ of the edges in the full FA layer in every example, and trained the model for each target property 5 times. Table 6 shows the results of these experiments using GCN. base† is the original model of Brockschmidt (2020) as in Table 4. $+ F A$ is the model that we re-trained with the last layer modified to an FA layer. $\{ 0 . 2 5 , 0 . 5 , 0 . 7 5 \} \times F A$ are the models were only a fraction of the edges in the FA layer were used.
+
+As shown in Table 6, the full FA layer achieves the largest reduction in error $( - 4 3 . 4 \% )$ , but even adding a fraction of the edges improves the results over the base model. For example, using only half of the edges $( 0 . 5 \times F A )$ reduces the error by $3 1 . 5 \%$ . Overall, the percentage of used edges in the partial-FA layer is correlated with its reduction in error.
+
+# C BIOLOGICAL BENCHMARKS – TRAINING DETAILS
+
+We used the implementation of Errica et al. (2020) who performed a fair and thorough comparison between GNNs, by splitting each dataset to 10-folds; then, for each GNN type they select a configuration among a grid of 72 configurations according to the validation set; finally, the best configuration for each fold is trained three additional times, early stopped using the validation set, and evaluated on the test set. The final reported result is the average of all 30 test runs (10-folds $\times 3$ ). The final standard deviation is computed among the average results of each of the ten folds.
+
+# D DATA STATISTICS
+
+D.1 SYNTHETIC DATASET: TREE-NEIGHBORSMATCH
+
+Statistics of the synthetic TREE-NEIGHBORSMATCH dataset are shown in Table 7.
+
+Table 7: The number of examples, in our experiments and combinatorially, for every value of depth.   
+
+<table><tr><td>depth</td><td># Training examples sampled</td><td>Total combinatorial: (2depth!) . 2depth</td></tr><tr><td>2</td><td>96</td><td>96</td></tr><tr><td>3</td><td>8000</td><td>&gt;3·105</td></tr><tr><td>4</td><td>16,000</td><td>&gt;3·1014</td></tr><tr><td>5</td><td>32,000</td><td>&gt;1036</td></tr><tr><td>6</td><td>32,000</td><td>&gt;1090</td></tr><tr><td>7</td><td>32,000</td><td>&gt;10217</td></tr><tr><td>8</td><td>32,000</td><td>&gt;10509</td></tr></table>
+
+# D.2 QUANTUM CHEMISTRY: QM9
+
+Statistics of the quantum chemistry QM9 dataset, as used in Brockschmidt (2020) are shown in Table 8.
+
+Table 8: Statistics of the QM9 chemical dataset (Ramakrishnan et al., 2014) as used by Brockschmidt (2020).   
+
+<table><tr><td></td><td>Training</td><td>Validation</td><td>Test</td></tr><tr><td># examples</td><td>110,462</td><td>10,000</td><td>10,000</td></tr><tr><td># nodes-average</td><td>18.03</td><td>18.06</td><td>18.09</td></tr><tr><td># nodes - standard deviation</td><td>2.9</td><td>2.9</td><td>2.9</td></tr><tr><td># edges - average</td><td>18.65</td><td>18.67</td><td>18.72</td></tr><tr><td># edges - standard deviation</td><td>3.1</td><td>3.1</td><td>3.1</td></tr></table>
+
+# D.3 BIOLOGICAL BENCHMARKS
+
+Statistics of the biological datasets, as used in Errica et al. (2020), are shown in Table 9.
+
+# D.4 VARMISUSE
+
+Statistics of the VARMISUSE dataset, as used in Allamanis et al. (2018) and Brockschmidt (2020), are shown in Table 10.
+
+Table 9: Statistics of the biological datasets, as used by Errica et al. (2020).   
+
+<table><tr><td></td><td>NCI1 (Wale et al., 2008)</td><td>ENZYMES (Borgwardt et al., 2005)</td></tr><tr><td># examples</td><td>4110</td><td>600</td></tr><tr><td># classes</td><td>2</td><td>6</td></tr><tr><td># nodes -average</td><td>29.87</td><td>32.63</td></tr><tr><td># nodes - standard deviation</td><td>13.6</td><td>15.3</td></tr><tr><td># edges - average</td><td>32.30</td><td>64.14</td></tr><tr><td># edges - standard deviation</td><td>14.9</td><td>25.5</td></tr><tr><td># node labels</td><td>37</td><td>3</td></tr></table>
+
+Table 10: Statistics of the VARMISUSE dataset (Allamanis et al., 2018) as used by Brockschmidt (2020).   
+
+<table><tr><td></td><td>Training</td><td>Validation</td><td>UnseenProject Test</td><td>SeenProject Test</td></tr><tr><td># graphs</td><td>254360</td><td>42654</td><td>117036</td><td>59974</td></tr><tr><td># nodes -average</td><td>2377</td><td>1742</td><td>1959</td><td>3986</td></tr><tr><td># edges - average</td><td>7298</td><td>7851</td><td>5882</td><td>12925</td></tr></table>
+
+# E DISCUSSION: OVER-SMOOTHING VS. OVER-SQUASHING
+
+Although over-smoothing and over-squashing are related, they are disparate phenomena that occur in different types of problems. For example, imagine a triangular graph containing only three nodes, where every node has a scalar value, an edge to each of the other nodes, and needs to compute a function of its own value and the other nodes’ values. The problem radius $r$ in this case is $r { = } 1$ . As we increase the number of layers, the representations of the nodes might become indistinguishable, and thus suffer from over-smoothing. However, there will be no over-squashing in this case, because there is no growing amount of information that is squashed into fixed-sized vectors while passing long-range messages. Contrarily, in the TREE-NEIGHBORSMATCH problem, there is no reason for over-smoothing to occur, because there are no two nodes that can converge to the same representation. A node in a “higher” level in the tree contains twice the information than a node in a “lower” level. Thus, this is a case where over-squashing can occur without over-smoothing.