Add files using upload-large-folder tool

parse/train/27acGyyI1BY/27acGyyI1BY.md

@@ -0,0 +1,408 @@
+# NEURAL ODE PROCESSES
+
+Cristian Bodnar∗, Ben Day∗, Jacob Moss∗ & Pietro Lio\`
+
+Alexander Norcliffe∗ † Department of Computer Science University College London London, United Kingdom ucabino@ucl.ac.uk
+
+Department of Computer Science   
+University of Cambridge   
+Cambridge, United Kingdom   
+{cb2015, bjd39, jm2311, pl219}@cam.ac.uk
+
+# ABSTRACT
+
+Neural Ordinary Differential Equations (NODEs) use a neural network to model the instantaneous rate of change in the state of a system. However, despite their apparent suitability for dynamics-governed time-series, NODEs present a few disadvantages. First, they are unable to adapt to incoming data-points, a fundamental requirement for real-time applications imposed by the natural direction of time. Second, time-series are often composed of a sparse set of measurements that could be explained by many possible underlying dynamics. NODEs do not capture this uncertainty. In contrast, Neural Processes (NPs) are a new class of stochastic processes providing uncertainty estimation and fast data-adaptation, but lack an explicit treatment of the flow of time. To address these problems, we introduce Neural ODE Processes (NDPs), a new class of stochastic processes determined by a distribution over Neural ODEs. By maintaining an adaptive data-dependent distribution over the underlying ODE, we show that our model can successfully capture the dynamics of low-dimensional systems from just a few data-points. At the same time, we demonstrate that NDPs scale up to challenging high-dimensional time-series with unknown latent dynamics such as rotating MNIST digits.
+
+# 1 INTRODUCTION
+
+Many time-series that arise in the natural world, such as the state of a harmonic oscillator, the populations in an ecological network or the spread of a disease, are the product of some underlying dynamics. Sometimes, as in the case of a video of a swinging pendulum, these dynamics are latent and do not manifest directly in the observation space. Neural Ordinary Differential Equations (NODEs) (Chen et al., 2018), which use a neural network to parametrise the derivative of an ODE, have become a natural choice for capturing the dynamics of such time-series (C¸ agatay Yıldız et al., ˘ 2019; Rubanova et al., 2019; Norcliffe et al., 2020; Kidger et al., 2020; Morrill et al., 2020).
+
+However, despite their fundamental connection to dynamics-governed time-series, NODEs present certain limitations that hinder their adoption in these settings. Firstly, NODEs cannot adjust predictions as more data is collected without retraining the model. This ability is particularly important for real-time applications, where it is desirable that models adapt to incoming data points as time passes and more data is collected. Secondly, without a larger number of regularly spaced measurements, there is usually a range of plausible underlying dynamics that can explain the data. However, NODEs do not capture this uncertainty in the dynamics. As many real-world time-series are comprised of sparse sets of measurements, often irregularly sampled, the model can fail to represent the diversity of suitable solutions. In contrast, the Neural Process (Garnelo et al., 2018a;b) family offers a class of (neural) stochastic processes designed for uncertainty estimation and fast adaptation to changes in the observed data. However, NPs modelling time-indexed random functions lack an explicit treatment of time. Designed for the general case of an arbitrary input domain, they treat time as an unordered set and do not explicitly consider the time-delay between different observations.
+
+To address these limitations, we introduce Neural ODE Processes (NDPs), a new class of stochastic processes governed by stochastic data-adaptive dynamics. Our probabilistic Neural ODE formulation relies on and extends the framework provided by NPs, and runs parallel to other attempts to incorporate application-specific inductive biases in this class of models such as Attentive NPs (Kim et al., 2019), ConvCNPs (Gordon et al., 2019), and MPNPs (Day et al., 2020). We demonstrate that NDPs can adaptively capture many potential dynamics of low-dimensional systems when faced with limited amounts of data. Additionally, we show that our approach scales to high-dimensional time series with latent dynamics such as rotating MNIST digits (Casale et al., 2018). Our code and datasets are available at https://github.com/crisbodnar/ndp.
+
+![](images/48b4efd4bfee774a1dcc71c0b37da963611fafc6dc8a2fe35f956b8ebb271926.jpg)  
+Figure 1: Schematic diagram of Neural ODE Processes. Left: Observations from a time series, the context set $\bullet$ , are encoded and aggregated to form $\mathbfit { \Delta } \mathbf { r }$ which parametrises the latent variables $D$ and $L _ { 0 }$ . Middle: A sample is drawn from $L _ { 0 }$ and $D$ , initialising and conditioning the ODE, respectively. Each sample produces a plausible, coherent trajectory. Right: Predictions at a target time, $t _ { i } ^ { \mathbb { T } }$ , are made by decoding the state of the ODE, $l ( t _ { i } ^ { \mathbb { T } } )$ together with $t _ { i } ^ { \mathbb { T } }$ . An example is shown with the $\bigcirc$ connected from the ODE position plot to the Predictions plot. Middle & right: the bold lines in each plot refer to the same sample, fainter lines to other samples. $A l l$ : The plots are illustrations only.
+
+# 2 BACKGROUND AND FORMAL PROBLEM STATEMENT
+
+Problem Statement We consider modelling random functions $F : \mathcal T \to \mathcal y$ , where $\boldsymbol { \mathcal { T } } = [ t _ { 0 } , \infty )$ represents time and $\mathcal { V } \subset \mathbb { R } ^ { d }$ is a compact subset of $\mathbb { R } ^ { d }$ . We assume $F$ has a distribution $\mathcal { D }$ , induced by another distribution $\mathcal { D } ^ { \prime }$ over some underlying dynamics that govern the time-series. Given a specific instantation $\mathcal { F }$ of $F$ , let $\mathbb { C } = \{ ( t _ { i } ^ { \mathbb { C } } , y _ { i } ^ { \mathbb { C } } ) \} _ { i \in I _ { \mathbb { C } } }$ be a set of samples from $\mathcal { F }$ with some indexing set $I _ { \mathbb { C } }$ . We refer to $\mathbb { C }$ as the context points, as denoted by the superscript $\mathbb { C }$ . For a given context $\mathbb { C }$ , the task is to predict the values $\{ \hat { y } _ { j } ^ { \mathbb { T } } \} _ { j \in I _ { \mathbb { T } } }$ that $\mathcal { F }$ takes at a set of target times $\{ t _ { j } ^ { \mathbb { T } } \} _ { j \in I _ { \mathbb { T } } }$ , where $I _ { \mathbb { T } }$ is another index set. We call $\mathbb { T } = \{ ( t _ { j } ^ { \mathbb { T } } , y _ { j } ^ { \mathbb { T } } ) \}$ the target set. Additionally let $t _ { \mathbb { C } } = \{ t _ { i } | i \in I _ { \mathbb { C } } \}$ and similarly define $y _ { \mathbb { C } } , t _ { \mathbb { T } }$ and $y _ { \mathbb { T } }$ . Conventionally, as in Garnelo et al. (2018b), the target set forms a superset of the context set and we have $\mathbb { C } \subseteq \mathbb { T }$ . Optionally, it might also be natural to consider that the initial time and observation $( t _ { 0 } , y _ { 0 } )$ are always included in $\mathbb { C }$ . During training, we let the model learn from a dataset of (potentially irregular) time-series sampled from $F$ . We are interested in learning the underlying distribution over the dynamics as well as the induced distribution over functions. We note that when the dynamics are not latent and manifest directly in the observation space $\mathcal { V }$ , the distribution over ODE trajectories and the distribution over functions coincide.
+
+Neural ODEs NODEs are a class of models that parametrize the velocity $\dot { z }$ of a state $_ z$ with the help of a neural network $\dot { z } = f _ { \theta } ( z , t )$ . Given the initial time $t _ { 0 }$ and target time $t _ { i } ^ { \mathbb { T } }$ , NODEs predict the corresponding state $\hat { y } _ { i } ^ { \mathbb { T } }$ by performing the following integration and decoding operations:
+
+$$
+z ( t _ { 0 } ) = h _ { 1 } ( y _ { 0 } ) , \qquad z ( t _ { i } ^ { \mathbb { T } } ) = z ( t _ { 0 } ) + \int _ { t _ { 0 } } ^ { t _ { i } ^ { \mathbb { T } } } f _ { \theta } ( z ( t ) , t ) d t , \qquad \hat { y } _ { i } ^ { \mathbb { T } } = h _ { 2 } ( z ( t _ { i } ^ { \mathbb { T } } ) ) ,
+$$
+
+where $h _ { 1 }$ and $h _ { 2 }$ can be neural networks. When the dimensionality of $_ { z }$ is greater than that of $\textbf {  { y } }$ and $h _ { 1 } , h _ { 2 }$ are linear, the resulting model is an Augmented Neural ODE (Dupont et al., 2019) with input layer augmentation (Massaroli et al., 2020). The extra dimensions offer the model additional flexibility as well as the ability to learn higher-order dynamics (Norcliffe et al., 2020).
+
+Neural Processes (NPs) NPs model a random function $F : \mathcal { X }  \mathcal { Y }$ , where $\mathcal { X } \subseteq \mathbb { R } ^ { d _ { 1 } }$ and $\mathcal { V } \subseteq \mathbb { R } ^ { d _ { 2 } }$ . The NP represents a given instantiation $\mathcal { F }$ of $F$ through the global latent variable $_ { z }$ , which parametrises the variation in $F$ . Thus, we have $\mathcal { F } ( \pmb { x } _ { i } ) = g ( \pmb { x } _ { i } , z )$ . For a given context set $\mathbb { C } = \{ ( \pmb { x } _ { i } ^ { \mathbb { C } } , \pmb { y } _ { i } ^ { \mathbb { C } } ) \}$ and target set $\pmb { x } _ { 1 : n } , \pmb { y } _ { 1 : n }$ , the generative process is given by:
+
+$$
+p ( \pmb { y } _ { 1 : n } , z | \pmb { x } _ { 1 : n } , \mathbb { C } ) = p ( z | \mathbb { C } ) \prod _ { i = 1 } ^ { n } \mathcal { N } ( \pmb { y } _ { i } | g ( \pmb { x } _ { i } , z ) , \sigma ^ { 2 } ) ,
+$$
+
+where $p ( z )$ is chosen to be a multivariate standard normal distribution and $\pmb { y } _ { 1 : n }$ is a shorthand for the sequence $\left( \pmb { y } _ { 1 } , \dots , \pmb { y } _ { n } \right)$ . The model can be trained using an amortised variational inference procedure that naturally gives rise to a permutation-invariant encoder $q _ { \theta } ( z | \mathbb { C } )$ , which stores the information about the context points. Conditioned on this information, the decoder $g ( { \pmb x } , z )$ can make predictions at any input location $_ { \textbf { \em x } }$ . We note that while the domain $\mathcal { X }$ of the random function $F$ is arbitrary, in this work we are interested only in stochastic functions with domain on the real line (time-series). Therefore, from here our notation will reflect that, using $t$ as the input instead of $_ { \textbf { \em x } }$ . The output $\textbf {  { y } }$ remains the same.
+
+# 3 NEURAL ODE PROCESSES
+
+Model Overview We introduce Neural ODE Processes (NDPs), a class of dynamics-based models that learn to approximate random functions defined over time. To that end, we consider an NP whose context is used to determine a distribution over ODEs. Concretely, the context infers a distribution over the initial position (and optionally – the initial velocity) and, at the same time, stochastically controls its derivative function. The positions given by the ODE trajectories at any time $t _ { i } ^ { \mathbb { T } }$ are then decoded to give the predictions. In what follows, we offer a detailed description of each component of the model. A schematic of the model can be seen in Figure 1.
+
+# 3.1 GENERATIVE PROCESS
+
+We first describe the generative process behind NDPs. A graphical model perspective of this process is also included in Figure 2.
+
+Encoder and Aggregator Consider a given context set $\mathbb { C } =$ $\{ ( t _ { i } ^ { \mathbb { C } } , { \pmb y } _ { i } ^ { \mathbb { C } } ) \} _ { i \in I _ { \mathbb { C } } }$ of observed points. We encode this context into two latent variables $L ( t _ { 0 } ) \sim q _ { L } ( l ( t _ { 0 } ) | \mathbb { C } )$ and $D \sim q _ { D } ( d | \mathbb { C } )$ , representing the initial state and the global control of an ODE, respectively. To parametrise the distribution of the latter variable, the NDP encoder produces a representation $\pmb { r } _ { i } = f _ { e } \big ( \big ( t _ { i } ^ { \mathbb { C } } , \pmb { y } _ { i } ^ { \mathbb { C } } \big ) \big )$ for each context pair $( t _ { i } ^ { \mathbb { C } } , \pmb { y } _ { i } ^ { \mathbb { C } } )$ . The function $f _ { e }$ is as a neural network, fully connected or convolutional, depending on the nature of $\textbf {  { y } }$ . An aggregator combines all the representations $\mathbf { \nabla } _ { \mathbf { r } _ { i } }$ to form a global representation, $\pmb { r }$ , that parametrises the distribution of the global latent context, $D \sim q _ { D } ( \mathbf { \boldsymbol { d } } | \mathbb { C } ) = \mathcal { N } \big ( \boldsymbol { z } | \mu _ { D } ( \boldsymbol { r } ) , \operatorname { d i a g } ( \boldsymbol { \sigma } _ { D } ( \boldsymbol { r } ) ) \big )$ . As the aggregator must preserve order invariance, we choose to take the element-wise mean. The distribution of $L _ { 0 }$ might be parametrised identically as a function of the whole context by $q _ { L } ( \pmb { d } | \mathbb { C } )$ , and, in particular, if the initial observation $\mathbf { { \boldsymbol { \psi } } } _ { 0 }$ is always known, then $q _ { L } ( \bar { l } ( 0 ) | \mathbb { C } ) = q _ { L } ( l ( 0 ) | y _ { 0 } ) = \mathcal { N } \big ( l ( 0 ) | \mu _ { L } ( y _ { 0 } ) , \mathrm { d i a g } ( \sigma _ { L } ( y _ { 0 } ) ) \big ) .$ .
+
+![](images/af896d9ec81b2a350325d7aefa86c74532f40c9b53a0641cb32974664a80a10e.jpg)  
+Figure 2: Graphical model of NDPs. The dark nodes denote observed random variables, while the light nodes denote hidden random variables. $I _ { \mathbb { C } }$ and $I _ { \mathbb { T } }$ represent the indexing sets for the context and target points, respectively. Full arrows show the generative process. Dotted arrows indicate inference.
+
+Latent ODE To obtain a distribution over functions, we are interested in capturing the dynamics that govern the time-series and exploiting the temporal nature of the data. To that end, we allow the latent context to evolve according to a Neural ODE (Chen et al., 2018) with initial position $L ( 0 )$ and controlled by $D$ . These two random variables factorise the uncertainty in the underlying dynamics into an uncertainty over the initial conditions (given by $L ( t _ { 0 } ) \dot { { \mathrm { . } } }$ ) and an uncertainty over the ODE derivative, given by $D$ .
+
+By using the target times, $t _ { 1 : n } ^ { \mathbb { T } } = ( t _ { 1 } ^ { \mathbb { T } } , . . . , t _ { N } ^ { \mathbb { T } } )$ , the latent state at a given time is found by evolving a Neural ODE:
+
+$$
+\boldsymbol { l } ( t _ { i } ^ { \mathbb { T } } ) = \boldsymbol { l } ( t _ { 0 } ) + \int _ { t _ { 0 } } ^ { t _ { i } ^ { \mathbb { T } } } \boldsymbol { f } _ { \theta } ( \boldsymbol { l } ( t ) , \boldsymbol { d } , t ) \boldsymbol { d } t ,
+$$
+
+where $f _ { \theta }$ is a neural network that models the derivative of $\imath$ . As explained above, we allow $^ d$ to modulate the derivative of this ODE by acting as a global control signal. Ultimately, for fixed initial conditions, this results in an uncertainty over the ODE trajectories.
+
+Decoder To obtain a prediction at a time $t _ { i } ^ { \mathbb { T } }$ , we decode the random state of the ODE at time $t _ { i } ^ { \mathbb { T } }$ , given by $L ( t _ { i } ^ { \mathbb { T } } )$ . Assuming that the outputs are noisy, for a given sample $l ( t _ { i } ^ { \mathbb { T } } )$ from this stochastic state, the decoder $g$ produces a distribution over $Y _ { t _ { i } } ^ { \mathbb { T } } \sim p \big ( { y } _ { i } ^ { \mathbb { T } } | g ( l ( t _ { i } ^ { \mathbb { T } } ) , t _ { i } ) \big )$ parametrised by the decoder output. Concretely, for regression tasks, we take the target output to be normally distributed with constant (or optionally learned) variance $Y _ { t _ { i } } ^ { \mathbb { T } } \sim \mathcal { N } \big ( { \pmb y } _ { i } | g ( \bar { l } ( t _ { i } ) , t _ { i } \big ) , \sigma ^ { 2 } \big )$ . When $Y _ { t _ { i } } ^ { \mathbb { T } }$ is a random vector formed of independent binary random variables (e.g. a black and white image), we use a Bernoulli distribution $\begin{array} { r } { Y _ { t _ { i } } ^ { \mathbb { T } } \sim \prod _ { j = 1 } ^ { \dim ( Y ) } } \end{array}$ Bernoulli $\left( g ( l ( t _ { i } ) , t _ { i } ) _ { j } \right)$ .
+
+Putting everything together, for a set of observed context points $\mathbb { C }$ , the generative process of NDPs is given by the expression below, where we emphasise once again that $\displaystyle l ( t _ { i } )$ also implicitly depends on $\boldsymbol { l } ( 0 )$ and $^ d$ .
+
+$$
+p ( \pmb { y } _ { 1 : n } , l ( 0 ) , d | t _ { 1 : n } , \mathbb { C } ) = p \big ( l ( 0 ) | \mathbb { C } \big ) p ( d | \mathbb { C } \big ) \prod _ { i = 1 } ^ { n } p \big ( \pmb { y } _ { i } | g ( l ( t _ { i } ) , t _ { i } ) \big ) ,
+$$
+
+We remark that NDPs generalise NPs defined over time. If the latent NODE learns the trivial velocity $f _ { \theta } ( l ( t ) , \pmb { d } , t ) = 0$ , the random state $L ( t ) = L ( t _ { 0 } )$ remains constant at all times $t$ . In this case, the distribution over functions is directly determined by $L ( t _ { 0 } ) \sim p ( l ( t _ { 0 } ) | \mathbb { C } )$ , which substitutes the random variable $Z$ from a regular NP. For greater flexibility, the control signal $^ d$ can also be supplied to the decoder ${ \mathbf { } } g ( l ( t ) , d , t )$ . This shows that, in principle, NDPs are at least as expressive as NPs. Therefore, NDPs could be a sensible choice even in applications where the time-series are not solely determined by some underlying dynamics, but are also influenced by other generative factors.
+
+# 3.2 LEARNING AND INFERENCE
+
+Since the true posterior is intractable because of the highly non-linear generative process, the model is trained using an amortised variational inference procedure. The variational lower-bound on the probability of the target values given the known context $\log p ( y _ { \mathbb { T } } | t _ { \mathbb { T } } , y _ { \mathbb { C } } )$ is as follows:
+
+$$
+\mathbb { E } _ { q } \big ( l ( t _ { 0 } ) , d | t _ { \mathbb { T } } , y \mathbb { r } \big ) \left[ \sum _ { i \in I _ { \mathbb { T } } } \log p ( y _ { i } | l ( t _ { 0 } ) , d , t _ { i } ) + \log \frac { q _ { L } ( l ( t _ { 0 } ) | t _ { \mathbb { C } } , y _ { \mathbb { C } } ) } { q _ { L } ( l ( t _ { 0 } ) | t _ { \mathbb { T } } , y _ { \mathbb { T } } ) } + \log \frac { q _ { D } ( d | t _ { \mathbb { C } } , y _ { \mathbb { C } } ) } { q _ { D } ( d | t _ { \mathbb { T } } , y _ { \mathbb { T } } ) } \right] ,
+$$
+
+where $q _ { L } , q _ { D }$ give the variational posteriors (the encoders described in Section 3.1). The full derivation can be found in Appendix B. We use the reparametrisation trick to backpropagate the gradients of this loss. During training, we sample random contexts of different sizes to allow the model to become sensitive to the size of the context and the location of its points. We train using mini-batches composed of multiple contexts. For that, we use an extended ODE that concatenates the independent ODE states of each sample in the batch and integrates over the union of all the times in the batch (Rubanova et al., 2019). Pseudo-code for this training procedure is also given in Appendix $\textrm { C }$ .
+
+# 3.3 MODEL VARIATIONS
+
+Here we present the different ways to implement the model. The majority of the variation is in the architecture of the decoder. However, it is possible to vary the encoder such that $f _ { e } \big ( ( t _ { i } ^ { \mathbb { C } } , y _ { i } ^ { \mathbb { C } } ) \big )$ can be a multi-layer-perceptron, or additionally contain convolutions.
+
+Neural ODE Process (NDP) In this setup the decoder is an arbitrary function $g ( l ( t _ { i } ^ { \mathbb { T } } ) , d , t _ { i } ^ { \mathbb { T } } )$ of the latent position at the time of interest, the control signal, and time. This type of model is particularly suitable for high-dimensional time-series where the dynamics are fundamentally latent. The inclusion of $^ d$ in the decoder offers the model additional flexibility and makes it a good default choice for most tasks.
+
+Second Order Neural ODE Process (ND2P) This variation has the same decoder architecture as NDP, however the latent ODE evolves according to a second order ODE. The latent state, $\imath$ , is split into a “position”, $\boldsymbol { l } _ { 1 }$ and “velocity”, $l _ { 2 }$ , with $\dot { l _ { 1 } } = { l _ { 2 } }$ and $\dot { l _ { 2 } } = f _ { \theta } ( l _ { 1 } , l _ { 2 } , d , t )$ . This model is designed for time-series where the dynamics are second-order, which is often the case for physical systems (C¸ agatay Yıldız et al., 2019; Norcliffe et al., 2020). ˘
+
+NDP Latent-Only (NDP-L) The decoder is a linear transformation of the latent state $\begin{array} { r l } { g ( l ( t _ { i } ^ { \mathbb { T } } ) ) = } \end{array}$ $W ( l ( t _ { i } ^ { \mathbb { T } } ) ) + b$ . This model is suitable for the setting when the dynamics are fully observed (i.e. they are not latent) and, therefore, do not require any decoding. This would be suitable for simple functions generated by ODEs, for example, sines and exponentials. This decoder implicitly contains information about time and $^ d$ because the ODE evolution depends on these variables as described in Equation 3.
+
+ND2P Latent-Only (ND2P-L) This model combines the assumption of second-order dynamics with the idea that the dynamics are fully observed. The decoder is a linear layer of the latent state as in NDP-L and the phase space dynamics are constrained as in ND2P.
+
+# 3.4 NEURAL ODE PROCESSES AS STOCHASTIC PROCESSES
+
+The Kolmogorov Extension Theorem states that exchangeability and consistency are necessary and sufficient conditions for a collection of joint marginal distributions to define a stochastic process Øksendal (2003); Garnelo et al. (2018b). We define these conditions and show that the NDP model satisfies them. The proofs can be found in Appendix A.
+
+Definition 3.1 (Exchangeability). Exchangeability refers to the invariance of the joint distribution $\rho _ { t _ { 1 : n } } ( \pmb { y } _ { 1 : n } )$ under permutations of $\scriptstyle { \pmb { y } } _ { 1 : n }$ . That is, for a permutation $\pi$ of $\{ 1 , 2 , . . . , n \}$ , $\pi ( t _ { 1 : n } ) =$ $\left( t _ { \pi ( 1 ) } , . . . , t _ { \pi ( n ) } \right)$ and $\pi ( \pmb { y } _ { 1 : n } ) = ( \pmb { y } _ { \pi ( 1 ) } , . . . , \pmb { y } _ { \pi ( n ) } )$ , the joint probability distribution $\rho _ { t _ { 1 : n } } ( \pmb { y } _ { 1 : n } )$ is invariant if $\rho _ { t _ { 1 : n } } ( { \pmb y } _ { 1 : n } ) = \rho _ { \pi ( t _ { 1 : n } ) } ( \pi ( { \pmb y } _ { 1 : n } ) )$ .
+
+Proposition 3.1. NDPs satisfy the exchangeability condition.
+
+Definition 3.2 (Consistency). Consistency says if a part of a sequence is marginalised out, then the joint probability distribution is the same as if it was only originally taken from the smaller sequence $\begin{array} { r } { \rho _ { t _ { 1 : m } } ( { \pmb y } _ { 1 : m } ) = \mathbf { \bar { \int } } \rho _ { t _ { 1 : n } } ( { \pmb y } _ { 1 : n } ) d { \pmb y } _ { m + 1 : n } } \end{array}$ .
+
+Proposition 3.2. NDPs satisfy the consistency condition.
+
+It is important to note that the stochasticity comes from sampling the latent $\boldsymbol { l } ( 0 )$ and $^ d$ . There is no stochasticity within the ODE, such as Brownian motion, though stochastic ODEs have previously been explored (Liu et al., 2019; Tzen & Raginsky, 2019; Jia & Benson, 2020; Li et al., 2020). For any given pair $\boldsymbol { l } ( 0 )$ and $^ d$ , both the latent state trajectory and the observation space trajectory are fully determined. We also note that outside the NP family and differently from our approach, NODEs have been used to generate continuous stochastic processes by transforming the density of another latent process (Deng et al., 2020).
+
+# 3.5 RUNNING TIME COMPLEXITY
+
+For a model with $n$ context points and $m$ target points, an NP has running time complexity $O ( n { + } m )$ , since the model only has to encode each context point and decode each target point. However, a Neural ODE Process has added complexity due to the integration process. Firstly, the integration itself has runtime complexity $O ( \mathrm { N F E } )$ , where NFE is the number of function evaluations. In turn, the worst-case NFE depends on the minimum step size $\delta$ the ODE solver has to use and the maximum time we are interested in, which we denote by $t _ { \mathrm { m a x } }$ . Secondly, for settings where the target times are not already ordered, an additional $O ( m \log ( m ) )$ term is added for sorting them. This ordering is required by the ODE solver.
+
+Therefore, given that $m \geq n$ and assuming a constant $t _ { \mathrm { m a x } }$ exists, the worst-case complexity of NDPs is $O \big ( m \log ( m ) \big )$ . For applications where the times are already sorted (e.g. real-time applications), the complexity falls back to the original $O ( n + m )$ . In either case, NDPs scale well with the size of the input. We note, however, that the integration steps $\left. t _ { \operatorname* { m a x } } \right/ \delta$ could result in a very large constant, hidden by the big- $O$ notation. Nonetheless, modern ODE solvers use adaptive step sizes that adjust to the data that has been supplied and this should alleviate this problem. In our experiments, when sorting is used, we notice the NDP models are between 1 and 1.5 orders of magnitude slower to train than NPs in terms of wall-clock time. At the same time, this limitation of the method is traded-off by a significantly faster loss decay per epoch and superior final performance. We provide a table of time ratios from our 1D experiments, from section 4.1, in Appendix D.
+
+![](images/f4ace0f9ea28b0954c941549df4578a466a59f378120163abeb17e01fe1ade59.jpg)  
+Figure 3: We present example posteriors of trained models and the loss during training of the NP and NDP models for the sine data. We find that NDPs are able to produce a greater range of functions when a single context point is provided, and a sharper, better targeted range as more points in the time series are observed. Quantitatively, NDPs train to a lower loss in fewer epochs, as may be expected for functions that are generated by ODEs. Both models were trained for 30 epochs.
+
+# 4 EXPERIMENTS
+
+To test the proposed advantages of NDPs we carried out various experiments on time series data. For the low-dimensional experiments in Sections 4.1 and 4.2, we use an MLP architecture for the encoder and decoder. For the high-dimensional experiments in Section 4.3, we use a convolutional architecture for both. We train the models using RMSprop (Tieleman & Hinton, 2012) with learning rate $1 \times 1 0 ^ { - 3 }$ . Additional model and task details can be found in Appendices F and G, respectively.
+
+# 4.1 ONE DIMENSIONAL REGRESSION
+
+We begin with a set of 1D regression tasks of differing complexity—sine waves, exponentials, straight lines and damped oscillators—that can be described by ODEs. For each task, the functions are determined by a set of parameters (amplitude, shift, etc) with pre-defined ranges. To generate the distribution over functions, we sample these parameters from a uniform distribution over their respective ranges. We use 490 time-series for training and evaluate on 10 separate test time-series. Each series contains 100 points. We repeat this procedure across 5 different random seeds to compute the standard error. Additional details can be found in Appendix G.1.
+
+The left and middle panels of Figure 3 show how NPs and NDPs adapt on the sine task to incoming data points. When a single data-point has been supplied, NPs have incorrectly collapsed the distribution over functions to a set of almost horizontal lines. NDPs, on the other hand, are able to produce a wide range of possible trajectories. Even when a large number of points have been supplied, the NP posterior does not converge on a good fit, whereas NDPs correctly capture the true sine curve. In the right panel of Figure 3, we show the test-set MSE as a function of the training epoch. It can be seen that NDPs train in fewer iterations to a lower test loss despite having approximately $10 \%$ fewer parameters than NPs. We conducted an ablation study, training all model variants on all the 1D datasets, with final test MSE losses provided in Table 1 and training plots in Appendix G.1.
+
+We find that NDPs either strongly outperform NPs (sine, linear), or their standard errors overlap (exponential, oscillators). For the exponential and harmonic oscillator tasks, where the models perform similarly, many points are close to zero in each example and as such it is possible to achieve a low MSE score by producing outputs that are also around zero. In contrast, the sine and linear datasets have a significant variation in the $y$ -values over the range, and we observe that NPs perform considerably worse than the NDP models on these tasks.
+
+Table 1: Final MSE Loss on 1D regression tasks with standard error (lower is better). Bold indicates that the model performance is within error at the $9 5 \%$ confidence level, with underline indicating the best estimate for top-performer. NPs perform similarly to NDPs and their variants on the exponential and oscillator tasks, where $y$ -values are close to zero. For the sine and linear tasks, where $y$ values vary significantly over the time range, NPs perform worse than NDPs and their variants.   
+
+<table><tr><td colspan="5">MSE ×10-2</td></tr><tr><td>Model</td><td>Sine</td><td>Linear</td><td>Exponential</td><td> Oscillators</td></tr><tr><td>NP</td><td>5.93 ± 0.96</td><td>5.85 ± 0.70</td><td>0.29 ± 0.03</td><td>0.64 ± 0.06</td></tr><tr><td>NDP</td><td>2.09 ±0.12</td><td>3.76 ± 0.32</td><td>0.31± 0.08</td><td>0.72 ± 0.08</td></tr><tr><td>ND2P</td><td>2.75 ± 0.19</td><td>4.37 ± 1.14</td><td>0.25 ± 0.04</td><td>0.55 ± 0.03</td></tr><tr><td>NDP-L</td><td>2.51 ± 0.24</td><td>4.77 ± 0.67</td><td>0.40 ± 0.04</td><td>0.72 ± 0.04</td></tr><tr><td>ND2P-L</td><td>2.64 ± 0.30</td><td>3.16 ± 0.46</td><td>0.39 ± 0.05</td><td>0.66 ± 0.03</td></tr></table>
+
+The difference between NDP and the best of the other model variants is not significant across the set of tasks. As such, we consider only NDPs for the remainder of the paper as this is the least constrained model version: they have unrestricted latent phase-space dynamics, unlike the secondorder counterparts, and a more expressive decoder architecture, unlike the latent-only variants. In addition, NDPs train in a faster wall clock time than the other variants, as shown in Appendix D.
+
+Active Learning We perform an active learning experiment on the sines dataset to evaluate both the uncertainty estimates produced by the models and how well they adapt to new information. Provided with an initial context point, additional points are greedily queried according to the model uncertainty. Higher quality uncertainty estimation and better adaptation will result in more information being acquired at each step, and therefore a faster and greater reduction in error. As shown in Figure 4, NDPs also perform better in this setting.
+
+![](images/98efe33387f1da0c5f04a2cce03cbb9effaa5241d3a77290a7bfd8aab7121a72.jpg)  
+Figure 4: Active learning on the sines dataset. Left: NPs querying the points of highest uncertainty. Middle: NDPs querying the points of highest uncertainty, qualitatively it outperforms NPs. Right: MSE plots of four different querying regimes, NPs and NDPS looking actively and randomly, NDP Active decreases the MSE the fastest.
+
+# 4.2 PREDATOR-PREY DYNAMICS
+
+The Lotka-Volterra Equations are used to model the dynamics of a two species system, where one species predates on the other. The populations of the prey, $u$ , and the predator, $v$ , are given by the differential equations $\dot { u } = \alpha u - \beta u v , \dot { v } = \delta u v - \gamma v$ , for positive real parameters, $\alpha , \beta , \delta , \gamma$ . Intuitively, when prey is plentiful, the predator population increases $( + \delta u v )$ , and when there are many predators, the prey population falls $( - \beta u v )$ . The populations exhibit periodic behaviour, with the phase-space orbit determined by the conserved quantity $V = \delta u - \bar { \gamma } \ln ( u ) + \beta v - \alpha \ln ( v )$ . Thus for any predator-prey system there exists a range of stable functions describing the dynamics, with any particular realisation being determined by the initial conditions, $( u _ { 0 } , v _ { 0 } )$ . We consider the system $( \bar { \alpha } , \beta , \gamma , \delta ) = ( ^ { 2 } / 3 , ^ { 4 } / 3 , 1 , 1 )$ .
+
+We generate sample time-series from the Lotka Volterra system by considering different starting configurations; $( \bar { u } _ { 0 } , v _ { 0 } ) = ( 2 E , E )$ , where $E$ is sampled from a uniform distribution in the range (0.25, 1.0). The training set consists of 40 such samples, with a further 10 samples forming the test set. As before, each time series consists of 100 time samples and we evaluate across 5 different random seeds to obtain a standard error.
+
+![](images/d4ba46ed3627cb2173a6e95153328d9b1783101d13077bab2e3dac3e92515574.jpg)  
+Figure 5: NPs and NDPs on the Lotka-Volterra task. Black is used for targets or ground truth, solid lines for mean predictions over 50 samples, and dashed lines for sample trajectories. In the left and middle plots, the shaded regions show the min-max range over 50 samples, in the right plot the shaded region was produced using kernel density estimation. Left: NPs are less able to model the dynamics, diverging from the ground truth even in regions with dense context sampling, whereas the NDP is both more accurate and varies more appropriately. Middle: Plotting the theoretically conserved quantity $V$ better exposes how the models deviate from the ground truth Right: In phase space $( u , v )$ the NDP is more clearly seen to better track the ground truth.
+
+We find that NDPs are able to train in fewer epochs to a lower loss (Appendix G.2). We record final test MSEs $( \times 1 0 ^ { - 2 } )$ at $4 4 \pm 4$ for the NPs and $1 5 \pm 2$ for the NDPs. As in the 1D tasks, NDPs perform better despite having a representation $\mathbfit { \Delta } \mathbf { r }$ and context $_ { z }$ with lower dimensionality, leading to $10 \%$ fewer parameters than NPs. Figure 5 presents these advantages for a single time series.
+
+# 4.3 VARIABLE ROTATING MNIST
+
+To test our model on high-dimensional time-series with latent dynamics, we consider the rotating MNIST digits (Casale et al., 2018; C¸ agatay Yıldız et al., 2019). In the original task, samples of ˘ digit $\mathbf { \overleftarrow { 3 } } \overrightarrow { }$ start upright and rotate once over 16 frames $( = 3 6 0 ^ { \circ } s ^ { - 1 }$ ) (i.e. constant angular velocity, zero angular shift). However, since we are interested in time-series with variable latent dynamics and increased variability in the initial conditions as in our formal problem statement, we consider a more challenging version of the task. In our adaptation, the angular velocity varies between samples in the range $( 3 6 \bar { 0 } ^ { \circ } \pm 6 0 ^ { \circ } ) s ^ { - 1 }$ and each sample starts at a random initial rotation. To induce some irregularity in each time-series in the training dataset, we remove five randomly chosen time-steps (excluding the initial time $t _ { 0 }$ ) from each time-series. Overall, we generate a dataset with 1, 000 training time-series, 100 validation time-series and 200 test time-series, each using disjoint combinations of different calligraphic styles and dynamics. We compare NPs and NDPs using identical convolutional networks for encoding the images in the context. We assume that the initial image $y _ { 0 }$ (i.e. the image at $t _ { 0 }$ ) is always present in the context. As such, for NDPs, we compute the distribution of $L _ { 0 }$ purely by encoding $y _ { 0 }$ and disregarding the other samples in the context, as described in Section 3. We train the NP for 500 epochs and use the validation set error to checkpoint the best model for testing. We follow a similar procedure for the NDP model but, due to the additional computational load introduced by the integration operation, only train for 50 epochs.
+
+![](images/0fb8c9f43b1e030ecbb233943fb0605ffc16f8ba407a022a44084b552c9f824a.jpg)  
+Figure 6: Predictions on the test set of Variable Rotating MNIST. NDP is able to extrapolate beyond the training time range whereas NP cannot even learn to reconstruct the digit.
+
+In Figure 6, we include the predictions offered by the two models on a time-series from the test dataset, which was not seen in training by either of the models. Despite the lower number of epochs they are trained for, NDPs are able to interpolate and even extrapolate on the variable velocity MNIST dataset, while also accurately capturing the calligraphic style of the digit. NPs struggle on this challenging task and are unable to produce anything resembling the digits. In order to better understand this wide performance gap, we also train in Appendix G.3 the exact same models on the easier Rotating MNIST task from C¸ agatay Yıldız et al. (2019) where the angular velocity and initial ˘ rotation are constant. In this setting, the two models perform similarly since the NP model can rely on simple interpolations without learning any dynamics.
+
+# 5 DISCUSSION AND RELATED WORK
+
+We now consider two perspectives on how Neural ODE Processes relate to existing work and discuss the model in these contexts.
+
+NDPs as Neural Processes From the perspective of stochastic processes, NDPs can be seen as a generalisation of NPs defined over time and, as such, existing improvements in this family are likely orthogonal to our own. For instance, following the work of Kim et al. (2019), we would expect adding an attention mechanism to NDPs to reduce uncertainty around context points. Additionally, the intrinsic sequential nature of time could be further exploited to model a dynamically changing sequence of NDPs as in Sequential NPs (Singh et al., 2019). For application domains where the observations evolve on a graph structure, such as traffic networks, relational information could be exploited with message passing operation as in MPNPs (Day et al., 2020).
+
+NDPs as Neural ODEs From a dynamics perspective, NDPs can be thought of as an amortised Bayesian Neural ODE. In this sense, $\mathrm { O D E ^ { 2 } }$ VAE (C¸ agatay Yıldız et al., 2019) is the model that is ˘ most closely related to our method. While there are many common ideas between the two, significant differences exist. Firstly, NDPs do not use an explicit Bayesian Neural Network but are linked to them through the theoretical connections inherited from NPs (Garnelo et al., 2018b). NDPs handle uncertainty through latent variables, whereas $\mathrm { O D E ^ { 2 } }$ VAE uses a distribution over the NODE’s weights. Secondly, NDPs stochastically condition the ODE derivative function and initial state on an arbitrary context set of variable size. In contrast, ODE2VAE conditions only the initial position and initial velocity on the first element and the first $M$ elements in the sequence, respectively. Therefore, our model can dynamically adapt the dynamics to any observed time points. From that point of view, our model also runs parallel to other attempts of making Neural ODEs capable of dynamically adapting to irregularly sampled data (Kidger et al., 2020). We conclude this section by remarking that any Latent NODE, as originally defined in Chen et al. (2018), is also a stochastic process. However, regular Latent NODEs are not trained to use a data-adaptive prior over the latent context, but use a fixed standard-normal prior. This corresponds to the case when $\mathbb { C } = \mathbb { T }$ as remarked by Le et al. (2018). Additionally, they also only model an uncertainty in the initial position of the ODE, but do not consider an uncertainty in the derivative function.
+
+# 6 CONCLUSION
+
+We introduce Neural ODE Processes (NDPs), a new class of stochastic processes suitable for modelling data-adaptive stochastic dynamics. First, NDPs tackle the two main problems faced by Neural ODEs applied to dynamics-governed time series: adaptability to incoming data points and uncertainty in the underlying dynamics when the data is sparse and, potentially, irregularly sampled. Second, they add an explicit treatment of time as an additional inductive bias inside Neural Processes. To do so, NDPs include a probabilistic ODE as an additional encoded structure, thereby incorporating the assumption that the time-series is the direct or latent manifestation of an underlying ODE. Furthermore, NDPs maintain the scalability of NPs to large inputs. We evaluate our model on synthetic 1D and 2D data, as well as higher-dimensional problems such as rotating MNIST digits. Our method exhibits superior training performance when compared with NPs, yielding a lower loss in fewer iterations. Whether or not the underlying ODE of the data is latent, we find that where there is a fundamental ODE governing the dynamics, NDPs perform well.
+
+# REFERENCES
+
+Francesco Paolo Casale, Adrian V Dalca, Luca Saglietti, Jennifer Listgarten, and Nicolo Fusi. Gaussian Process Prior Variational Autoencoders. arXiv e-prints, art. arXiv:1810.11738, October 2018.
+
+Ricky TQ Chen, Yulia Rubanova, Jesse Bettencourt, and David K Duvenaud. Neural ordinary differential equations. In Advances in neural information processing systems, pp. 6571–6583, 2018.
+
+Ben Day, Cat˘ alina Cangea, Arian R. Jamasb, and Pietro Li ˘ o. Message passing neural processes, \` 2020.
+
+Ruizhi Deng, Bo Chang, Marcus A. Brubaker, Greg Mori, and Andreas Lehrmann. Modeling continuous stochastic processes with dynamic normalizing flows. In Advances in Neural Information Processing Systems (NeurIPS), 2020.
+
+Dheeru Dua and Casey Graff. UCI machine learning repository, 2017. URL http://archive. ics.uci.edu/ml.
+
+Emilien Dupont, Arnaud Doucet, and Yee Whye Teh. Augmented neural odes. In H. Wallach, H. Larochelle, A. Beygelzimer, F. d'Alche-Buc, E. Fox, and R. Garnett (eds.), ´ Advances in Neural Information Processing Systems 32, pp. 3140–3150. Curran Associates, Inc., 2019. URL http: //papers.nips.cc/paper/8577-augmented-neural-odes.pdf.
+
+Marta Garnelo, Dan Rosenbaum, Chris J. Maddison, Tiago Ramalho, David Saxton, Murray Shanahan, Yee Whye Teh, Danilo J. Rezende, and S. M. Ali Eslami. Conditional neural processes, 2018a.
+
+Marta Garnelo, Jonathan Schwarz, Dan Rosenbaum, Fabio Viola, Danilo J. Rezende, S. M. Ali Eslami, and Yee Whye Teh. Neural processes, 2018b.
+
+Jonathan Gordon, Wessel P. Bruinsma, Andrew Y. K. Foong, James Requeima, Yann Dubois, and Richard E. Turner. Convolutional conditional neural processes, 2019.
+
+Junteng Jia and Austin R. Benson. Neural jump stochastic differential equations, 2020.
+
+Patrick Kidger, James Morrill, James Foster, and Terry Lyons. Neural controlled differential equations for irregular time series. arXiv preprint arXiv:2005.08926, 2020.
+
+Hyunjik Kim, Andriy Mnih, Jonathan Schwarz, Marta Garnelo, Ali Eslami, Dan Rosenbaum, Oriol Vinyals, and Yee Whye Teh. Attentive neural processes, 2019.
+
+Tuan Anh Le, Hyunjik Kim, Marta Garnelo, Dan Rosenbaum, Jonathan Schwarz, and Yee Whye Teh. Empirical evaluation of neural process objectives. In NeurIPS workshop on Bayesian Deep Learning, 2018.
+
+Xuechen Li, Ting-Kam Leonard Wong, Ricky T. Q. Chen, and David Duvenaud. Scalable gradients for stochastic differential equations, 2020.
+
+Xuanqing Liu, Tesi Xiao, Si Si, Qin Cao, Sanjiv Kumar, and Cho-Jui Hsieh. Neural sde: Stabilizing neural ode networks with stochastic noise, 2019.
+
+Stefano Massaroli, Michael Poli, Jinkyoo Park, Atsushi Yamashita, and Hajime Asama. Dissecting neural odes, 2020.
+
+James Morrill, Patrick Kidger, Cristopher Salvi, James Foster, and Terry Lyons. Neural cdes for long time series via the log-ode method, 2020.
+
+Alexander Norcliffe, Cristian Bodnar, Ben Day, Nikola Simidjievski, and Pietro Lio. On second \` order behaviour in augmented neural odes, 2020.
+
+Bernt Øksendal. Stochastic differential equations. In Stochastic differential equations, pp. 65–84. Springer, 2003.
+
+Adam Paszke, Sam Gross, Francisco Massa, Adam Lerer, James Bradbury, Gregory Chanan, Trevor Killeen, Zeming Lin, Natalia Gimelshein, Luca Antiga, Alban Desmaison, Andreas Kopf, Edward Yang, Zachary DeVito, Martin Raison, Alykhan Tejani, Sasank Chilamkurthy, Benoit Steiner, Lu Fang, Junjie Bai, and Soumith Chintala. Pytorch: An imperative style, high-performance deep learning library. In H. Wallach, H. Larochelle, A. Beygelzimer, F. d'Alche-Buc, E. Fox, and ´ R. Garnett (eds.), Advances in Neural Information Processing Systems 32, pp. 8024–8035. Curran Associates, Inc., 2019.
+
+Yulia Rubanova, Ricky T. Q. Chen, and David Duvenaud. Latent odes for irregularly-sampled time series, 2019.
+
+Gautam Singh, Jaesik Yoon, Youngsung Son, and Sungjin Ahn. Sequential neural processes. In Advances in Neural Information Processing Systems, pp. 10254–10264, 2019.
+
+T. Tieleman and G. Hinton. Lecture 6.5—RmsProp: Divide the gradient by a running average of its recent magnitude. COURSERA: Neural Networks for Machine Learning, 2012.
+
+Belinda Tzen and Maxim Raginsky. Neural stochastic differential equations: Deep latent gaussian models in the diffusion limit, 2019.
+
+Ben H Williams, Marc Toussaint, and Amos J Storkey. Extracting motion primitives from natural handwriting data. In International Conference on Artificial Neural Networks, pp. 634–643. Springer, 2006.
+
+C¸ agatay Yıldız, Markus Heinonen, and Harri L ˘ ahdesm ¨ aki. Ode ¨ 2vae: Deep generative second order odes with bayesian neural networks, 2019.
+
+# ACKNOWLEDGEMENTS
+
+We’d like to thank Cat˘ alina Cangea and Nikola Simidjievski for their feedback on an earlier ver- ˘ sion of this work, and Felix Opolka for many discussions in this area. We were greatly enabled and are indebted to the developers of a great number of open-source projects, most notably the torchdiffeq library. Jacob Moss is funded by a GSK grant.
+
+# A STOCHASTIC PROCESS PROOFS
+
+Before giving the proofs, we state the following important Lemma.
+
+Lemma A.1. As in NPs, the decoder output $g ( l ( t ) , t )$ can be seen as a function $\mathcal { F } ( t )$ for a given fixed $\boldsymbol { l } ( t _ { 0 } )$ and $^ d$ .
+
+Proof. This follows directly from the fact that $\begin{array} { r } { l ( t ) = l ( t _ { 0 } ) + \int _ { t _ { 0 } } ^ { \mathbb { T } } f _ { \theta } ( l ( t ) , t , \pmb { d } ) d t } \end{array}$ can be seen as a function of $t$ and that the integration process is deterministic for a given pair $\boldsymbol { l } ( t _ { 0 } )$ and $^ d$ (i.e. for fixed initial conditions and control).
+
+Proposition 3.1 NDPs satisfy the exchangeability condition.
+
+Proof. This follows directly from Lemma A.1, since any permutation on $t _ { 1 : n }$ would automatically act on $\mathcal { F } _ { 1 : n }$ and consequently on $p ( \pmb { y } _ { 1 : n } , l ( t _ { 0 } ) , \pmb { d } | t _ { 1 : n } )$ , for any given ${ l } ( t _ { 0 } ) , d$ . □
+
+Proposition 3.2 NDPs satisfy the consistency condition.
+
+Proof. Based on Lemma A.1 we can write the joint distribution (similarly to a regular NP) as follows:
+
+$$
+\rho _ { t _ { 1 : n } } ( y _ { 1 : n } ) = \int p ( \mathcal { F } ) \prod _ { i = 1 } ^ { n } p ( \pmb { y } _ { i } | \mathcal { F } ( t _ { i } ) ) d \mathcal { F } .
+$$
+
+Because the density of any $\mathbf { \nabla } _ { \mathbf { \psi } _ { 3 } } \mathbf { \psi } _ { 2 } \qquad \mathbf { \psi } _ { 3 } \mathbf { \psi } _ { 4 } \qquad \mathbf { \psi } _ { 3 } \mathbf { \psi } _ { 4 } \qquad \mathbf { \psi } _ { 3 } \mathbf { \psi } _ { 4 } \mathbf { \psi } _ { 3 } \qquad \mathbf { \psi } _ { 4 } \mathbf { \psi } _ { 4 } \mathbf { \psi } _ { 3 } \mathbf { \psi } _ { 4 } \mathbf { \psi } _ { 4 } \mathbf { \psi } _ { 3 } \qquad \mathbf { \psi } _ { 3 } \mathbf { \psi } _ { 4 } \mathbf { \psi } _ { 4 } \mathbf { \psi } _ { 3 } \mathbf { \psi } _ { 4 } \mathbf { \psi } _ { 4 }$ depends only on the corresponding $t _ { i }$ , integrating out any subset of ${ \pmb y } _ { 1 : n }$ gives the joint distribution of the remaining random variables in the sequence. Thus, consistency is guaranteed. □
+
+# B ELBO DERIVATION
+
+As noted in Lemma A.1, the joint probability $p ( \pmb { y } , l ( t _ { 0 } ) , \pmb { d } | t ) = p ( l ( t _ { 0 } ) ) p ( \pmb { d } ) p ( \pmb { y } | g ( l ( t ) , \pmb { d } , t ) )$ can still be seen as a function that depends only on $t$ , since the ODE integration process is deterministic for a given $\boldsymbol { l } ( t _ { 0 } )$ and $^ d$ . Therefore, the ELBO derivation proceeds as usual (Garnelo et al., 2018b). For convenience, let ${ \boldsymbol z } = ( l ( t _ { 0 } ) , d )$ denote the concatenation of the two latent vectors and $q ( z ) =$ $q _ { L } ( l ( t _ { 0 } ) ) q _ { D } ( d )$ . First, we derive the ELBO for $\log p ( y _ { \mathbb { T } } | t _ { \mathbb { T } } )$ .
+
+$$
+\begin{array} { r l } { \log p ( y _ { \mathbb { T } } | t _ { \mathbb { T } } ) = D _ { \mathrm { K L } } \big ( q ( z | t _ { \mathbb { T } } , y _ { \mathbb { T } } ) \| p ( z | t _ { \mathbb { T } } , y _ { \mathbb { T } } ) \big ) + \mathcal { L } _ { \mathrm { E L B o } } } & { } \\ { \geq \mathcal { L } _ { \mathrm { E L B O } } = \mathbb { E } _ { q ( z | t _ { \mathbb { T } } , y _ { \mathbb { T } } ) } \big [ - \log q ( z | t _ { \mathbb { T } } , y _ { \mathbb { T } } ) + \log p ( y _ { \mathbb { T } } , z | t _ { \mathbb { T } } ) \big ] } & { } \\ { = - \mathbb { E } _ { q ( z | t _ { \mathbb { T } } , y _ { \mathbb { T } } ) } \log q ( z | t _ { \mathbb { T } } , y _ { \mathbb { T } } ) + \mathbb { E } _ { q ( z | t _ { \mathbb { T } } , y _ { \mathbb { T } } ) } \big [ \log p ( z ) + \log p ( y _ { \mathbb { T } } | t _ { \mathbb { T } } , z ) \big ] } & { } \\ { = \mathbb { E } _ { q ( z | t _ { \mathbb { T } } , y _ { \mathbb { T } } ) } \Bigg [ \displaystyle \sum _ { i \in I _ { \mathbb { T } } } \log p ( y _ { i } | z , t _ { i } ) + \log \frac { p ( z ) } { q ( z | t _ { \mathbb { T } } , y _ { \mathbb { T } } ) } \Bigg ] } & { } \end{array}
+$$
+
+Noting that at training time, we want to maximise $\log p ( y _ { \mathbb { T } } | t _ { \mathbb { T } } , y _ { \mathbb { C } } )$ . Using the derivation above, we obtain a similar lower-bound, but with a new prior $p ( z | t _ { \mathbb { C } } , y _ { \mathbb { C } } )$ , updated to reflect the additional information supplied by the context.
+
+$$
+\log p ( y _ { \mathbb { T } } | t _ { \mathbb { T } } , y _ { \mathbb { C } } ) \geq \mathbb { E } _ { q ( z | t _ { \mathbb { T } } , y _ { \mathbb { T } } ) } \left[ \sum _ { i \in I _ { \mathbb { T } } } \log p ( y _ { i } | z , t _ { i } ) + \log \frac { p ( z | t _ { \mathbb { C } } , y _ { \mathbb { C } } ) } { q ( z | t _ { \mathbb { T } } , y _ { \mathbb { T } } ) } \right]
+$$
+
+If we approximate the true $p ( z | t _ { \mathbb { C } } , y _ { \mathbb { C } } )$ with the variational posterior, this takes the final form
+
+$$
+\log p ( y _ { \mathbb { T } } | t _ { \mathbb { T } } , y _ { \mathbb { C } } ) \geq \mathbb { E } _ { q ( z | t _ { \mathbb { T } } , y _ { \mathbb { T } } ) } \left[ \sum _ { i \in I _ { \mathbb { T } } } \log p ( y _ { i } | z , t _ { i } ) + \log \frac { q ( z | t _ { \mathbb { C } } , y _ { \mathbb { C } } ) } { q ( z | t _ { \mathbb { T } } , y _ { \mathbb { T } } ) } \right]
+$$
+
+Splitting ${ z } = ( l ( t _ { 0 } ) , d )$ back into its constituent parts, we obtain the loss function
+
+$$
+\mathbb { E } _ { q } \big ( l ( t _ { 0 } ) , d | t _ { \tau } , y _ { \tau } \big ) \left[ \sum _ { i \in I _ { \tau } } \log p ( y _ { i } | l ( t _ { 0 } ) , d , t _ { i } ) + \log \frac { q _ { L } ( l ( t _ { 0 } ) | t _ { \mathbb { C } } , y _ { \mathbb { C } } ) } { q _ { L } ( l ( t _ { 0 } ) | t _ { \mathbb { T } } , y _ { \mathbb { T } } ) } + \log \frac { q _ { D } ( d | t _ { \mathbb { C } } , y _ { \mathbb { C } } ) } { q _ { D } ( d | t _ { \mathbb { T } } , y _ { \mathbb { T } } ) } \right] .
+$$
+
+# C LEARNING AND INFERENCE PROCEDURE
+
+We include below the pseudocode for training NDPs. For clarity of exposition, we give code for a single time-series. However, in practice, we batch all the operations in lines $6 - 1 5$ .
+
+Algorithm 1: Learning and Inference in Neural ODE Processes   
+
+<table><tr><td></td><td>Input :A dataset of time-series {Xk},k ≤K,where K is the total number of time-series</td></tr><tr><td></td><td>Initialise NDP model with parameters θ</td></tr><tr><td></td><td>Let m be the number of context points and n the number of extra target points</td></tr><tr><td></td><td>fori ← O to training_steps do</td></tr><tr><td>3 4</td><td>Sample m from U[1,max_context_points]</td></tr><tr><td>5</td><td>Sample n fromU[1,max_extra_target_points]</td></tr><tr><td>6</td><td>Uniformly sample a time-series Xk</td></tr><tr><td>7</td><td>Uniformly sample from Xk the target points T = (tT,yT),where tT is the time batch with</td></tr><tr><td></td><td>shape (m + n,1) and yr is the corresponding outputs batch with shape (m + n, dim(y)) Extract the (unordered) context set C = T[O : m]</td></tr><tr><td>8 9</td><td>Compute q(𝑙(to),d|C) using the variational encoder</td></tr><tr><td>10</td><td>Compute q(𝑙(to),d|T) using the variational encoder</td></tr><tr><td></td><td>// During training，we sample from q(l(to),d|T)</td></tr><tr><td>11</td><td>Sample l(to),d from q(l(to),d|T) Integrate to compute l(t) as in Equation 3 for all times t ∈ tT</td></tr><tr><td>12 13</td><td>foreach time t ∈tT do</td></tr><tr><td>14</td><td>Use decoder to compute p(y(t)lg(l(t)),t)</td></tr><tr><td>15</td><td></td></tr><tr><td>16</td><td>Compute loss LELBo based on Equation 5</td></tr><tr><td></td><td>0←θ-αVθLELBO</td></tr></table>
+
+It is worth highlighting that during training we sample ${ l ( t _ { 0 } ) , d }$ from the target-conditioned posterior, rather than the context-conditioned posterior. In contrast, at inference time we sample from the context-conditioned posterior.
+
+# D WALL CLOCK TRAINING TIMES
+
+To explore the additional term in the runtime given in Section 3.5, we record the wall clock time for each model to train for 30 epochs on the 1D synthetic datasets, over 5 seeds. Then we take the ratio of a given model and the NP. The experiments were run on an Nvidia Titan $X P$ . The results can be seen in Table 2.
+
+# E SIZE OF LATENT ODE
+
+To investigate how many dimensions the ODE $\imath$ should have we carry out an ablation study, looking at the performance on the 1D sine dataset. We train models with $\imath$ -dimension $\{ 1 , 2 , 5 , 1 0 , 1 5 , 2 0 \}$ for 30 epochs. Figure 7 shows training plots for $\mathrm { d i m } ( l ) = \{ 1 , 2 , 1 0 , 2 0 \}$ , and final MSE values are given in Table 3.
+
+Table 2: Table of ratios, of Neural ODE Process and Neural Process training times on different 1D synthetic datasets. We see that NDP/NP is the lowest (i.e. fastest) in each case.   
+
+<table><tr><td>Time Ratios</td><td>Sine</td><td>Exponential</td><td>Linear</td><td>Oscillators</td></tr><tr><td>NDP/NP</td><td>22.1 ± 0.9</td><td>23.6 ± 0.9</td><td>10.9 ± 1.4</td><td>22.2 ± 2.3</td></tr><tr><td>ND2P/NP</td><td>55.2 ± 6.3</td><td>32.4 ± 1.5</td><td>14.2 ± 0.3</td><td>35.8 ± 0.7</td></tr><tr><td>NDP-L/NP</td><td>55.2 ± 6.2</td><td>47.5 ± 18.0</td><td>14.7 ± 1.5</td><td>25.3 ± 0.5</td></tr><tr><td>ND2P-L/NP</td><td>43.7 ± 1.9</td><td>27.9 ± 1.1</td><td>15.1 ± 1.6</td><td>32.8 ± 1.1</td></tr><tr><td>NP Training Time /s</td><td>22.4 ± 0.2</td><td>45.5 ± 0.3</td><td>100.9 ± 0.3</td><td>23.2 ± 0.4</td></tr></table>
+
+![](images/af284a4a5785d40fe41f77a19b3d77e5330284828e6e5f583bb62ed2d0d064a8.jpg)  
+Figure 7: Training plots of NDP with ODEs of different sizes, training on the sine dataset. We see that for $\dim ( l ) = 1$ , the model trains slowly, as would be expected for a sine curve where at least 2 dimensions are needed to learn second order and test performance is close to the standard NP. The other models train at approximately the same rate.
+
+We see that when $\dim ( l ) = 1$ , NDPs are slow to train and require more epochs. This is because sine curves are second-order ODEs, and at least two dimensions are required to learn second-order dynamics (one for the position and one for the velocity). When $\dim ( l ) = 1$ , NDPs perform similarly to NPs, which is expected when the latent ODE is unable to capture the underlying dynamics. We then see that for all other dimensions, NDPs train at approximately the same rate (over epochs) and have similar final MSE scores. As the dimension increases beyond 10, the test MSE increases, indicating overfitting.
+
+# F ARCHITECTURAL DETAILS
+
+For the experiments with low dimensionality (1D, 2D), the architectural details are as follows:
+
+• Encoder: $[ t _ { i } , y _ { i } ]  r _ { i }$ : Multilayer Perceptron, 2 hidden layers, ReLU activations.   
+• Aggregator: $r _ { 1 : n } \to r$ : Taking the mean.   
+• Representation to Hidden: $r  h$ : One linear layer followed by ReLU.   
+• Hidden to $L ( t _ { 0 } )$ Mean: $h  \mu _ { L }$ : One linear layer.   
+• Hidden to $L ( t _ { 0 } )$ Variance: $h  \sigma _ { L }$ : One linear layer, followed by sigmoid, multiplied by 0.9 add 0.1, i.e. $\sigma _ { L } = 0 . 1 + 0 . 9 \times \mathrm { s i g m o i d } ( W h + b )$ .   
+• Hidden to $D ( t _ { 0 } )$ Mean: $h  \mu _ { L }$ : One linear layer.   
+• Hidden to $D ( t _ { 0 } )$ Variance: $h  \sigma _ { D }$ : One linear layer, followed by sigmoid, multiplied by 0.9 add 0.1, i.e. $\sigma _ { D } = 0 . 1 + 0 . 9 \times \mathrm { s i g m o i d } ( W h + b )$ .   
+• ODE Layers: $[ l , d , t ] \to i$ : Multilayer Perceptron, two hidden layers, tanh activations.   
+• Decoder: $g ( l ( t _ { i } ^ { \mathbb { T } } ) , d , t _ { i } ^ { \mathbb { T } } ) \to y _ { i } ^ { \mathbb { T } }$ , for the NDP model and ND2P described in section 3.3, this function is a linear layer, acting on a concatenation of the latent state and a function of $l ( t _ { i } ^ { \mathbb { T } } )$ , $^ d$ , and $t _ { i } ^ { \mathbb { T } }$ . $g ( l ( t _ { i } ^ { \mathbb { T } } ) , \mathbf { \dot { d } } , t _ { i } ^ { \mathbb { T } } ) = \mathbf { \tilde { W } } ( l ( t _ { i } ^ { \mathbb { T } } ) | | h ( l ( t _ { i } ^ { \mathbb { T } } ) , \mathbf { d } , t _ { i } ^ { \mathbb { T } } ) ) + b .$ . Where $h$ is a Multilayer Perceptron with two hidden layers and ReLU activations.
+
+Table 3: Final MSE values for NDPs training on the sine dataset with different sized ODEs, with NP performance included for reference. Peak performance is found when $\mathrm { d i m } ( l ) = 2$ , which is to be expected as the true dynamics are 2-dimensional. For $\dim ( l ) = 1$ , the MSE is highest, and within error of the NP. Performance degrades with increasing $\dim ( l )$ , with overfitting becoming a problem for $\dim ( l ) = 2 0$ .   
+
+<table><tr><td>l-dimension</td><td>MSE ×10-2</td><td>Training Times/s</td></tr><tr><td>NP</td><td>5.9 ± 0.9</td><td>22.4± 0.2</td></tr><tr><td>1</td><td>5.6 ± 1.3</td><td>299.7 ± 20.5</td></tr><tr><td>2</td><td>1.7 ± 0.1</td><td>413.8 ± 52.9</td></tr><tr><td>5</td><td>2.2 ± 0.2</td><td>414.8 ± 13.1</td></tr><tr><td>10</td><td>2.1 ± 0.1</td><td>496.7 ± 20.5</td></tr><tr><td>15</td><td>2.6 ± 0.2</td><td>618.0 ± 30.7</td></tr><tr><td>20</td><td>3.1 ± 0.3</td><td>652.0 ± 38.8</td></tr></table>
+
+For the high-dimensional experiments (Rotating MNIST).
+
+• Encoder: $\left[ t _ { i } , y _ { i } \right] \to r _ { i }$ : Convolutional Neural Network, 4 layers with 16, 32, 64, 128 channels respectively and kernel size of 5, stride 2. ReLU activations. Batch normalisation.   
+• Aggregator: $r _ { 1 : n } \to r$ : Taking the mean.   
+• Representation to $D$ Hidden: $\pmb { r }  \pmb { h } _ { D }$ : One linear layer followed by ReLU.   
+• Hidden to $D$ Mean: $h _ { D }  \mu _ { D }$ : One linear layer.   
+• Hidden to $D$ Variance: $h _ { D } \to \sigma _ { z }$ : One linear layer, followed by sigmoid, multiplied by 0.9 add 0.1, i.e. $\sigma _ { D } = 0 . 1 + 0 . 9 \times \mathrm { s i g m o i d } ( W h + b )$ .   
+• $\mathbf { { \boldsymbol { \psi } } } _ { 0 }$ to $L ( t _ { 0 } )$ Hidden: $y _ { 0 }  h _ { L }$ : Convolutional Neural Network, 4 layers with 16, 32, 64, 128 channels respectively and kernel size of 5, stride 2. ReLU activations. Batch normalisation.   
+• $L ( t _ { 0 } )$ Hidden to $L ( t _ { 0 } )$ Mean: $h _ { L } \to \mu _ { L }$ : One linear layer.   
+• $L ( t _ { 0 } )$ Hidden to $L ( t _ { 0 } )$ Variance: $h _ { L } \ \to \ \sigma _ { z }$ : One linear layer, followed by sigmoid, multiplied by 0.9 add 0.1, i.e. $\sigma _ { L } = 0 . 1 + 0 . 9 \times \mathrm { s i g m o i d } ( W h + b )$ .   
+• ODE Layers: $[ l , d , t ] \to i$ : Multilayer Perceptron, two hidden layers, tanh activations.   
+• Decoder: $g ( l ( t _ { i } ^ { \mathbb { T } } ) ) \to y _ { i } ^ { \mathbb { T } }$ : 1 linear layer followed by a 4 layer transposed Convolutional Neural Network with 32, 128, 64, 32 channels respectively. ReLU activations. Batch normalisation.
+
+# G TASK DETAILS AND ADDITIONAL RESULTS
+
+# G.1 ONE DIMENSIONAL REGRESSION
+
+We carried out an ablation study over model variations on various 1D synthetic tasks—sines, exponentials, straight lines and harmonic oscillators. Each task is based on some function described by a set of parameters that are sampled over to produce a distribution over functions. In every case, the parameters are sampled from uniform distributions. A trajectory example is formed by sampling from the parameter distributions and then sampling from that function at evenly spaced timestamps, $t$ , over a fixed range to produce 100 data points $( t , y )$ . We give the equations for these tasks in terms of their defining parameters and the ranges for these parameters in Table 4.
+
+To test after each epoch, 10 random context points are taken, and then the mean-squared error and negative log probability are calculated over all the points (not just a subset of the target points). Each model was trained 5 times on each dataset (with different weight initialisation). We used a batch size of 5, with context size ranging from 1 to 10, and the extra target size ranging from 0 to 5.1 The results are presented in Figure 8.
+
+<table><tr><td>Task</td><td>Form</td><td>a</td><td>b</td><td>t</td><td># train</td><td>#test</td></tr><tr><td>Sines</td><td>y=asin(t-b)</td><td>(-1,1)</td><td>(-1/2,1/2)</td><td>（-π，π）</td><td>490</td><td>10</td></tr><tr><td>Exponentials</td><td>y = @/60 × exp(t-b)</td><td>(-1,1)</td><td>(-1/2,1/2）</td><td>(-1,4)</td><td>490</td><td>10</td></tr><tr><td>Straight lines</td><td>y=at+b</td><td>(-1,1)</td><td>（-1/2,1/2)</td><td>（0,5）</td><td>490</td><td>10</td></tr><tr><td>Oscillators</td><td>y = asin(t -b)exp(-t/2)</td><td>(-1,1)</td><td>(-1/2,1/2)</td><td>(0,5)</td><td>490</td><td>10</td></tr></table>
+
+Table 4: Task details for 1D regression. $a$ and $b$ are sampled uniformly at random from the given ranges. $t$ is sampled at 100 regularly spaced intervals over the given range. 490 training examples and 10 test examples were used in every case.
+
+All models perform better than NPs, with fewer parameters (approximately $10 \%$ less). Because there are no significant differences between the different models, we use NDP in the remainder of the experiments, because it has the fewest model restrictions. The phase space dynamics are not restricted like its second-order variant, and the decoder has a more expressive architecture than the latent-only variants. It also trains the fastest in wall clock time seen in Appendix D.
+
+# G.2 LOTKA-VOLTERRA SYSTEM
+
+To generate samples from the Lotka Volterra system, we sample different starting configurations, $( \boldsymbol { u _ { 0 } } , \boldsymbol { \bar { v } _ { 0 } } ) = ( 2 E , \boldsymbol { \bar { E } } )$ , where $E$ is sampled from a uniform distribution in the range (0.25, 1.0). We then evolve the Lotka Volterra system
+
+$$
+\frac { d u } { d t } = \alpha u - \beta u v , \qquad \frac { d v } { d t } = \delta u v - \gamma v .
+$$
+
+using $( \alpha , \beta , \gamma , \delta ) = ( ^ { 2 } / 3 , { ^ 4 } / 3 , 1 , 1 )$ . This is evolved from $t = 0$ to $t = 1 5$ and then the times are rescaled by dividing by 10.
+
+The training for the Lotka-Volterra system can be seen in Figure 9. This was taken across 5 seeds, with a training set of 40 trajectories, 10 test trajectories and batch size 5. We use a context size ranging from 1 to 100, and extra target size ranging from 0 to 45. The test context size was fixed at 90 query times. NDP trains slightly faster with lower loss, as expected.
+
+# G.3 ROTATING MNIST & ADDITIONAL RESULTS
+
+To better understand what makes vanilla NPs fail on our Variable Rotating MNIST from Section 4.3, we train the exact same models on the simpler Rotating MNIST dataset (C¸ agatay Yıldız et al., 2019). ˘ In this dataset, all digits start in the same position and rotate with constant velocity. Additionally, the fourth rotation is removed from all the time-series in the training dataset. We follow the same training procedure as in Section 4.3.
+
+We report in Figure 10 the predictions for the two models on a random time-series from the validation dataset. First, NPs and NDPs perform similarly well at interpolation and extrapolation within the time-interval used in training. As an exception but in agreement with the results from ODE2VAE, NDPs produces a slightly better reconstruction for the fourth time step in the time-series. Second, neither model is able to extrapolate the dynamics beyond the time-range seen in training (i.e. the last five time-steps).
+
+Overall, these observations suggest that for the simpler RotMNIST dataset, explicit modelling of the dynamics is not necessary and the tasks can be learnt easily by interpolating between the context points. And indeed, it seems that even NDPs, which should be able to learn solutions that extrapolate, collapse on these simpler solutions present in the parameter space, instead of properly learning the desired latent dynamics. A possible explanation is that the Variable Rotating MNIST dataset can be seen as an image augmentation process which makes the convolutional features to be approximately rotation equivariant. In this way, the NDP can also learn rotation dynamics in the spatial dimensions of the convolutional features.
+
+Finally, in Figure 11, we plot the reconstructions of different digit styles on the test dataset of Variable Rotating MNIST. This confirms that NDPs are able to capture different calligraphic styles.
+
+![](images/cfbf0cb9fe385000ef99a19850ae280059470b588433eddc63392d4f24adf288.jpg)  
+Figure 8: Training model variants on 1D synthetic datasets. NPs train slower in all cases. All Neural ODE Process variants train approximately at the same rate. With the latent-only variants performing slightly worse than the more expressive model variants. Additionally, ND2P performs slightly better than NDP on the damped oscillator and linear sets, because they are naturally easier to learn as second-order ODEs.
+
+# G.4 HANDWRITTEN CHARACTERS
+
+The CharacterTrajectories dataset consists of single-stroke handwritten digits recorded using an electronic tablet (Williams et al., 2006; Dua & Graff, 2017). The trajectories of the pen tip in two dimensions, $( x , y )$ , are of varying length, with a force cut-off used to determine the start and end of a stroke. We consider a reduced dataset, containing only letters that were written in a single stroke, this disregards letters such as “f”, “i” and “t”. Whilst it is not obvious that character trajectories should follow an ODE, the related Neural Controlled Differential Equation (NCDEs) model has been applied successfully to this task (Kidger et al., 2020). We train with a training set with 49600 examples, a test set with 400 examples and a batch size of 200. We use a context size ranging between 1 and 100, an extra target size ranging between 0 and 100 and a fixed test context size of 20. We visualise the training of the models in Figure 12 and the models plotting posteriors in Figure 13.
+
+![](images/d023c116f6dc67b4eecd593c3d37d084c530200268e3953618302d5745fa5a31.jpg)  
+Figure 9: Training NP and NDP on the Lotka-Volterra equations. Due to the additional encoding structure of NDP, it can be seen that NDPs train in fewer iterations, to a lower loss than NPs.
+
+![](images/961d50c1b7b23b8d2ec59304efb20da259f66fcdcc0e6c6d5d1f1b0a257afbc4.jpg)  
+Figure 10: Predictions on the simpler Rotating MNIST dataset. NPs are also able to perform well on this task, but NDPs are not able to extrapolate beyond the maximum training time.
+
+We observe that NPs and NDPs are unable to successfully learn the time series as well as NCDEs. We record final test MSEs $( \times 1 0 ^ { - 1 } )$ at $4 . 6 \pm 0 . 1$ for NPs and a slightly lower $3 . 4 \pm 0 . 1$ for NDPs. We believe the reason is because handwritten digits do not follow an inherent ODE solution, especially given the diversity of handwriting styles for the same letter. We conjecture that Neural Controlled Differential Equations were able to perform well on this dataset due to the control process. Controlled ODEs follow the equation:
+
+$$
+z ( T ) = z ( t _ { 0 } ) + \int _ { t _ { 0 } } ^ { \mathbb { T } } f _ { \theta } ( z ( t ) , t ) { \frac { d X ( t ) } { d t } } d t , \qquad z ( t _ { 0 } ) = h _ { 1 } ( x ( t _ { 0 } ) ) , \qquad { \hat { x } } ( T ) = h _ { 2 } ( z ( T ) )
+$$
+
+Where $X ( t )$ is the natural cubic spline through the observed points ${ \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf } { \mathbf { } } { \mathbf { } } { \mathbf } { } \mathbf { }  { \mathbf { } \mathbf { } } { \mathbf { } \mathbf { } } { \mathbf } { \mathbf { } } { \mathbf } { \mathbf { } } { \mathbf } { \mathbf } { } \mathbf { } \mathbf { } \mathbf { } \mathbf { }  { \mathbf } { \mathbf } { \mathbf } { \mathbf } { \mathbf } { \mathbf } { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf  { \mathbf } { \mathbf } { \mathbf } \mathbf { } \mathbf { \mathbf } { \mathbf } \mathbf { } \mathbf { } \mathbf { } \mathbf \mathbf { } \mathbf \mathbf { } \mathbf { } \mathbf \mathbf { } \mathbf \mathbf { } \mathbf \mathbf { } \mathbf \mathbf { } \mathbf { } \mathbf \mathbf { } \mathbf \mathbf \mathbf { } \mathbf \mathbf { } \mathbf \mathbf { } \mathbf \mathbf  \mathbf { \mathbf \mathbf } \mathbf { \mathbf \mathbf } \mathbf { \mathbf \mathbf } \mathbf { \mathbf \mathbf } \mathbf { \mathbf \mathbf \mathbf } \mathbf { \mathbf \mathbf } \mathbf \mathbf { \mathbf } $ . If the learnt $f _ { \theta }$ is an identity operation, then the result returned will be the cubic spline through the observed points. Therefore, a controlled ODE can learn an identity with a small perturbation, which is easier to learn with the aid of a control process, rather than learning the entire ODE trajectory.
+
+![](images/4dd5e80b7ae23ca030635b6d51ddff287b66905988c2386bc46f5775d52dd9fc.jpg)  
+Figure 11: NDP is able to capture different styles in the Variable Rotating MNIST dataset.
+
+![](images/f909f506537a8a0280dce0b0b1af84caf5c00c7dadc7da008cd2a44264fb5bd7.jpg)  
+Figure 12: NPs and NDPs training on handwriting. NDPs perform slightly better, achieving a lower loss in fewer iterations. However this is a marginal improvement, and we believe it is down to significant diversity in the dataset, due to there being no fundamental differential equation for handwriting.
+
+![](images/e32f11f2cf1513b6a7c0869be71664e23a25f8df8e53d51fe37df7f9348cc864.jpg)  
+Figure 13: We test the models on drawing the letter “a” with varying numbers of context points. For a few context points, the trajectories are diverse and not entirely recognisable. As more context points are observed, the trajectories become less diverse and start approaching an “a”. We expect that with more training, and editing the hyperparameters, such as batch size, or the number of hidden layers this model would improve. Additionally, we observe that NDP qualitatively outperforms NP on a small number and a large number of context points.

parse/train/H1loF2NFwr/H1loF2NFwr.md

@@ -0,0 +1,393 @@
+# EVALUATING THE SEARCH PHASE OF NEURAL ARCHITECTURE SEARCH
+
+Kaicheng $\mathbf { V } \mathbf { u } ^ { * }$ Computer vision lab, EPFL kaicheng.yu@epfl.ch
+
+Christian Sciuto∗†   
+Daskell   
+christian.sciuto@daskell.com
+
+Martin Jaggi Machine learning and optimization lab, EPFL martin.jaggi@epfl.ch
+
+Claudiu Musat   
+Swisscom Digital Lab   
+claudiu.musat@swisscom.com
+
+# Mathieu Salzmann
+
+Computer vision lab, EPFL mathieu.salzmann@epfl.ch
+
+# ABSTRACT
+
+Neural Architecture Search (NAS) aims to facilitate the design of deep networks for new tasks. Existing techniques rely on two stages: searching over the architecture space and validating the best architecture. NAS algorithms are currently compared solely based on their results on the downstream task. While intuitive, this fails to explicitly evaluate the effectiveness of their search strategies. In this paper, we propose to evaluate the NAS search phase. To this end, we compare the quality of the solutions obtained by NAS search policies with that of random architecture selection. We find that: (i) On average, the state-of-the-art NAS algorithms perform similarly to the random policy; (ii) the widely-used weight sharing strategy degrades the ranking of the NAS candidates to the point of not reflecting their true performance, thus reducing the effectiveness of the search process. We believe that our evaluation framework will be key to designing NAS strategies that consistently discover architectures superior to random ones.
+
+# 1 INTRODUCTION
+
+By automating the design of a neural network for the task at hand, Neural Architecture Search (NAS) has tremendous potential to impact the practicality of deep learning (Zoph & Le, 2017; Liu et al., 2018b;a; Tan et al., 2018; Baker et al., 2016), and has already obtained state-of-the-art performance on many tasks. A typical NAS technique (Zoph & Le, 2017; Pham et al., 2018; Liu et al., 2018a) has two stages: the search phase, which aims to find a good architecture, and the evaluation one, where the best architecture is trained from scratch and validated on the test data.
+
+In the literature, NAS algorithms are typically compared based on their results in the evaluation phase. While this may seem intuitive, the search phase of these algorithms often differ in several ways, such as their architecture sampling strategy and the search space they use, and the impact of these individual factors cannot be identified by looking at the downstream task results only. Furthermore, the downstream task results are often reported for a single random seed, which leaves unanswered the question of robustness of the search strategies.
+
+Table 1: Comparison of NAS algorithms with random sampling. We report results on PTB using mean validation perplexity (the lower, the better) and on CIFAR-10 using mean top 1 accuracy. We also provide the $p$ -value of Student’s t-tests against random sampling.   
+
+<table><tr><td></td><td>PTB (PPL)</td><td>t-test</td><td>CIFAR-10 (acc.)</td><td>t-test</td></tr><tr><td>ENAS</td><td>59.88 ± 1.92</td><td>0.73</td><td>96.79 ± 0.11</td><td>0.01</td></tr><tr><td>DARTS</td><td>60.61 ± 2.54</td><td>0.62</td><td>96.62 ± 0.23</td><td>0.20</td></tr><tr><td>NAO</td><td>61.99 ± 1.95</td><td>0.02</td><td>96.86 ± 0.17</td><td>0.00</td></tr><tr><td>Random</td><td>60.13± 0.65</td><td>：</td><td>96.44 ± 0.19</td><td>-</td></tr></table>
+
+In this paper, we therefore propose to investigate the search phase of existing NAS algorithms in a controlled manner. To this end, we compare the quality of the NAS solutions with a random search policy, which uniformly randomly samples an architecture from the same search space as the NAS algorithms, and then trains it using the same hyper-parameters as the NAS solutions. To reduce randomness, the search using each policy, i.e., random and NAS ones, is repeated several times, with different random seeds.
+
+We perform a series of experiments on the Penn Tree Bank (PTB) (Marcus et al., 1994a) and CIFAR10 (Krizhevsky et al., 2009) datasets, in which we compared the state-of-the-art NAS algorithms whose code is publicly available—DARTS (Liu et al., 2019b), NAO (Luo et al., 2018) and ENAS (Pham et al., 2018)—to our random policy. We reached the surprising conclusions that, as shown in Table 1, none of them significantly outperforms random sampling. Since the mean performance for randomlysampled architectures converges to the mean performance over the entire search space, we further conducted Welch Student’s t-tests (Welch, 1947), which reveal that, in RNN space, ENAS and DARTS cannot be differentiated from the mean of entire search space, while NAO yields worse performance than random sampling. While the situation is slightly better in CNN space, all three algorithms still perform similarly to random sampling. Note that this does not necessarily mean that these algorithms perform poorly, but rather that the search space has been sufficiently constrained so that even a random architecture in this space provides good results. To verify this, we experiment with search spaces where we can exhaustively evaluate all architectures, and observe that these algorithms truly cannot discover top-performing architectures.
+
+In addition to this, we observed that the ranking by quality of candidate architectures produced by the NAS algorithms during the search does not reflect the true performance of these architectures in the evaluation phase. Investigating this further allowed us to identify that weight sharing (Pham et al., 2018), widely adopted to reduce the amount of required resources from thousands of GPU days to a single one, harms the individual networks’ performance. More precisely, using reduced search spaces, we make use of the Kendall Tau $\tau$ metric1 to show that the architecture rankings obtained with and without weight sharing are entirely uncorrelated in RNN space $\scriptstyle \tau = - 0 . 0 0 4$ over 10 runs); and have little correlation in the CNN space $\tau = 0 . 1 9 5$ over 10 runs). Since such a ranking is usually treated as training data for the NAS sampler in the search phase, this further explains the small margin between random search and the NAS algorithms. We also show that training samplers without weight sharing in CNN space surpasses random sampling by a significant margin.
+
+In other words, we disprove the common belief that the quality of architectures trained with and without weight sharing is similar. We show that the difference in ranking negatively impacts the search phase of NAS algorithms, thus seriously impeding their robustness and performance.
+
+In short, evaluating the search phase of NAS, which is typically ignored, allowed us to identify two key characteristics of state-of-the-art NAS algorithms: The importance of the search space and the negative impact of weight sharing. We believe that our evaluation framework will be instrumental in designing NAS search strategies that are superior to the random one. Our code is publicly available at https://github.com/kcyu2014/eval-nas.
+
+# 2 RELATED WORK
+
+Since its introduction in (Zoph & Le, 2017), NAS has demonstrated great potential to surpass the human design of deep networks for both visual recognition (Liu et al., 2018b; Ahmed & Torresani, 2018; Chen et al., 2018; Pérez-Rúa et al., 2018; Liu et al., 2019a) and natural language processing (Zoph & Le, 2017; Pham et al., 2018; Luo et al., 2018; Zoph et al., 2018; Liu et al., 2018b; Cai et al., 2018a). Existing search strategies include reinforcement learning (RL) samplers (Zoph & Le, 2017; Zoph et al., 2018; Pham et al., 2018), evolutionary algorithms (Xie & Yuille, 2017; Real et al., 2017; Miikkulainen et al., 2019; Liu et al., 2018b; Lu et al., 2018), gradient-descent (Liu et al., 2019b), bayesian optimization (Kandasamy et al., 2018; Jin et al., 2019; Zhou et al., 2019) and performance predictors (Liu et al., 2018a; Luo et al., 2018). Here, our goal is not to introduce a new search policy, but rather to provide the means to analyze existing ones. Below, we briefly discuss existing NAS methods and focus on how they are typically evaluated.
+
+Neural architecture search with weight sharing. The potential of vanilla NAS comes with the drawback of requiring thousands of GPU hours even for small datasets, such as PTB and CIFAR-10.
+
+Furthermore, even when using such heavy computational resources, vanilla NAS has to restrict the number of trained architectures from a total of $\mathrm { i 0 ^ { 9 } }$ to $1 0 ^ { 4 }$ , and increasing the sampler accuracy can only be achieved by increasing the resources.
+
+ENAS (Pham et al., 2018) was the first to propose a training scheme with shared parameters, reducing the resources from thousands of GPU days to one. Instead of being trained from scratch each sampled model inherits the parameters from previously-trained ones. Since then, NAS research has mainly focused on two directions: 1) Replacing the RL sampler with a better search algorithm, such as gradient descent (Liu et al., 2019b), bayesian optimiziation (Zhou et al., 2019) and performance predictors (Luo et al., 2018); 2) Exploiting NAS for other applications, e.g., object detection (Ghiasi et al., 2019; Chen et al., 2019), semantic segmentation (Liu et al., 2019a), and finding compact networks (Cai et al., 2018b; Wu et al., 2018; Chu et al., 2019; Guo et al., 2019).
+
+Characterizing the search space. Ying et al. (2019); Dong & Yang (2020) introduced a dataset that contains the ground-truth performance of CNN cells, and Wang et al. (2019) evaluated some traditional search algorithms on it. Similarly, Radosavovic et al. (2019) characterizes many CNN search spaces by computing the statistics of a set of sampled architectures, revealing that, for datasets such as CIFAR-10 or ImageNet, these statistics are similar. While these works support our claim that evaluation of NAS algorithms is crucial, they do not directly evaluate the state-of-the-arts NAS algorithms as we do here.
+
+Evaluation of NAS algorithms. Typically, the quality of NAS algorithms is judged based on the results of the final architecture they produce on the downstream task. In other words, the search and robustness of these algorithms are generally not studied, with (Liu et al., 2019b; So et al., 2019) the only exception for robustness, where results obtained with different random seeds were reported. Here, we aim to further the understanding of the mechanisms behind the search phase of NAS algorithms. Specifically, we propose doing so by comparing them with a simple random search policy, which uniformly randomly samples one architecture per run in the same search space as the NAS techniques.
+
+While some works have provided partial comparisons to random search, these comparisons unfortunately did not give a fair chance to the random policy. Specifically, (Pham et al., 2018) reports the results of only a single random architecture, and (Liu et al., 2018b) those of an architecture selected among 8 randomly sampled ones as the most promising one after training for 300 epochs only. Here, we show that a fair comparison to the random policy, obtained by training all architectures, i.e., random and NAS ones, for 1000 epochs and averaging over multiple random seeds for robustness, yields a different picture; the state-of-the-art search policies are no better than the random one.
+
+The motivation behind this comparison was our observation of only a weak correlation between the performance of the searched architectures and the ones trained from scratch during the evaluation phase. This phenomenon was already noticed by Zela et al. (2018), and concurrently to our work by Li & Talwalkar (2019); Xie et al. (2019); Ying et al. (2019), but the analysis of its impact or its causes went no further. Here, by contrast, we link this difference in performance between the search and evaluation phases to the use of weight sharing.
+
+While this may seem to contradict the findings of Bender et al. (2018), which, on CIFAR-10, observed a strong correlation between architectures trained with and without weight sharing when searching a CNN cell, our work differs from (Bender et al., 2018) in two fundamental ways: 1) The training scheme in (Bender et al., 2018), in which the entire model with shared parameters is trained via random path dropping, is fundamentally different from those used by state-of-the-arts weight sharing NAS strategies (Pham et al., 2018; Liu et al., 2019b; Luo et al., 2018); 2) While the correlation in (Bender et al., 2018) was approximated using a small subset of sampled architectures, we make use of a reduced search space where we can perform a complete evaluation of all architectures, thus providing an exact correlation measure in this space.
+
+# 3 EVALUATING THE NAS SEARCH
+
+In this section, we detail our evaluation framework for the NAS search phase. As depicted in Fig. 1(a,b), typical NAS algorithms consist of two phases:
+
+![](images/2793127c1c541e0e0d0f6cd27226af6fa43627bd457a5552e2de63327cdc8700.jpg)  
+Figure 1: Evaluating NAS. Existing frameworks consist of two phases: (a) The search phase, where a sampler is trained to convergence or a pre-defined stopping criterion; (b) The evaluation phase that trains the best model from scratch and evaluates it on the test data. Here, we argue that one should evaluate the search itself. To this end, as shown in (c), we compare the best architecture found by the NAS policy with a single uniformly randomly sampled architecture. For this comparison to be meaningful, we repeat it with different random seeds for both training the NAS sampler and our random search policy. We then report the mean and standard deviations over the different seeds.
+
+Search: The goal of this phase is to find the best candidate architecture from the search space2. This is where existing algorithms, such as ENAS, DARTS and NAO, differ. Nevertheless, for all the algorithms, the search depends heavily on initialization. In all the studied policies, initialization is random and the outcome thus depends on the chosen random seed.
+
+Evaluation: In this phase, all the studied algorithms retrain the best model found in the search phase. The retrained model is then evaluated on the test data.
+
+The standard evaluation of NAS techniques focuses solely on the final results on the test data. Here, by contrast, we aim to evaluate the search phase itself, which truly differentiates existing algorithms.
+
+To do this, as illustrated in Fig. 1(c), we establish a baseline; we compare the search phase of existing algorithms with a random search policy. An effective search algorithm should yield a solution that clearly outperforms the random policy. Below, we introduce our framework to compare NAS search algorithms with random search. The three NAS algorithms that we evaluated, DARTS (Liu et al., 2019b), NAO (Luo et al., 2018) and ENAS (Pham et al., 2018), are representative of the state of the art for different search algorithms: reinforcement learning, gradient-descent and performance prediction, and are discussed in Appendix C.
+
+# 3.1 COMPARING TO RANDOM SEARCH
+
+We implement our random search policy by simply assigning uniform probabilities to all operations. Then, for each node in the Directed Acyclic Graph (DAG) that is typically used to represent an architecture, we randomly sample a connection to one previous node from the resulting distributions.
+
+An effective search policy should outperform the random one. To evaluate this, we compute the validation results of the best architecture found by the NAS algorithm trained from scratch, as well as those of a single randomly sampled architecture. Comparing these values for a single random seed would of course not provide a reliable measure. Therefore, we repeat this process for multiple random seeds used both during the search phase of the NAS algorithm and to sample one random architecture as described above. We then report the means and standard deviations of these results over the different seeds. Note that while we use different seeds for the search and random sampling, we always use the same seed when training the models from scratch during the evaluation phase.
+
+Our use of multiple random seeds and of the same number of epochs for the NAS algorithms and for our random search policy makes the comparison fair. This contrasts with the comparisons performed in (Pham et al., 2018), where the results of only a single random architecture were reported, and in (Liu et al., 2019b), which selected a single best random architecture among an initial set of 8 after training for 300 epochs only. As shown in Appendix D.2, some models that perform well in the early training stages may yield worse performance than others after convergence. Therefore, choosing the best random architecture after only 300 epochs for PTB and 100 for CIFAR-10, and doing so for a single random seed, might not be representative of the general behavior.
+
+# 3.2 SEARCH IN A REDUCED SPACE
+
+Because of the size of standard search spaces, one cannot understand the quality of the search by fully evaluating all possible solutions. Hence, we propose to make use of reduced search spaces with ground-truth architecture performances available to evaluate the search quality. For RNNs, we simply reduce the number of nodes in the search space from 12 to 2. Given that each node is identified by two values, the ID of the incoming node and the activation function, the space has a cardinality $| S | = n ! * | \mathcal { O } | ^ { n }$ , where $n = 2$ nodes and $| \mathcal { O } | = 4$ operations, thus yielding 32 possible solutions. To obtain ground truth, we train all of these architectures individually. Each architecture is trained 10 times with a different seed, which therefore yields a mean and standard deviation of its performance. The mean value is used as ground truth—the actual potential of the given architecture. These experiments took around 5000 GPU hours.
+
+For CNNs, we make use of NASBench-101 (Ying et al., 2019), a CNN graph-based search space with 3 possible operations, conv3x3, conv1x1 and max3x3. This framework defines search spaces with between 3 and 7 nodes, with 423,624 architectures in 7-node case. To the best of our knowledge, we are the first to evaluate the NAS methods used in this paper on NASBench.
+
+# 4 EXPERIMENTAL RESULTS
+
+To analyze the search phase of the three state-of-the-art NAS algorithms mentioned above, we first compare these algorithms to our random policy when using standard search spaces for RNNs on (PTB) and CNNs on CIFAR-10. Details about the experiment setting are in Appendix C.5. The surprising findings in this typical NAS use case prompted us to study the behavior of the search strategies in reduced search spaces. This allowed us to identify a factor that has a significant impact on the observed results: Weight sharing. We then quantify this impact on the ranking of the NAS candidates, evidencing that it dramatically affects the effectiveness of the search.
+
+# 4.1 NAS COMPARISON IN A STANDARD SEARCH SPACE
+
+Below, we compare DARTS (Liu et al., 2019b), NAO (Luo et al., 2018), ENAS (Pham et al., 2018) and BayesNAS (Zhou et al., 2019) with our random search policy, as discussed in Section 3.1. We follow (Liu et al., 2019b) to define an RNN search space of 12 nodes and a CNN ones of 7 nodes. For each of the four search policies, we run 10 experiments with a different initialization of the sampling policy. During the search phase, we used the authors-provided hyper-parameters and code for each policy. Once a best architecture is identified by the search phase, it is used for evaluation, i.e., we train the chosen architecture from scratch for 1000 epochs for RNN and 600 for CNN.
+
+RNN Results. In Figure 2, we plot, on the left, the mean perplexity evolution over the 1000 epochs, obtained by averaging the results of the best architectures found using the 10 consecutive seeds.3 On the right, we show the perplexity evolution for the best cell of each strategy among the 10 different runs. Random sampling is robust and consistently competitive. As shown in Table 1, it outperforms on average the DARTS and NAO policies, and yields the overall best cell for these experiments with perplexity
+
+![](images/fba49bca1ad00acf458ed2de52b42821b219f9b104e42d956eea61bef84b93bb.jpg)  
+Figure 2: Validation perplexity evolution in the 12-node RNN search space. (Best viewed in color)
+
+of 57.60. Further training this cell for 4000 epochs, as in (Liu et al., 2019b), yields a perplexity of 55.93. The excellent performance of the random policy evidences the high expressiveness of the manually-constructed search space; even arbitrary policies in this space perform well, as evidenced by the relatively low standard deviation over the 10 seeds of the random architectures, shown in Table 1 and Figure 2(left).
+
+CNN Results. In Table 2, we compare the NAS methods with our random policy in the search space of Liu et al. (2019b). We provide the accuracy reported in the original papers as well as the accuracy we reproduced using our implementation. Note that the NAS algorithms only marginally outperform random search, by less than $0 . 5 \%$ in top-1 accuracy. The best architecture was discovered by NAO, with an accuracy of $9 7 . 1 0 \%$ , again less than $0 . 5 \%$ higher than the randomly discovered one. Note that, our random sampling comes at no search cost. By contrast, Li & Talwalkar (2019) obtained an accuracy of $9 7 . 1 5 \%$ with a different random search policy having the same cost as DARTS.
+
+Table 2: Top 1 accuracy in the 7-node DARTS Search space. We report the mean and best top-1 accuracy on the test sets of architectures found by DARTS, NAO, ENAS, BayesNAS, and our random policy. As sanity check, we also train from scratch the architectures reported in original papers, as well as their reported performance.   
+
+<table><tr><td></td><td colspan="2">Our seed</td><td colspan="2">Best reported result</td></tr><tr><td>Type</td><td>Mean test</td><td>Best test</td><td>Original</td><td>Reproduced</td></tr><tr><td>DARTS</td><td>96.62 ± 0.23</td><td>96.80</td><td>97.24</td><td>97.15</td></tr><tr><td>NAO</td><td>96.86 ± 0.17</td><td>97.10</td><td>96.47</td><td>96.92</td></tr><tr><td>ENAS</td><td>96.76 ± 0.10</td><td>96.95</td><td>96.46</td><td>96.87</td></tr><tr><td>BayesNAS</td><td>95.99 ± 0.25</td><td>96.41</td><td>97.19</td><td>97.13</td></tr><tr><td>Random</td><td>96.48 ± 0.18</td><td>96.74</td><td>97.15t</td><td></td></tr></table>
+
+†Result took from Li & Talwalkar (2019)
+
+# Observations:
+
+• The evaluated state-of-the-art NAS algorithms do not surpass random search by a significant margin, and even perform worse in the RNN search space.   
+• The ENAS policy sampler has the lowest variance among the three tested ones. This shows that ENAS is more robust to the variance caused by the random seed of the search phase.   
+• The NAO policy is more sensitive to the search space; while it yields the best performance in CNN   
+space, it performs the worst in RNN one.   
+• The DARTS policy is very sensitive to random initialization, and yields the largest standard deviation across the 10 runs (2.54 in RNN and 0.23 in CNN space).
+
+Such a comparison of search policies would not have been possible without our framework. Nevertheless, the above analysis does not suffice to identify the reason behind these surprising observations. As mentioned before, one reason could be that the search space has been sufficiently constrained so that all architectures perform similarly well. By contrast, if we assume that the search space does contain significantly better architectures, then we can conclude that these search algorithms truly fail to find a good one. To answer this question, we evaluate these methods in a reduced search space, where we can obtain the true performance of all possible architectures.
+
+# 4.2 SEARCHING A REDUCED SPACE
+
+The results in the previous section highlight the inability of the studied methods to surpass random search. Encouraged by these surprising results, we then dig deeper into their causes. Below, we make use of search spaces with fewer nodes, which we can explore exhaustively.
+
+Reduced RNN space. We use the same search space as in Section 3.2 but reduce the number of intermediate nodes to 2. In Table 3 (A), we provide the results of searching the RNN 2-node space. Its smaller size allows us to exhaustively compute the results of all possible solutions, thus determining the upper bound for
+
+![](images/29c3dff2aabebaedd09cdd4077b1dd1bc43974bfafb242e0cdd20d88eb4a8f02.jpg)  
+Figure 3: Architectures discovered by NAS algorithms. We rank all 32 architectures in the reduced search space based on their performance of individual training, from left (best) to right (worst), and plot the best cell found by three NAS algorithms across the 10 random seeds.
+
+this case. In Figure 3, we plot the rank of the top 1 architecture discovered by the three NAS algorithms for each of the 10 different runs.
+
+Table 3: Results in reduced search spaces. For RNNs (A), We report the mean and best perplexity on the validation and test sets at the end of training the architectures found using DARTS, NAO, ENAS. For CNNs (B), we show the mean and best top-1 accuracy on the test set. Instead of running random sampling in the reduced space, we compute the probability of the best model found by each method to surpass the random one (details in Appendix A.2). The mean and best statistics of the entire search space are reported as Space.   
+
+<table><tr><td></td><td colspan="4">(A)RNN n=2(32) in PPL.</td><td colspan="4">(B) NASBench n=7(423K)</td></tr><tr><td>Type</td><td>Mean Valid</td><td>Mean Test</td><td>Best Valid</td><td>Best Test</td><td>Mean Acc.</td><td>Best Acc.</td><td>Best Rank</td><td>p(&gt;random)</td></tr><tr><td>DARTS</td><td>71.29 ± 2.45</td><td>68.74 ± 2.42</td><td>68.05</td><td>65.55</td><td>92.21 ± 0.61</td><td>93.02</td><td>57079</td><td>0.24</td></tr><tr><td>NAO</td><td>68.66 ± 2.50</td><td>66.03 ± 2.40</td><td>66.22</td><td>63.59</td><td>92.59 ± 0.59</td><td>93.33</td><td>19552</td><td>0.62</td></tr><tr><td>ENAS</td><td>69.99 ±0.0</td><td>66.61 ± 0.0</td><td>69.99</td><td>66.61</td><td>91.83 ±0.42</td><td>92.54</td><td>96939</td><td>0.07</td></tr><tr><td>Space</td><td>69.69 ± 2.44</td><td>67.21 ± 2.52</td><td>65.38</td><td>62.63</td><td>90.93 ±5.84</td><td>95.06</td><td>-</td><td>1</td></tr></table>
+
+We observe that: (i) All policies failed to find the architecture that actually performs best; (ii) The ENAS policy always converged to the same architecture. This further evidences the robustness of ENAS to the random seed; (iii) NAO performs better than random sampling on average because it keeps a ranking of architectures; (iv) DARTS never discovered a top-5 architecture.
+
+Reduced CNN space. In Table 3 (B), we report the mean and best test top-1 accuracy over 10 different runs on the NASBench-101 7-node space. To assess the search performance, we also show the best architecture rank in the entire space. The best test accuracy found by these methods is 93.33, by NAO, which remains much lower than the ground-truth best of 95.06. In terms of ranking, the best rank of these methods across 10 runs is 19522, which is among the top $4 \%$ architectures and yields a probability of 0.62 to surpass a randomly-sampled one given the same search budget. Note that ENAS and DARTS only have $7 \%$ and $24 \%$ chance to surpass the random policy. See Appendix A.2 for the definition of this probability, and Appendix D.3 for detailed results.
+
+NAO seems to constantly outperform random search in the reduced space. Nevertheless, the final architecture chosen by NAO is always one of the architectures from the initial pool, which were sampled uniformly randomly. This indicates that the ranking of NAO is not correctly updated throughout the search and that, in practice, in a reduced space, NAO is similar to random search.
+
+# 4.3 IMPACT OF WEIGHT SHARING
+
+Our previous experiments in reduced search spaces highlight that the ranking of the searched architectures does not reflect the ground-truth one. As we will show below, this can be traced back to weight sharing, which all the tested algorithms, and the vast majority of existing ones, rely on. To evidence this, we perform the following experiments:
+
+Without WS: We make use of the reduced space, where we have the architecture’s real performance.
+
+With WS: We train the architectures in parallel, using the weight sharing strategy employed in NAO and ENAS. As DARTS does not have discrete representations of the solutions during the search, the idea of solution ranking does not apply. During training, each mini-batch is given to an architecture uniformly sampled from the search space. We repeat the process 10 times, with 10 random seeds and train the shared weights for 1000 epochs for the RNN experiments and 200 epochs for the CNN ones. Note that, this approach is equivalent to Single Path One Shot (SPOS) (Guo et al., 2019). It guarantees equal expectations of the number of times each architecture is sampled, thus overcoming the bias due to unbalanced training resulting from ineffective sampling policies.
+
+We then compute the correlation between the architecture rankings found with WS and the ground truth (i.e., the architectures trained independently). For each of the 10 runs of the weight sharing strategy, we evaluate the Kendall Tau metric (defined in Appendix A.1) of the final rankings with respect to the real averaged ranking.
+
+RNN Results. In Figure 4(a), we depict the architecture performance obtained without WS (sorted in ascending order of average validation perplexity), and the corresponding performance with WS. In Figure 4(b), we show the rank difference, where the best and worst were found using the Kendall Tau metric, and show a concrete rank change example in Figure 4(c).
+
+![](images/6b6b82ba76f85b80a9a515525788f6acd001300a007309f90a0e8077738f3691.jpg)  
+Figure 4: Rank disorder due to weight sharing in RNN reduced space. (a) We report the average and std over 10 different runs. Note that the rankings significantly differ between using (line plot) and not using WS (bar plot), showing the negative impact of this strategy. (b) We visualize from left to right, the best, worst and average cases, and show the corresponding Kendall Tau value. A change in ranking, indicated by the colors and numbers, is measured as the absolute position change between the WS ranking and the true one. For conciseness, we only show the top 10 architectures. (c) For example, in the average scenario, the 6-th best architecture is wrongly placed as the best one, as indicated by the red arrow.
+
+CNN Results. We report the average Kendall tau across 10 different runs. Note that we sampled up to 200 architectures for each experiment and fully evaluated on the entire test set to use the test accuracy for ranking. The Kendall tau for search spaces from 3 to 7 nodes is, respectively, 0.441, 0.314, 0.214, 0.195. We also provide other statistics in Table 6 of Appendix D.3.
+
+Table 4: Search results w/o weight sharing. We report results from ENAS ans NAO on NASBench with 7 nodes over 10 runs.   
+
+<table><tr><td>Type</td><td>Mean Acc.</td><td>Best Acc.</td><td>Best Rank</td><td>P(&gt;random)</td></tr><tr><td>NAO</td><td>93.08 ± 0.71</td><td>94.11</td><td>3543</td><td>0.92</td></tr><tr><td>ENAS</td><td>93.54± 0.45</td><td>94.04</td><td>4610</td><td>0.90</td></tr></table>
+
+Since NAO and ENAS intrinsically disentangle the training of shared weights and sampler, to further confirm the negative effect of weight sharing, we adapt these algorithms to use the architecture’s performance in the NASBench dataset to train their sampler. Table 4 evidences that, after removing weight sharing, both ENAS and NAO consistently discover a good architecture, as indicated by a small difference between the best over 10 runs and the mean performance. More interestingly, for the 7-node case, the best cell discovered $( 9 4 . 1 1 \%$ by NAO and $9 4 . 0 4 \%$ by ENAS) are more than $1 \%$ higher than the best cells found with weight sharing (93.33 and 92.54, respectively, in Table 3).
+
+# Observations:
+
+• The difference of architecture performance is not related to the use of different random seeds, as indicated by the error bars in Figure 4(a).   
+• WS never produces the true ranking, as evidenced by the Best case in Figure 4(b).   
+• The behavior of the WS rankings is greatly affected by changing the seed. In particular, the Kendall Tau for the plots in Figure 4(b) are $0 . 2 8 2 , - 0 . 0 0 4 , - 0 . 1 1 6$ for Best, Average and Worst.   
+For RNNs, the Kendall Tau are close to 0, which suggests a lack of correlation between the WS rankings and the true one. By contrast, for CNNs, the correlation is on average higher than for RNNs. This matches the observation in Section 4.1 that CNN results are generally better than RNN ones.   
+• In a reduced CNN space, the ranking disorder increases with the space complexity, i.e., this disorder is proportional to the amount of weight sharing.4   
+• If we train NAO and ENAS without weight sharing in NASBench, on average the performance is $1 \%$ higher than them with it. This further evidences that weight sharing negatively impacts the sampler, and with a good ranking, the sampler can be trained better. Furthermore, the probability to surpass random search increases from 0.62 to 0.92 for NAO and from 0.07 to 0.90 for ENAS.
+
+Together with previous results, we believe that these results evidence the negative impact of weight sharing; it dramatically affects the performance of the sampled architectures, thus complicating the overall search process and leading to search policies that are no better than the random one.
+
+# 5 CONCLUSION
+
+In this paper, we have analyzed the effectiveness of the search phase of NAS algorithms via fair comparisons to random search. We have observed that, surprisingly, the search policies of state-ofthe-art NAS techniques are no better than random, and have traced the reason for this to the use of (i) a constrained search space and (ii) weight sharing, which shuffles the architecture ranking during the search, thus negatively impacting it.
+
+In essence, our gained insights highlight two key properties of state-of-the-art NAS strategies, which had been overlooked in the past due to the single-minded focus of NAS evaluation on the results on the target tasks. We believe that this will be key to the development of novel NAS algorithms. In the future, we will aim to do so by designing relaxed weight sharing strategies.
+
+# 6 ACKNOWLEDGEMENT
+
+This work was supported in part by the Swiss National Science Foundation. We would also like to thank Rene Ranftl and Vladlen Koltun for the discussions and support.
+
+# REFERENCES
+
+Karim Ahmed and Lorenzo Torresani. Maskconnect: Connectivity learning by gradient descent. In Proceedings of the European Conference on Computer Vision (ECCV), pp. 349–365, 2018.
+
+Bowen Baker, Otkrist Gupta, Nikhil Naik, and Ramesh Raskar. Designing neural network architectures using reinforcement learning. arXiv preprint arXiv:1611.02167, 2016.
+
+Gabriel Bender, Pieter-Jan Kindermans, Barret Zoph, Vijay Vasudevan, and Quoc Le. Understanding and simplifying one-shot architecture search. In International Conference on Machine Learning, pp. 549–558, 2018.
+
+Han Cai, Tianyao Chen, Weinan Zhang, Yong Yu, and Jun Wang. Efficient architecture search by network transformation. AAAI, 2018a.
+
+Han Cai, Ligeng Zhu, and Song Han. ProxylessNAS: Direct Neural Architecture Search on Target Task and Hardware. arXiv:1812.00332 [cs, stat], December 2018b. URL http://arxiv. org/abs/1812.00332. arXiv: 1812.00332.
+
+Liang-Chieh Chen, Maxwell Collins, Yukun Zhu, George Papandreou, Barret Zoph, Florian Schroff, Hartwig Adam, and Jon Shlens. Searching for efficient multi-scale architectures for dense image prediction. In Advances in Neural Information Processing Systems, pp. 8713–8724, 2018.
+
+Yukang Chen, Tong Yang, Xiangyu Zhang, Gaofeng Meng, Chunhong Pan, and Jian Sun. DetNAS: Neural Architecture Search on Object Detection. arXiv:1903.10979 [cs], March 2019. URL http://arxiv.org/abs/1903.10979. arXiv: 1903.10979.
+
+Xiangxiang Chu, Bo Zhang, Ruijun Xu, and Jixiang Li. FairNAS: Rethinking Evaluation Fairness of Weight Sharing Neural Architecture Search. arXiv:1907.01845 [cs, stat], July 2019. URL http://arxiv.org/abs/1907.01845. arXiv: 1907.01845.
+
+Terrance DeVries and Graham W. Taylor. Improved Regularization of Convolutional Neural Networks with Cutout. arXiv:1708.04552 [cs], August 2017. URL http://arxiv.org/abs/1708. 04552. arXiv: 1708.04552.
+
+Xuanyi Dong and Yi Yang. Nas-bench-102: Extending the scope of reproducible neural architecture search. In International Conference on Learning Representations, 2020. URL https:// openreview.net/forum?id=HJxyZkBKDr.
+
+Golnaz Ghiasi, Tsung-Yi Lin, Ruoming Pang, and Quoc V. Le. NAS-FPN: Learning Scalable Feature Pyramid Architecture for Object Detection. arXiv:1904.07392 [cs], April 2019. URL http://arxiv.org/abs/1904.07392. arXiv: 1904.07392.
+
+Zichao Guo, Xiangyu Zhang, Haoyuan Mu, Wen Heng, Zechun Liu, Yichen Wei, and Jian Sun. Single Path One-Shot Neural Architecture Search with Uniform Sampling. arXiv:1904.00420 [cs], March 2019. URL http://arxiv.org/abs/1904.00420. arXiv: 1904.00420.
+
+Sepp Hochreiter and Jürgen Schmidhuber. Long short-term memory. Neural computation, 9(8): 1735–1780, 1997.
+
+Haifeng Jin, Qingquan Song, and Xia Hu. Auto-keras: An efficient neural architecture search system. In Proceedings of the 25th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, pp. 1946–1956. ACM, 2019.
+
+Kirthevasan Kandasamy, Willie Neiswanger, Jeff Schneider, Barnabas Poczos, and Eric P Xing. Neural architecture search with bayesian optimisation and optimal transport. In Advances in Neural Information Processing Systems, pp. 2016–2025, 2018.
+
+Maurice G Kendall. A new measure of rank correlation. Biometrika, 30(1/2):81–93, 1938.
+
+Alex Krizhevsky, Vinod Nair, and Geoffrey Hinton. Cifar-10 (canadian institute for advanced research). 2009.
+
+Liam Li and Ameet Talwalkar. Random search and reproducibility for neural architecture search. arXiv preprint arXiv:1902.07638, 2019.
+
+Chenxi Liu, Barret Zoph, Maxim Neumann, Jonathon Shlens, Wei Hua, Li-Jia Li, Li Fei-Fei, Alan Yuille, Jonathan Huang, and Kevin Murphy. Progressive neural architecture search. In Proceedings of the European Conference on Computer Vision (ECCV), pp. 19–34, 2018a.
+
+Chenxi Liu, Liang-Chieh Chen, Florian Schroff, Hartwig Adam, Wei Hua, Alan Yuille, and Li FeiFei. Auto-DeepLab: Hierarchical Neural Architecture Search for Semantic Image Segmentation. arXiv:1901.02985 [cs], 2019a. URL http://arxiv.org/abs/1901.02985.
+
+Hanxiao Liu, Karen Simonyan, Oriol Vinyals, Chrisantha Fernando, and Koray Kavukcuoglu. Hierarchical representations for efficient architecture search. International Conference on Learning Representations (ICLR), Conference track, 2018b.
+
+Hanxiao Liu, Karen Simonyan, and Yiming Yang. Darts: Differentiable architecture search. ICLR, 2019b.
+
+Zhichao Lu, Ian Whalen, Vishnu Boddeti, Yashesh Dhebar, Kalyanmoy Deb, Erik Goodman, and Wolfgang Banzhaf. Nsga-net: A multi-objective genetic algorithm for neural architecture search. arXiv preprint arXiv:1810.03522, 2018.
+
+Renqian Luo, Fei Tian, Tao Qin, En-Hong Chen, and Tie-Yan Liu. Neural architecture optimization. In Advances in neural information processing systems, 2018.
+
+Mitchell Marcus, Grace Kim, Mary Ann Marcinkiewicz, Robert MacIntyre, Ann Bies, Mark Ferguson, Karen Katz, and Britta Schasberger. The penn treebank: Annotating predicate argument structure. In Proceedings of the Workshop on Human Language Technology, HLT ’94, pp. 114–119, Stroudsburg, PA, USA, 1994a. Association for Computational Linguistics. ISBN 1-55860-357-3. doi: 10.3115/1075812.1075835. URL https://doi.org/10.3115/1075812.1075835.
+
+Mitchell Marcus, Grace Kim, Mary Ann Marcinkiewicz, Robert MacIntyre, Ann Bies, Mark Ferguson, Karen Katz, and Britta Schasberger. The penn treebank: Annotating predicate argument structure. In Proceedings of the Workshop on Human Language Technology, pp. 114–119. Association for Computational Linguistics, 1994b.
+
+Stephen Merity, Nitish Shirish Keskar, and Richard Socher. Regularizing and optimizing lstm language models. arXiv preprint arXiv:1708.02182, 2017.
+
+Risto Miikkulainen, Jason Liang, Elliot Meyerson, Aditya Rawal, Daniel Fink, Olivier Francon, Bala Raju, Hormoz Shahrzad, Arshak Navruzyan, Nigel Duffy, et al. Evolving deep neural networks. In Artificial Intelligence in the Age of Neural Networks and Brain Computing, pp. 293–312. Elsevier, 2019.
+
+Vinod Nair and Geoffrey E Hinton. Rectified linear units improve restricted boltzmann machines. In Proceedings of the 27th international conference on machine learning (ICML-10), pp. 807–814, 2010.
+
+Juan-Manuel Pérez-Rúa, Moez Baccouche, and Stephane Pateux. Efficient progressive neural architecture search. arXiv preprint arXiv:1808.00391, 2018.
+
+Hieu Pham, Melody Y Guan, Barret Zoph, Quoc V Le, and Jeff Dean. Efficient neural architecture search via parameter sharing. ICML, 2018.
+
+Ilija Radosavovic, Justin Johnson, Saining Xie, Wan-Yen Lo, and Piotr Dollár. On Network Design Spaces for Visual Recognition. In International Conference on Computer Vision, May 2019.
+
+Esteban Real, Sherry Moore, Andrew Selle, Saurabh Saxena, Yutaka Leon Suematsu, Jie Tan, Quoc Le, and Alex Kurakin. Large-scale evolution of image classifiers. arXiv preprint arXiv:1703.01041, 2017.
+
+David R. So, Chen Liang, and Quoc V. Le. The evolved transformer. In ICML, 2019.
+
+Mingxing Tan, Bo Chen, Ruoming Pang, Vijay Vasudevan, and Quoc V Le. Mnasnet: Platform-aware neural architecture search for mobile. arXiv preprint arXiv:1807.11626, 2018.
+
+Linnan Wang, Yiyang Zhao, Yuu Jinnai, Yuandong Tian, and Rodrigo Fonseca. AlphaX: eXploring Neural Architectures with Deep Neural Networks and Monte Carlo Tree Search. arXiv preprint arXiv:1903.11059, 2019.
+
+Bernard L Welch. The generalization ofstudent’s’ problem when several different population variances are involved. Biometrika, 34(1/2):28–35, 1947.
+
+Bichen Wu, Xiaoliang Dai, Peizhao Zhang, Yanghan Wang, Fei Sun, Yiming Wu, Yuandong Tian, Peter Vajda, Yangqing Jia, and Kurt Keutzer. FBNet: Hardware-Aware Efficient ConvNet Design via Differentiable Neural Architecture Search. arXiv:1812.03443 [cs], December 2018. URL http://arxiv.org/abs/1812.03443. arXiv: 1812.03443.
+
+L. Xie and A. Yuille. Genetic cnn. IEEE International Conference on Computer Vision (ICCV), 2017.
+
+Saining Xie, Alexander Kirillov, Ross Girshick, and Kaiming He. Exploring randomly wired neural networks for image recognition. arXiv preprint arXiv:1904.01569, 2019.
+
+Zhilin Yang, Zihang Dai, Ruslan Salakhutdinov, and William W Cohen. Breaking the softmax bottleneck: A high-rank rnn language model. arXiv preprint arXiv:1711.03953, 2017.
+
+Chris Ying, Aaron Klein, Esteban Real, Eric Christiansen, Kevin Murphy, and Frank Hutter. Nasbench-101: Towards reproducible neural architecture search. arXiv preprint arXiv:1902.09635, 2019.
+
+Arber Zela, Aaron Klein, Stefan Falkner, and Frank Hutter. Towards automated deep learning: Efficient joint neural architecture and hyperparameter search. ICML AutoML Workshop, 2018.
+
+Hongpeng Zhou, Minghao Yang, Jun Wang, and Wei Pan. Bayesnas: A bayesian approach for neural architecture search. In ICML, 2019.
+
+Barret Zoph and Quoc V. Le. Neural Architecture Search with Reinforcement Learning. International Conference on Learning Representations (ICLR), Conference track, 2017.
+
+Barret Zoph, Vijay Vasudevan, Jonathon Shlens, and Quoc V Le. Learning transferable architectures for scalable image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 8697–8710, 2018.
+
+# A METRICS TO EVALUATE NAS ALGORITHMS
+
+A.1 KENDALL TAU METRIC
+
+As a correlation measure, we make use of the Kendall Tau $( \tau )$ metric (Kendall, 1938): a number in the range [-1, 1] with the following properties:
+
+• $\tau = - 1$ : Maximum disagreement. One ranking is the opposite of the other.   
+· $\tau = 1$ : Maximum agreement. The two rankings are identical.   
+• $\tau$ close to 0: A value close to zero indicates the absence of correlation.
+
+# A.2 PROBABILITY TO SURPASS RANDOM SEARCH
+
+As discussed in Section 3.2, the goal of NASBench is to search for a CNN cell with up to 7 nodes and 3 operations, resulting in total 423,624 architectures. Each architecture is trained 3 times with different random initialization up to 108 epochs on the CIFAR-10 training set, and evaluated on the test split. Hence, the average test accuracy of these runs can be seen as the ground-truth performances. In our experiments, we use this to rank the architectures, from 1 (highest accuracy) to 423,624. Given the best architecture’s rank $r$ after $n$ runs, and maximum rank $r _ { m a x }$ equals to the total number of architectures, the probability that the best architecture discovered is better than a randomly searched one given the same budget is given by
+
+$$
+p = 1 - ( 1 - ( r / r _ { m a x } ) ) ^ { n } .
+$$
+
+We use this as a new metric to evaluate the search phase.
+
+# B NAS SEARCH SPACE REPRESENTATION
+
+As discussed in the main paper, our starting point is a neural search space for a neural architecture, as illustrated in Figure 5. A convolutional cell can be represented with a similar topological structures. Following common practice in NAS (Zoph & Le, 2017), a candidate architecture sampled from this space connects the input and the output nodes through a sequence of intermediary ones. Each node is connected to others and has an operation attached to it.
+
+A way of representing this search space (Pham et al., 2018; Luo et al., 2018), depicted in Figure 5(b), is by using strings. Each character in the string indicates either the node ID that the current node is connected to, or the operation selected for the current node. Operations include the identity, sigmoid, tanh and ReLU (Nair & Hinton, 2010).
+
+Following the alternative way introduced in (Liu et al., 2019b), we make use of a vectorized representation of these strings. More specifically, as illustrated by Figure 5(c), a node ID, resp. an operation, is encoded as a vector of probabilities over all node IDs, resp. all operations. For instance, the connection between nodes $i$ and $j$ is represented as $\begin{array} { r } { y ^ { ( i , j ) } ( x ) = \sum _ { o \in \mathcal { O } } p _ { o } o ( x ) } \end{array}$ , with $\mathcal { O }$ the set of all operations, and $p _ { o } =$ softmax $\begin{array} { r } { \mathrm { \Pi } \cdot ( \alpha _ { o } ) = \exp ( \alpha _ { o } ) / \sum _ { o ^ { \prime } \in \mathcal { O } } \exp ( \alpha _ { o ^ { \prime } } ) } \end{array}$ the probability of each operation.
+
+# C NAS ALGORITHMS
+
+Here, we discuss the three state-of-the-art NAS algorithms used in our experiments in detail, including their hyper-parameters during the search phase. The current state-of-the-arts NAS on CIFAR-10 is ProxylessNAS (Cai et al., 2018b) with a top-1 accuracy of 97.92. However, this algorithm inherits the sampler from ENAS and DARTS, but with a different objective function, backbone model, and search space. In addition, the code is not publicly available, which precludes us from directly evaluating it.
+
+# C.1 ENAS
+
+adopts a reinforcement learning sampling strategy that is updated with the REINFORCE algorithm. The sampler is implemented as a two-layer LSTM Hochreiter & Schmidhuber (1997) and generates a sequence of strings. In the training process, each candidate sampled by the ENAS controller is trained on an individual mini-batch. At the end of each epoch, the controller samples new architectures that are evaluated on a single batch of the validation dataset. After this, the controller is updated accordingly using these validation metrics. We refer the reader to (Pham et al., 2018) for details about the hyper-parameter settings.
+
+![](images/f82e2072542c3f58245a315c29562cf75228ce6c6e1d58cd0a6d554f90156194.jpg)  
+Figure 5: Search space of NAS algorithms. Typically, the search space is encoded as (a) a directed acyclic graph, and an architecture can be represented as (b) a string listing the node ID that each node is connected to, or the operation ID employed by each node. (c) An alternatively representation is a list of vectors $\alpha$ of siz e n(n+1)2 |O|, where n is the number of nodes and O is the set of all operations. Each vector, $\alpha ^ { ( i , j ) }$ , captures, via a softmax, the probability $p _ { o }$ that operation $o$ is employed between node $i$ and $j$ . Note that any node only takes one incoming edge, thus (b) and (c) represent the same search space and only differs in its formality.
+
+# C.2 DARTS
+
+It vectorizes the aforementioned strings as discussed in Section B and shown in Fig. 5(c). The sampling process is then parameterized by the vector $\alpha$ , which is optimized via gradient-descent in a dual optimization scheme: The architecture is first trained while fixing $\alpha$ , and $\alpha$ is then updated while the network is fixed. This process is repeated in an alternating manner. In the evaluation phase, DARTS samples the top-performing architecture by using the trained $\alpha$ vector as probability prior, i.e., the final model is not a soft average of all paths but one path in the DAG, which makes its evaluation identical to that of the other NAS algorithms. Note that we use the same hyper-parameters as in the released code of Liu et al. (2019b).
+
+# C.3 NAO
+
+It implements a gradient-descent algorithm, but instead of vectorizing the strings as in DARTS, it makes use of a variational auto-encoder (VAE) to learn a latent representation of the candidate architectures. Furthermore, it uses a performance predictor, which takes a latent vector as input to predict the corresponding architecture performance. In short, the search phase of NAO consists of first randomly sampling an initial pool of architectures and training them so as to obtain a ranking. This ranking is then used to train the encoder-predictor-decoder network, from which new candidates are sampled, and the process is repeated in an iterative manner. The best architecture is then taken as the top-1 in the NAO ranking. We directly use the code released by Luo et al. (2018).
+
+# C.4 BAYESNAS
+
+Bayesian optimization was first introduced to the neural architecture search field by Kandasamy et al. (2018) and Jin et al. (2019). We chose to evaluate BayesNAS (Zhou et al., 2019) because it is more recent than Auto-Keras (Jin et al., 2019) and than the work of Kandasamy et al. (2018), and because these two works use different search spaces than DARTS, resulting in models with significantly worse performance than DARTS. BayesNAS adopts Bayesian optimization to prune the fully-connected DAG graph using the shared weights to obtain accuracy metrics. The search space follows that of DARTS (Liu et al., 2019b) with minor modifications in connections, but exactly the same operations. Please see (Zhou et al., 2019) for more details. Note that BayesNAS was only implemented in CNN space. We use the search and model code released by Zhou et al. (2019) with our training pipeline, since the authors did not release the training code.
+
+# C.5 EXPERIMENTAL SETUP
+
+Following common practice in NAS, we make use of the word-level language modeling Penn Tree Bank (PTB) dataset (Marcus et al., 1994b) and of the image classification CIFAR-10 dataset (Krizhevsky et al., 2009). For these datasets, the goals are, respectively, finding a recurrent cell that correctly predicts the next word given the input sequence, and finding a convolutional cell that maximizes the classification accuracy. The quality of a candidate is then evaluated using the perplexity metric and top-1 accuracy, respectively.
+
+In the evaluation phase, we always use the same model backbone and parameter initialization for all searched architectures, which ensures fairness and reflects the empirical observation that the searched models are insensitive (accuracy variations of less than 0.002 (Liu et al., 2019b)) to initialization during evaluation. For our RNN comparisons, we follow the procedure used in (Liu et al., 2019b; Pham et al., 2018; Luo et al., 2018) for the final evaluation, consisting of keeping the connections found for the best architecture in the search phase but increasing the hidden state size (to 850 in practice), so as to increase capacity. Furthermore, when training an RNN architecture from scratch, we follow (Yang et al., 2017; Merity et al., 2017) and first make the use of standard SGD to speed up training, and then change to average SGD to improve convergence. For all CNN architectures, we use RMSProp for fast optimization (Ying et al., 2019) and enable auxiliary head and cut-out (DeVries & Taylor, 2017) to boost the performance as in Liu et al. (2019b).
+
+# C.6 ADAPTATION TO REDUCED SEARCH SPACE
+
+When changing to reduced search spaces, we adapted the evaluated search algorithms to achieve the best performance. Below, we describe these modifications.
+
+# RNN reduced space
+
+• For DARTS, no changes are needed except modifying the number of nodes in the search space. For NAO, to mimic the behavior of the algorithm in the space of 12 nodes, we randomly sample $20 \%$ of the possible architectures to define the initial candidate pool. We train the encoderpredictor-decoder network for 250 iterations every 50 epochs using the top-4 architectures in the NAO ranking. At each search iteration, we sample at most 3 new architectures to be added to the pool. The rest of the search logic remains unchanged. For ENAS, we reduce the number of architectures sampled in one epoch to 20 and increase the number of batches to 10 for each architecture. All other hyper-parameters are unchanged.
+
+# CNN reduced space
+
+For DARTS, again, no changes are needed except modifying the number of nodes in the search space.   
+• For NAO, since the topology of the NASBench space is very similar to the original search space, we kept most of the parameters unchanged, but only change the embedding size of the encoder proportionally to the number of nodes $1 2 \times { \mathrm { n o d e } } - 1 2$ ).   
+• For ENAS, we set the LSTM sampler size to 64 and keep the temperature as 5.0. The number of aggregation step of each sampler training is set to 10.
+
+# D SUPPLEMENTARY EXPERIMENTS
+
+We provide additional experiments to support our claims.
+
+# D.1 INFLUENCE OF THE AMOUNT OF SHARING
+
+Depending on the active connections in the DAG, different architectures are subject to different amounts of weight sharing. In Figure 6 (a), let us consider the 3-node case, with node 1 and node 2 fixed and node 3 having node 1 as incoming node. In this scenario, the input to node 3 can be either directly node 0 (i.e., the input), or node 1, or node 2. In the first case, the only network parameters that the output of node 3 depends on are the weights of its own operation. In the second and third cases, however, the output further depends on the parameters of node 1, and of nodes 1 and 2, respectively.
+
+![](images/92ef9e18ea4dab9602cca3f772fb6e9855e4c5edb3cf463220b76fb30e26cdcd.jpg)  
+Figure 6: A toy search space to assess the influence of weight sharing in RNN space. (a) Top: the reduced space. (a) Bottom: The amount of sharing depends on the activated path. (b) Ranking obtained from weight sharing training, that best ranked architectures has weight matrix to share.
+
+To study the influence of the amount of sharing on the architecture ranking, we performed an experiment where we fixed the first two nodes and only searched for the third one. This represents a space of 12 architectures (3 possible connections to node $3 \times 4$ operations). We train them using the same setting in Section 4.3. The ranking of the 12 architectures is shown in Figure 6 (b), where color indicates the number of shared weight matrices, that is, matrices of nodes 1 and 2 also used in the search for node 3. Note that the top-performing architectures do not share any weights and that the more weights are shared, the worse the architecture performs.
+
+In CNN space, we conduct a similar experiment in NASBench. With total node equals to 6, we only permute the last node operation and connection to one of the previous nodes. In short, we will have a total 4 connection possibility and 3 operation choices, in total 12 architectures. We compute the Kendall Tau among the architectures with the same connection but different operations, and the results are reported in Table 5. Clearly, the correlation of architectures decrease while the weight sharing matrices increase.
+
+Table 5: Ranking disorder of weight sharing in CNN.   
+
+<table><tr><td>#of shared matrix</td><td>0</td><td>1</td><td>2</td><td>3</td></tr><tr><td>Kendall Tau T</td><td>0.67.</td><td>0.33</td><td>-0.33</td><td>0.0</td></tr></table>
+
+# D.2 RANDOM SAMPLING COMPARISON
+
+As discussed before, the random policy in (Liu et al., 2019b) samples 8 architectures, and picks the best after training them for 300 epochs independently. It might seem contradictory that DARTS outperforms this random policy, but cannot surpass the much simpler one designed in our paper, which only randomly samples 10 architectures (1 per random seed), trains them to convergence and picks the best. However, the random policy in DARTS relies on the assumption that a model that performs well in the early training stage will remain effective until the end of training. While this may sound intuitive, we observed a different picture with our reduced search space.
+
+Since we obtained the ground-truth performance ranking, as discussed in Section 4.2 of the main paper, in Figure 7, we plot the evolution of models’ rank while training proceeds, based on the average validation perplexity over 10 runs. Clearly, there are significant variations during training: Good models in early stages drop lower in the ranking towards the end. As such, there is a non-negligible chance that the random policy in DARTS picks a model whose performance will be sub-optimal. We therefore believe that our policy that simply samples one model and trains it until convergence yields a more fair baseline. Furthermore, the fact that we perform our comparison using 10 random seeds, for both our approach and the NAS algorithms, vs a single one in (Liu et al., 2019b) makes our conclusions more reliable.
+
+![](images/6f8c2916cc6b9b02a74e52c9cb1ed8329657a0efc3f69003577a2f184cb3ca5f.jpg)  
+Figure 7: Rank changes while training. Each line represents the evolution of the rank of a single architecture. The models are sorted based on their test performance after 1000 epochs, with the bestperforming one at the top. The curves were averaged over 10 runs. They correspond to the experiment in Section 4.2. The vertical dashed lines indicate the epoch number where random sampling was performed, either by the random policy in Liu et al. (2019b), or by ours.
+
+Table 6: Comparison of state-of-the-art methods on NASBench-101 search space.   
+
+<table><tr><td>Search Space</td><td colspan="10">NASBench-101 on CIFAR-10.n: number of nodes,(x):total architecture choices,mean and best:top 1 acuracy (in %)</td><td></td><td></td><td></td></tr><tr><td></td><td colspan="3"></td><td colspan="3">n = 5 (2.5K)</td><td colspan="3">n =6 (64K)</td><td colspan="3">n = 7 (423K)</td><td>Best of</td></tr><tr><td>Method</td><td>Mean</td><td>n = 4 (91) Best</td><td>K-T</td><td>Mean</td><td>Best</td><td>K-T</td><td>Mean</td><td>Best</td><td>K-T</td><td>Mean</td><td>Best</td><td>K-T</td><td>all n</td></tr><tr><td>Samplingmethods,train sampler during training super-net</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>ENAS</td><td>89.41±3.54</td><td>92.95</td><td>=</td><td>89.03 ± 2.76</td><td>91.84</td><td></td><td>91.41 ± 1.42</td><td>92.75</td><td></td><td>91.83 ± 0.42</td><td>92.54</td><td></td><td>93.69</td></tr><tr><td>NAO</td><td>92.87 ± 0.69</td><td>93.88</td><td>=</td><td>92.07 ± 1.14</td><td>93.97</td><td></td><td>92.83 ±0.78</td><td>93.62</td><td></td><td>92.59± 0.59</td><td>93.33</td><td></td><td>93.97</td></tr><tr><td>DARTS FBNET</td><td>91.54 ± 1.93</td><td>93.71</td><td></td><td>91.82 ± 1.10</td><td>93.63</td><td>=</td><td>91.12 ± 1.86</td><td>93.92</td><td>=</td><td>92.21 ± 0.61</td><td>93.02</td><td></td><td>93.92</td></tr><tr><td></td><td>91.56 ± 1.89</td><td>93.71</td><td>-</td><td>92.51 ± 1.51</td><td>93.90</td><td>=</td><td>91.76 ± 1.26</td><td>92.98</td><td></td><td>92.29 ± 1.25</td><td>93.98</td><td></td><td>93.98</td></tr><tr><td colspan="10">One-shotmethods,train sampler after optimizing super-net</td><td></td><td></td><td></td><td></td></tr><tr><td>SPOS</td><td>91.14 ± 3.47</td><td>94.24</td><td>0.441</td><td>91.53 ± 1.76</td><td>93.72</td><td>0.314</td><td>90.56 ± 1.03</td><td>92.29</td><td>0.214</td><td>89.85 ± 3.80</td><td>93.84</td><td>0.195</td><td>94.24</td></tr><tr><td>FAIRNAS</td><td>89.08 ± 4.35</td><td>94.13</td><td>-0.043</td><td>91.38 ± 1.44</td><td>93.55</td><td>-0.028</td><td>91.75 ± 2.20</td><td>94.47</td><td>-0.221</td><td>91.10 ± 1.84</td><td>93.55</td><td>-0.232</td><td>94.47</td></tr></table>
+
+# D.3 NASBENCH DETAILED RESULTS.
+
+We provide additional evaluations on the NASBench dataset to benchmark the performance of the state-of-the-art NAS algorithms. In addition to the three methods in the main paper, we reimplemented some recent algorithms, such as FBNet (Wu et al., 2018), Single Path One Shot (SPOS) (Guo et al., 2019), and FairNAS (Chu et al., 2019). Note that we removed the FBNet device look-up table and model latency from the objective function since the search for a mobile model is not our primary goal. This also makes it comparable with the other baselines.
+
+To ensure fairness, after the search phase is completed, each method trains the top 1 architectures found by its policy from scratch to obtain ground-truth performance; we repeated all the experiments with 10 random seeds. We report the mean and best top 1 accuracy in Table 6 for a number of nodes $n \in [ 4 , 7 ]$ , and the Kendall Tau (K-T) values for one-shot methods following Section 4.2 in the paper.
+
+From the results, we observe that: 1) Sampling-based NAS strategies always have better mean accuracy with lower standard deviation, meaning that they converge to a local minimum more easily but do not exploit the entire search space. 2) By contrast, one-shot methods explore more diverse solutions, thus having larger standard deviations but lower means, but are able to pick a better architecture than sampling-based strategies (94.47 for FairNAS and 94.24 for SPOS, vs best of sampler based FBNet 93.98). 3) ENAS constantly improves as the number of nodes increases. 4) FBNet constantly outperforms DARTS, considering the similarity, using Gumbel Softmax seems a better choice. 5) The variance of these algorithms is large and sensitive to initialization. 6) Even one-shot algorithms cannot find the overall best architecture with accuracy 95.06.

parse/train/S1gUsoR9YX/S1gUsoR9YX.md

@@ -0,0 +1,319 @@
+# MULTILINGUAL NEURAL MACHINE TRANSLATION WITH KNOWLEDGE DISTILLATION
+
+Xu Tan1∗, Yi Ren2∗, Di $\mathbf { H e ^ { 3 } }$ , Tao ${ \bf { Q } i n } ^ { 1 }$ , Zhou Zhao2 & Tie-Yan Liu1
+
+1Microsoft Research Asia {xuta,taoqin,tyliu}@microsoft.com
+
+2Zhejiang University rayeren,zhaozhou@zju.edu.cn
+
+3Key Laboratory of Machine Perception, MOE, School of EECS, Peking University di he@pku.edu.cn
+
+# ABSTRACT
+
+Multilingual machine translation, which translates multiple languages with a single model, has attracted much attention due to its efficiency of offline training and online serving. However, traditional multilingual translation usually yields inferior accuracy compared with the counterpart using individual models for each language pair, due to language diversity and model capacity limitations. In this paper, we propose a distillation-based approach to boost the accuracy of multilingual machine translation. Specifically, individual models are first trained and regarded as teachers, and then the multilingual model is trained to fit the training data and match the outputs of individual models simultaneously through knowledge distillation. Experiments on IWSLT, WMT and Ted talk translation datasets demonstrate the effectiveness of our method. Particularly, we show that one model is enough to handle multiple languages (up to 44 languages in our experiment), with comparable or even better accuracy than individual models.
+
+# 1 INTRODUCTION
+
+Neural Machine Translation (NMT) has witnessed rapid development in recent years (Bahdanau et al., 2015; Luong et al., 2015b; Wu et al., 2016; Gehring et al., 2017; Vaswani et al., 2017; Wu et al., 2018; Song et al., 2018; Shen et al., 2018; Guo et al., 2018; He et al., 2018; Gong et al., 2018), including advanced model structures (Gehring et al., 2017; Vaswani et al., 2017) and human parity achievements (Hassan et al., 2018). While conventional NMT can well handle single pair translation, training a separate model for each language pair is resource consuming, considering there are thousands of languages in the world1. Therefore, multilingual NMT (Johnson et al., 2017; Firat et al., 2016; Ha et al., 2016; Lu et al., 2018) is developed which handles multiple language pairs in one model, greatly reducing the offline training and online serving cost.
+
+Previous works on multilingual NMT mainly focus on model architecture design through parameter sharing, e.g., sharing encoder, decoder or attention module (Firat et al., 2016; Lu et al., 2018) or sharing the entire models (Johnson et al., 2017; Ha et al., 2016). They achieve comparable accuracy with individual models (each language pair with a separate model) when the languages are similar to each other and the number of language pairs is small (e.g., two or three). However, when handling more language pairs (dozens or even hundreds), the translation accuracy of multilingual model is usually inferior to individual models, due to language diversity.
+
+It is challenging to train a multilingual translation model supporting dozens of language pairs while achieving comparable accuracy as individual models. Observing that individual models are usually of higher accuracy than the multilingual model in conventional model training, we propose to transfer the knowledge from individual models to the multilingual model with knowledge distillation, which has been studied for model compression and knowledge transfer and well matches our setting of multilingual translation. It usually starts by training a big/deep teacher model (or ensemble of multiple models), and then train a small/shallow student model to mimic the behaviors of the teacher model, such as its hidden representation (Yim et al., 2017; Romero et al., 2014), its output probabilities (Hinton et al., 2015; Freitag et al., 2017) or directly training on the sentences generated by the teacher model in neural machine translation (Kim & Rush, 2016a). The student model can (nearly) match the accuracy of the cumbersome teacher model (or the ensemble of multiple models) with knowledge distillation.
+
+In this paper, we propose a new method based on knowledge distillation for multilingual translation to eliminate the accuracy gap between the multilingual model and individual models. In our method, multiple individual models serve as teachers, each handling a separate language pair, while the student handles all the language pairs in a single model, which is different from the conventional knowledge distillation where the teacher and student models usually handle the same task. We first train the individual models for each translation pair and then we train the multilingual model by matching with the outputs of all the individual models and the ground-truth translation simultaneously. After some iterations of training, the multilingual model may get higher translation accuracy than the individual models on some language pairs. Then we remove the distillation loss and keep training the multilingual model on these languages pairs with the original log-likelihood loss of the ground-truth translation.
+
+We conduct experiments on three translation datasets: IWSLT with 12 language pairs, WMT with 6 language pairs and Ted talk with 44 language pairs. Our proposed method boosts the translation accuracy of the baseline multilingual model and achieve similar (or even better) accuracy as individual models for most language pairs. Specifically, the multilingual model with only $1 / 4 4$ parameters can match or surpass the accuracy of individual models on the Ted talk datasets.
+
+# 2 BACKGROUND
+
+# 2.1 NEURAL MACHINE TRANSLATION
+
+Given a set of bilingual sentence pairs $D = \{ ( x , y ) \in \mathcal { X } { \times } \mathcal { Y } \}$ , an NMT model learns the parameter $\theta$ by minimizing the negative log-likelihood $\begin{array} { r } { - \sum _ { ( x , y ) \in D } \log { P ( y | x ; \theta ) } . \ P ( y | x ; \theta ) } \end{array}$ is calculated based on the chain rule $\prod _ { t = 1 } ^ { T _ { y } } P ( y _ { t } | y _ { < t } , x ; \theta )$ , where $y _ { < t }$ represents the tokens preceding position $t$ , and $T _ { y }$ is the length of sentence $y$ .
+
+The encoder-decoder framework (Bahdanau et al., 2015; Luong et al., 2015b; Sutskever et al., 2014; Wu et al., 2016; Gehring et al., 2017; Vaswani et al., 2017) is usually adopted to model the conditional probability $P ( \boldsymbol { y } | \boldsymbol { x } ; \boldsymbol { \theta } )$ , where the encoder maps the input to a set of hidden representations $h$ and the decoder generates each target token $y _ { t }$ using the previous generated tokens $y _ { < t }$ as well as the representations $h$ .
+
+# 2.2 MULTILINGUAL NMT
+
+NMT has been extended from the translation of a single language pair to multilingual translation (Dong et al., 2015; Luong et al., $2 0 1 5 \mathrm { a }$ ; Firat et al., 2016; Lu et al., 2018; Johnson et al., 2017; Ha et al., 2016), considering the large amount of languages pairs in the world. Some of these works focus on how to share the components of the NMT model among multiple language pairs. Dong et al. (2015) use a shared encoder but different decoders to translate the same source language to multiple target languages. Luong et al. (2015a) use the combination of multiple encoders and decoders, with one encoder for each source language and one decoder for each target language respectively, to translate multiple source languages to multiple target languages. Firat et al. (2016) share the attention mechanism but use different encoders and decoders for multilingual translation. Similarly, Lu et al. (2018) design the neural interlingua, which is an attentional LSTM encoder to bridge multiple encoders and decoders for different language pairs. In Johnson et al. (2017) and Ha et al. (2016), multiple source and target languages are handled with a universal model (one encoder and decoder), with a special tag in the encoder to determine which target language to translate. In Gu et al. (2018a;b) and Neubig & Hu (2018), multilingual translation is leveraged to boost the accuracy of low-resource language pairs with better model structure or training mechanism.
+
+It is observed that when there are dozens of language pairs, multilingual NMT usually achieves inferior accuracy compared with its counterpart which trains an individual model for each language pair. In this work we propose the multilingual distillation framework to boost the accuracy of multilingual NMT, so as to match or even surpass the accuracy of individual models.
+
+# 2.3 KNOWLEDGE DISTILLATION
+
+The early adoption of knowledge distillation is for model compression (Bucilu et al., 2006), where the goal is to deliver a compact student model that matches the accuracy of a large teacher model or the ensemble of multiple models. Knowledge distillation has soon been applied to a variety of tasks, including image classification (Hinton et al., 2015; Furlanello et al., 2018; Yang et al., 2018; Anil et al., 2018; Li et al., 2017), speech recognition (Hinton et al., 2015) and natural language processing (Kim & Rush, 2016a; Freitag et al., 2017). Recent works (Furlanello et al., 2018; Yang et al., 2018) even demonstrate that student model can surpass the accuracy of the teacher model, even if the teacher model is of the same capacity as the student model. Zhang et al. (2017) propose the mutual learning to enable multiple student models to learn collaboratively and teach each other by knowledge distillation, which can improve the accuracy of those individual models. Anil et al. (2018) propose online distillation to improve the scalability of distributed model training and the training accuracy.
+
+In this paper, we develop the multilingual distillation framework for multilingual NMT. Our work differs from Zhang et al. (2017) and Anil et al. (2018) in that they collaboratively train multiple student models with codistillation, while we use multiple teacher models to train a single student model, the multilingual NMT model.
+
+# 3 METHOD
+
+As mentioned, when there are many language pairs and each pair has enough training data, the accuracy of individual models for those language pairs is usually higher than that of the multilingual model, given that the multilingual model has limited capacity comparing with the sum of all the individual models. Therefore, we propose to teach the multilingual model using the individual models as teachers. Here we first describe the idea of knowledge distillation in neural machine translation for the case of one teacher and one student, and then introduce our method in the multilingual setting with multiple teachers (the individual models) and one student (the multilingual model).
+
+# 3.1 ONE TEACHER AND ONE STUDENT
+
+Denote $D = \{ ( x , y ) \in \mathcal { X } \times \mathcal { Y } \}$ as the bilingual corpus of a language pair. The log-likelihood loss (cross-entropy with one-hot label) on corpus $D$ with regard to an NMT model $\theta$ can be formulated as follows:
+
+$$
+\begin{array} { r l } & { { \mathcal { L } } _ { \mathrm { N L L } } ( D ; \theta ) = - \displaystyle \sum _ { ( x , y ) \in D } \log P ( y | x ; \theta ) , } \\ & { \log P ( y | x ; \theta ) = \displaystyle \sum _ { t = 1 } ^ { T _ { y } } \sum _ { k = 1 } ^ { | V | } \mathbb { 1 } \{ y _ { t } = k \} \log P ( y _ { t } = k | y _ { < t } , x ; \theta ) , } \end{array}
+$$
+
+where $T _ { y }$ is the length of the target sentence, $| V |$ is the vocabulary size of the target language, $y _ { t }$ is the $t$ -th target token, $\mathbb { 1 } \{ \cdot \}$ is the indicator function that represents the one-hot label, and $P ( \cdot | \cdot )$ is the conditional probability with model $\theta$ .
+
+In knowledge distillation, the student (with model parameter $\theta$ ) not only matches the outputs of the ground-truth one-hot label, but also to the probability outputs of the teacher model (with parameter $\theta _ { T }$ ). Denote the output distribution of the teacher model for token $y _ { t }$ as $Q \big ( y _ { t } | y _ { < t } , x ; \theta _ { T } \big )$ . The cross
+
+entropy between two distributions serves as the distillation loss:
+
+$$
+\mathcal { L } _ { \mathrm { K D } } ( D ; \theta , \theta _ { T } ) = - \sum _ { ( x , y ) \in D } \sum _ { t = 1 } ^ { T _ { y } } \sum _ { k = 1 } ^ { | V | } Q \{ y _ { t } = k | y _ { < t } , x ; \theta _ { T } \} \log P ( y _ { t } = k | y _ { < t } , x ; \theta ) .
+$$
+
+The difference between $\mathcal { L } _ { \mathrm { N L L } } ( D ; \theta )$ and $\mathcal { L } _ { \mathrm { K D } } ( D ; \theta , \theta _ { T } )$ is that the target distribution of $\mathcal { L } _ { \mathrm { K D } } ( D ; \theta , \theta _ { T } )$ is no longer the original one-hot label, but teacher’s output distribution which is more smooth by assigning non-zero probabilities to more than one word and yields smaller variance in gradients (Hinton et al., 2015). Then the total loss function becomes
+
+$$
+\mathcal { L } _ { \mathrm { A L L } } ( D ; \theta , \theta _ { T } ) = ( 1 - \lambda ) \mathcal { L } _ { \mathrm { N L L } } ( D ; \theta ) + \lambda \mathcal { L } _ { \mathrm { K D } } ( D ; \theta , \theta _ { T } ) ,
+$$
+
+where $\lambda$ is the coefficient to trade off the two loss terms.
+
+# 3.2 MULTILINGUAL DISTILLATION WITH MULTIPLE TEACHERS AND ONE STUDENT
+
+Let $L$ denote the total number of language pairs in our setting, superscript $l \in [ L ]$ denote the index of language pair, $D ^ { l }$ denote the bilingual corpus for the $l$ -th language pair, $\theta _ { M }$ denote the parameters of the (student) multilingual model, and $\theta _ { I } ^ { l }$ denote the parameters of the (teacher) individual model for $l$ -th language pair. Therefore, $\mathcal { L } _ { \mathrm { N L L } } ( \mathrm { \bar { \it D } } ; \theta _ { M } )$ denotes the log-likelihood loss on training data $D$ , and $\mathcal { L } _ { \mathrm { A L L } } ( \bar { D ^ { l } } ; \bar { \theta } _ { M } , \theta _ { I } ^ { l } )$ denotes the total loss on training data $\bar { D } ^ { l }$ , which consists of the original log-likelihood loss and the distillation loss by matching to the outputs from the teacher model $\theta _ { I } ^ { l }$ .
+
+The multilingual distillation process is summarized in Algorithm 1. As can be seen in Line 1, our algorithm takes pretrained individual models for each language pair as inputs. Note that those models can be pretrained using the same datasets $\{ D ^ { l } \} _ { l = 1 } ^ { L }$ or different datasets, and they can share the same network structure as the multilingual model or use different architectures. For simplification, in our experiments, we use the same datasets to pretrain the individual models and they share the same architecture as the multilingual model. In Line 8-9, the multilingual model learns from both the ground-truth data and the individual models with loss ${ \mathcal { L } } _ { \mathrm { A L L } }$ when its accuracy has not surpassed the individual model for a certain threshold $\tau$ (which is checked in Line 15-19 every $\tau _ { \mathrm { c h e c k } }$ steps according to the accuracy in validation set); otherwise, the multilingual model only learns from the ground-truth data using the original log-likelihood loss ${ \mathcal { L } } _ { \mathrm { N L L } }$ (in Line 10-11).
+
+# Algorithm 1 Knowledge Distillation for Multilingual NMT
+
+1: Input: Training corpus $\{ D ^ { l } \} _ { l = 1 } ^ { L }$ and pretrained individual models $\{ \theta _ { I } ^ { l } \} _ { l = 1 } ^ { L }$ for $L$ language pairs,   
+learning rate $\eta$ , total training steps $\tau$ , distillation check step $\tau _ { \mathrm { c h e c k } }$ , threshold $\tau$ of distillation   
+accuracy.   
+2: Initialize: Randomly initialize multilingual model $\theta _ { M }$ . Set current training step $T = 0$ , accu  
+mulated gradient $g = \mathbf { 0 }$ , distillation flag ${ \bf { \bar { \boldsymbol { f } } } } ^ { l } = T r u e$ for $l \in [ L ]$ .   
+3: while $T < \tau$ do   
+4: $T = T { + } 1$   
+5: $g = \mathbf { 0 }$   
+6: for $l \in [ L ]$ do   
+7: Randomly sample a mini-batch of sentence pairs $( \mathbf { x } ^ { l } , \mathbf { y } ^ { l } )$ from $D ^ { l }$ .   
+8: if $f ^ { l } = = \dot { T } r u e$ do   
+9: Compute and accumulate the gradient on loss $\mathcal { L } _ { \mathrm { A L L } } ( ( \mathbf { x } ^ { l } , \mathbf { y } ^ { l } ) ; \theta _ { M } , \theta _ { I } ^ { l } )$ : $g + = \partial \mathcal { L } _ { \mathrm { A L L } } / \partial \theta _ { M }$ .   
+10: else   
+11: Compute and accumulate the gradient on loss $\mathcal { L } _ { \mathrm { N L L } } \big ( ( \mathbf { x } ^ { l } , \mathbf { y } ^ { l } ) ; \theta _ { M } \big )$ : $g + = \partial \mathcal { L } _ { \mathrm { N L L } } / \partial \theta _ { M }$ .   
+12: end if   
+13: end for   
+14: Update $\theta _ { M }$ : $\theta _ { M } = \theta _ { M } - \eta * g$   
+15: if $T \% \ T _ { \mathrm { c h e c k } } = = 0$ do   
+16: for $l \in [ L ]$ do   
+17: if Accuracy(θM ) < Accuracy $( \theta _ { I } ^ { l } ) + \tau$ do $f ^ { l } = T r u e$ else $f ^ { l } =$ False end if   
+18: end for   
+19: end if   
+20: end while
+
+# 3.3 DISCUSSION
+
+Selective Distillation Considering that distillation from a bad teacher model is likely to hurt the student model and thus result in inferior accuracy, we selectively use distillation in the training process, as shown in Line 15-19 in Algorithm 1. When the accuracy of multilingual model surpasses the individual model for the accuracy threshold $\tau$ on a certain language pair, we remove the distillation loss and just train the model with original negative log-likelihood loss for this pair. Note that in one iteration, one language may not uses the distillation loss; it is very likely in later iterations that this language will be distilled again since the multilingual model may become worse than the teacher model for this language. Therefore, we call this mechanism as selective distillation. We also verify the effectiveness of the selective distillation in experiment part (Section 4.3).
+
+Top-K Distillation It is burdensome to load all the teacher models in the GPU memory for distillation considering there are dozens or even hundreds of language pairs in the multilingual setting. Alternatively, we first generate the output probability distribution of each teacher model for the sentence pairs offline, and then just load the top-K probabilities of the distribution into memory and normalize them so that they sum to 1 for distillation. This can reduce the memory cost again from the scale of $| V |$ (the vocabulary size) to K. We also study in Section 4.3 that top-K distribution can result in comparable or better distillation accuracy than the full distribution.
+
+# 4 EXPERIMENTS
+
+We test our proposed method on three public datasets: IWSLT, WMT, and Ted talk translation tasks.   
+We first describe experimental settings, report results, and conduct some analyses on our method.
+
+# 4.1 SETTINGS
+
+Datasets We use three datasets in our experiment. IWSLT: We collect 12 languages English translation pairs from IWSLT evaluation campaign2 from year 2014 to 2016. WMT: We collect 6 languages English translation pairs from WMT translation task3. Ted Talk: We use the common corpus of TED talk which contains translations between multiple languages (Ye et al., 2018). We select 44 languages in this corpus that has sufficient data for our experiments. More descriptions about the three datasets can be found in Appendix (Section 1). We also list the language code according to ISO-639-1 standard4 for the languages used in our experiments in Appendix (Section 2). All the sentences are first tokenized with moses tokenizer5 and then segmented into subword symbols using Byte Pair Encoding (BPE) (Sennrich et al., 2016). We learn the BPE merge operations across all the languages and keep the output vocabulary of the teacher and student model the same, to ensure knowledge distillation.
+
+Model Configurations We use the Transformer (Vaswani et al., 2017) as the basic NMT model structure since it achieves state-of-the-art accuracy and becomes a popular choice for recent NMT researches. We use the same model configuration for individual models and the multilingual model. For IWSLT and Ted talk tasks, the model hidden size $d _ { \mathrm { m o d e l } }$ , feed-forward hidden size $d _ { \mathrm { f f } }$ , number of layer are 256, 1024 and 2, while for WMT task, the three parameters are 512, 2048 and 6 respectively considering its large scale of training data.
+
+Training and Inference For the multilingual model training, we up sample the data of each language to make all languages have the same size of data. The mini batch size is set to roughly 8192 tokens. We train the individual models with 4 NVIDIA Tesla V100 GPU cards and multilingual models with 8 of them. We follow the default parameters of Adam optimizer (Kingma & Ba, 2014) and learning rate schedule in Vaswani et al. (2017). For the individual models, we use 0.2 dropout, while for multilingual models, we use 0.1 dropout according to the validation performance. For knowledge distillation, we set $\mathcal { T } _ { \mathrm { c h e c k } } = 3 0 0 0$ steps (nearly two training epochs), the accuracy threshold $\tau = 1$ BLEU score, the distillation coefficient $\lambda = 0 . 5$ and the number of teacher’s outputs $K = 8$ according to the validation performance. During inference, we decode with beam search and set beam size to 4 and length penalty $\alpha = 1 . 0$ for all the languages. We evaluate the translation quality by tokenized case sensitive BLEU (Papineni et al., 2002) with multi-bleu.pl6. Our codes are implemented based on fairseq7 and we will release the codes once the paper is published.
+
+Table 1: BLEU scores of 12 languages English on the IWLST dataset. The BLEU scores in () represent the difference between the multilingual model and individual models. $\Delta$ represents the improvements of our multi-distillation method over the multi-baseline.   
+
+<table><tr><td>Language</td><td>Individual</td><td>Multi-Baseline</td><td>Multi-Distillation</td><td>△</td></tr><tr><td>Ar→En</td><td>31.19</td><td>29.24 (-1.95)</td><td>31.25 (+0.06)</td><td>+2.01</td></tr><tr><td>Cs-→En</td><td>28.04</td><td>26.09 (-1.95)</td><td>27.09 (-0.95)</td><td>+1.00</td></tr><tr><td>De→En</td><td>33.07</td><td>32.74 (-0.33)</td><td>34.02 (+0.95)</td><td>+1.28</td></tr><tr><td>He-→En</td><td>37.42</td><td>35.18 (-2.24)</td><td>37.33 (-0.09)</td><td>+2.15</td></tr><tr><td>N1-→En</td><td>35.94</td><td>36.54 (+0.60)</td><td>37.69 (+1.75)</td><td>+1.15</td></tr><tr><td>Pt-→En</td><td>44.30</td><td>43.49 (-0.81)</td><td>44.69 (+0.39)</td><td>+1.20</td></tr><tr><td>Ro-→En</td><td>36.92</td><td>36.41 1 (-0.51)</td><td>38.01 (+1.09)</td><td>+1.60</td></tr><tr><td>Ru→En</td><td>23.04</td><td>23.12 (+0.08)</td><td>23.76 (+0.72)</td><td>+0.64</td></tr><tr><td>Th→En</td><td>18.24</td><td>19.33 3 (+1.09)</td><td>19.90 (+1.66)</td><td>+0.57</td></tr><tr><td>Tr→En</td><td>22.74</td><td>22.42 (-0.32)</td><td>23.75 (+1.01)</td><td>+1.33</td></tr><tr><td>Vi→En</td><td>26.06</td><td>26.37 (+0.31)</td><td>27.04 4 (+0.98)</td><td>+0.67</td></tr><tr><td>Zh→En</td><td>19.44</td><td>18.82 2 (-0.62)</td><td>19.52 (+0.08)</td><td>+0.70</td></tr></table>
+
+Table 2: BLEU scores of English $ 1 2$ languages on the IWLST dataset. The BLEU scores in () represent the difference between the multilingual model and individual models. $\Delta$ represents the improvements of our multi-distillation method over the multi-baseline.   
+
+<table><tr><td>Language</td><td>Individual</td><td>Multi-Baseline</td><td>Multi-Distillation</td><td>△</td></tr><tr><td>En→Ar</td><td>13.67</td><td>12.73 (-0.94)</td><td>13.80 (+0.13)</td><td>+1.07</td></tr><tr><td>En→Cs</td><td>17.81</td><td>17.33 (-0.48)</td><td>18.69 (+0.88)</td><td>+1.37</td></tr><tr><td>En→De</td><td>26.13</td><td>25.16 (-0.97)</td><td>26.76 (+0.63)</td><td>+1.60</td></tr><tr><td>En→He</td><td>24.15</td><td>22.73 (-1.42)</td><td>24.42 (+0.27)</td><td>+1.69</td></tr><tr><td>En-→Nl</td><td>30.88</td><td>29.51 (-1.37)</td><td>30.52 (-0.36)</td><td>+1.01</td></tr><tr><td>En→Pt</td><td>37.63</td><td>35.93 (-1.70)</td><td>37.23 (-0.40)</td><td>+1.30</td></tr><tr><td>En→Ro</td><td>27.23</td><td>25.68 (-1.55)</td><td>27.11 (-0.12)</td><td>+1.42</td></tr><tr><td>En→Ru</td><td>17.40</td><td>16.26 (-1.14)</td><td>17.42 (+0.02)</td><td>+1.16</td></tr><tr><td>En→Th</td><td>26.45</td><td>27.18 (+0.73)</td><td>27.62 (+1.17)</td><td>+0.45</td></tr><tr><td>En→Tr</td><td>12.47</td><td>11.63 (-0.84)</td><td>12.84 (+0.37)</td><td>+1.21</td></tr><tr><td>En→Vi</td><td>27.88</td><td>28.04 (+0.16)</td><td>28.69 (+0.81)</td><td>+0.65</td></tr><tr><td>En→Zh</td><td>10.95</td><td>10.12 (-0.83)</td><td>10.41 (-0.54)</td><td>+0.29</td></tr></table>
+
+# 4.2 RESULTS
+
+Results on IWSLT Multilingual NMT usually consists of three settings: many-to-one, one-tomany and many-to-many. As many-many translation can be bridged though many-to-one and oneto-many setting, we just conduct the experiments on many-to-one and one-to-many settings. We first show the results of 12 languages English translations on the IWLST dataset are shown in Table 1. There are 3 methods for comparison: 1) Individual, each language pair with a separate model; 2) Multi-Baseline, the baseline multilingual model, simply training all the language pairs in one model; 3) Multi-Distillation, our multilingual model with knowledge distillation. We have several observations. First, the multilingual baseline performs worse than individual models on most languages. The only exception is the languages with small training data, which benefit from data augmentation in multilingual training. Second, our method outperforms the multilingual baseline for all the languages, demonstrating the effectiveness of our framework for multilingual NMT. More importantly, compared with the individual models, our method achieves similar or even better accuracy (better on 10 out of 12 languages), with only $1 / 1 2$ model parameters of the sum of all individual models.
+
+One-to-many setting is usually considered as more difficult than many-to-one setting, as it contains different target languages which is hard to handle. Here we show how our method performs in oneto-many setting in Table 2. It can be seen that our method can maintain the accuracy (even better on most languages) compared with the individual models. We still improve over the multilingual baseline by nearly 1 BLEU score, which demonstrates the effectiveness of our method.
+
+Table 3: BLEU scores of 6 languages English on the WMT dataset. The BLEU scores in () represent the difference between the multilingual model and individual models. $\Delta$ represents the improvements of our multi-distillation method over the multi-baseline.   
+
+<table><tr><td>Language</td><td>Individual</td><td>Multi-Baseline</td><td>Multi-Distillation</td><td>△</td></tr><tr><td>Cs-En</td><td>25.29</td><td>23.82 (-1.47)</td><td>25.37 (+0.08)</td><td>+1.55</td></tr><tr><td>De-En</td><td>34.44</td><td>34.21 (-0.23)</td><td>36.22 (+1.78)</td><td>+2.01</td></tr><tr><td>Fi-En</td><td>21.23</td><td>22.99 (+1.76)</td><td>24.32 (+3.09)</td><td>+1.33</td></tr><tr><td>Lv-En</td><td>16.26</td><td>16.25 (-0.01)</td><td>18.43 (+2.17)</td><td>+2.18</td></tr><tr><td>Ro-En</td><td>35.81</td><td>35.04 (-0.77)</td><td>36.51 (+0.70)</td><td>+1.47</td></tr><tr><td>Ru-En</td><td>29.39</td><td>28.92 (-0.47)</td><td>30.82 (+1.43)</td><td>+1.90</td></tr></table>
+
+Table 4: BLEU scores of English $ 6$ languages on the WMT dataset.   
+
+<table><tr><td>Language</td><td>Individual</td><td>Multi-Baseline</td><td>Multi-Distillation</td><td>△</td></tr><tr><td>En-Cs</td><td>22.58</td><td>21.39 (-1.19)</td><td>23.10 (+0.62)</td><td>+1.81</td></tr><tr><td>En-De</td><td>31.40</td><td>30.08 3 (-1.32)</td><td>31.42 (+0.02)</td><td>+1.34</td></tr><tr><td>En-Fi</td><td>22.08</td><td>19.52 (-2.56)</td><td>21.56 (-0.52)</td><td>+2.04</td></tr><tr><td>En-Lv</td><td>14.92</td><td>14.51 (-0.41)</td><td>15.32 (+0.40)</td><td>+0.81</td></tr><tr><td>En-Ro</td><td>31.67</td><td>29.88 (-1.79)</td><td>31.39 (-0.28)</td><td>+1.51</td></tr><tr><td>En-Ru</td><td>24.36</td><td>22.96 (-1.40)</td><td>24.02 (-0.34)</td><td>+1.06</td></tr></table>
+
+Results on WMT The results of 6 languages English translations on the WMT dataset are reported in Table 3. It can be seen that the multi-baseline model performs worse than the individual models on 5 out of 6 languages, while in contrast, our method performs better on all the 6 languages. Particularly, our method improves the accuracy of some languages with more than 2 BLEU scores over individual models. The results of one-to-many setting on WMT dataset are reported in Table 4. It can be seen that our method outperforms the multilingual baseline by more than 1 BLEU score on nearly all the languages.
+
+Table 5: BLEU scores improvements of our method over the individual models $( \Delta _ { 1 } )$ and multibaseline model $\left( \Delta _ { 2 } \right)$ on the 44 languages English in the Ted talk dataset.   
+
+<table><tr><td>Language</td><td>Ar</td><td>Bg</td><td>Cs</td><td>Da</td><td>De</td><td>E1</td><td>Es</td><td>Et</td><td>Fa</td><td>Fi</td><td>Frca</td></tr><tr><td>△1</td><td>-1.50</td><td>-9.46</td><td>1.88</td><td>4.02</td><td>-0.10</td><td>0.80</td><td>0.23</td><td>8.20</td><td>0.09</td><td>6.44</td><td>15.8</td></tr><tr><td>△2</td><td>1.73</td><td>1.42</td><td>1.13</td><td>1.82</td><td>1.68</td><td>1.45</td><td>1.63</td><td>0.77</td><td>1.83</td><td>1.10</td><td>1.24</td></tr><tr><td>Language</td><td>Fr</td><td>Gl</td><td>He</td><td>Hi</td><td>Hr</td><td>Hu</td><td>Hy</td><td>Id</td><td>It</td><td>Ja</td><td>Ka</td></tr><tr><td>△1</td><td>0.13</td><td>19.26</td><td>-1.59</td><td>10.16</td><td>1.46</td><td>-0.11</td><td>8.87</td><td>1.36</td><td>-0.56</td><td>-0.03</td><td>11.20</td></tr><tr><td>△2</td><td>1.48</td><td>1.58</td><td>2.26</td><td>1.07</td><td>1.21</td><td>1.80</td><td>0.92</td><td>1.48</td><td>1.48</td><td>0.95</td><td>1.55</td></tr><tr><td>Language</td><td>Ko</td><td>Ku</td><td>Lt</td><td>Mk</td><td>My</td><td>Nb</td><td>N1</td><td>PI</td><td>Ptbr</td><td>Pt</td><td>Ro</td></tr><tr><td>△1</td><td>-0.42</td><td>7.75</td><td>4.46</td><td>10.72</td><td>7.63</td><td>14.07</td><td>-0.20</td><td>1.32</td><td>0.13</td><td>8.76</td><td>0.66</td></tr><tr><td>△2</td><td>1.43</td><td>1.55</td><td>1.69</td><td>0.80</td><td>1.31</td><td>1.47</td><td>1.68</td><td>0.80</td><td>1.45</td><td>1.98</td><td>1.70</td></tr><tr><td>Language</td><td>Ru</td><td>Sk</td><td>S1</td><td>Sq</td><td>Sr</td><td>Sv</td><td>Th</td><td>Tr</td><td>Uk</td><td>Vi</td><td>Zh</td></tr><tr><td>△1</td><td>0.65</td><td>4.23</td><td>11.87</td><td>5.03</td><td>1.58</td><td>2.39</td><td>1.17</td><td>-0.79</td><td>2.04</td><td>0.15</td><td>6.83</td></tr><tr><td>△2</td><td>0.99</td><td>0.93</td><td>1.15</td><td>1.68</td><td>1.44</td><td>1.00</td><td>0.62</td><td>1.88</td><td>0.98</td><td>0.77</td><td>0.58</td></tr></table>
+
+Results on Ted Talk Now we study the effectiveness of our method on a large number of languages. The experiments are conducted on the 44 languages English on the Ted talk dataset. Due to the large number of languages and space limitations, we just show the BLEU score improvements of our method over individual models and the multi-baseline for each language in Table 5, and leave the detailed experiment results to Appendix (Section 3). It can be seen that our method can improve over the multi-baseline for all the languages, mostly with more than 1 BLEU score improvements. Our method can also match or even surpass individual models for most languages, not to mention that the number of parameters of our method is only $1 / 4 4$ of that of the sum of 44 individual models. Our method achieves larger improvements on some languages, such as Da, Et, Fi, Hi and Hy, than others. We find this is correlated with the data size of the languages, which are listed in Appendix (Table 13). When a language is of smaller data size, it may get more improvement due to the benefit of multilingual training.
+
+# 4.3 ANALYSIS
+
+In this section, we conduct thorough analyses on our proposed method for multilingual NMT.
+
+Selective Distillation We study the effectiveness of the selective distillation (discussed in Section 3.3) on the Ted talk dataset, as shown in Table 6. We list the 16 languages on which the two methods (selective distillation, and distillation all the time) that have difference bigger than 0.5 in terms of BLEU score. It can be seen that selective distillation performs better on 13 out of 16 languages, with large BLEU score improvements, which demonstrates the effectiveness of the selective distillation.
+
+Table 6: BLEU scores of selective distillation (our method) and distillation all the time during the training process on the Ted talk dataset.   
+
+<table><tr><td></td><td>Bg</td><td>Et</td><td>Fi</td><td>Fr</td><td>Gl</td><td>Hi</td><td>Hy</td><td>Ka</td></tr><tr><td>distillation all the time</td><td>28.07</td><td>12.64</td><td>15.13</td><td>33.69</td><td>30.28</td><td>18.86</td><td>19.88</td><td>14.04</td></tr><tr><td>selective distillation</td><td>29.18</td><td>15.63</td><td>17.23</td><td>34.32</td><td>31.90</td><td>21.00</td><td>21.17</td><td>18.27</td></tr><tr><td>△</td><td>+1.11</td><td>+2.99</td><td>+2.10</td><td>+0.63</td><td>+1.62</td><td>+2.14</td><td>+1.29</td><td>+4.23</td></tr><tr><td></td><td>Ku</td><td>Mk</td><td>My</td><td>SI</td><td>Zh</td><td>Pl</td><td>Sk</td><td>Sv</td></tr><tr><td>distillation all the time</td><td>8.50</td><td>32.10</td><td>14.02</td><td>22.10</td><td>17.22</td><td>25.05</td><td>30.45</td><td>37.88</td></tr><tr><td>selective distillation</td><td>13.38</td><td>32.65</td><td>15.17</td><td>23.68</td><td>19.39</td><td>24.30</td><td>29.91</td><td>36.92</td></tr><tr><td>△</td><td>+4.88</td><td>+0.55</td><td>+1.15</td><td>+1.58</td><td>+2.17</td><td>-0.75</td><td>-0.54</td><td>-0.96</td></tr></table>
+
+Top-K Distillation In our experiments, the student model just matches the top-K output distribution of the teacher model, instead of the full distribution, in order to reduce the memory cost. We analyze whether there is accuracy difference between the top- $\mathbf { \nabla } \cdot \mathbf { K }$ distribution and the full distribution. We conduct experiments on IWSLT dataset with varying $K$ (from 1 to $| V |$ , where $| V |$ is the vocabulary size), and just show the BLEU scores on the validation set of De-En translation due to space limitation, as illustrated in Table 7. It can be seen that increasing $K$ from 1 to 8 will improve the accuracy, while bigger $K$ will bring no gains, even with the full distribution $( K = | V | )$ ).
+
+<table><tr><td>Top-K</td><td>1</td><td>2</td><td>4</td><td>8</td><td>16</td><td>32</td><td>64</td><td>128</td><td>IVI</td></tr><tr><td>BLEU</td><td>33.45</td><td>33.86</td><td>34.47</td><td>34.76</td><td>34.66</td><td>34.68</td><td>34.54</td><td>34.47</td><td>34.49</td></tr></table>
+
+Table 7: BLEU scores on De-En translation with varying Top-K distillation on the IWSLT dataset.
+
+Back Distillation In our current distillation algorithm, we fix the individual models and use them to teach and improve the multilingual model. After such a distillation process, the multilingual model outperforms the individual models on most of the languages. Then naturally, we may wonder whether this improved multilingual model can further be used to teach and improve individual models through knowledge distillation. We call such a process back distillation. We conduct the experiments on the IWSLT dataset, and find that the accuracy of 9 out of 12 languages gets improved, as shown in Table 10. The other 3 languages (He, Pt, Zh) cannot get improvements because the improved multilingual model performs very close to individual models, as shown in Table 1.
+
+Table 8: BLEU score improvements of the individual models with back distillation on the IWSLT dataset.   
+
+<table><tr><td>Language</td><td>Ar</td><td>Cs</td><td>De</td><td>N1</td><td>Ro</td><td>Ru</td><td>Th</td><td>Tr</td><td>Vi</td></tr><tr><td>Individual</td><td>31.19</td><td>28.04</td><td>33.07</td><td>35.94</td><td>36.92</td><td>23.04</td><td>18.24</td><td>22.74</td><td>26.06</td></tr><tr><td>+Back Distillation</td><td>31.39</td><td>29.44</td><td>33.71</td><td>36.86</td><td>37.28</td><td>23.36</td><td>19.42</td><td>23.58</td><td>27.17</td></tr><tr><td>△</td><td>+0.20</td><td>+1.40</td><td>+0.64</td><td>+0.92</td><td>+0.36</td><td>+0.32</td><td>+1.18</td><td>+0.84</td><td>+1.11</td></tr></table>
+
+Comparison with Sequence-Level Knowledge Distillation We conduct experiments to compare the word-level knowledge distillation (the exact method used in our paper) with sequence-level knowledge distillation(Kim & Rush, 2016b) on IWSLT dataset. As shown in Table 9, sequencelevel knowledge distillation results in consistently inferior accuracy on all languages compared with word-level knowledge distillation used in our work.
+
+Table 9: BLEU scores of sequence-level knowledge distillation and word-level knowledge distillation on the IWSLT dataset.   
+
+<table><tr><td>Language</td><td>Sequence-level</td><td>Word-level (OurMethod)</td><td>△</td></tr><tr><td>En-Ar</td><td>12.79</td><td>13.80</td><td>1.01</td></tr><tr><td>En-Cs</td><td>17.01</td><td>18.69</td><td>1.68</td></tr><tr><td>En-De</td><td>25.89</td><td>26.76</td><td>0.87</td></tr><tr><td>En-He</td><td>22.92</td><td>24.42</td><td>1.50</td></tr><tr><td>En-N1</td><td>29.99</td><td>30.52</td><td>0.53</td></tr><tr><td>En-Pt</td><td>36.12</td><td>37.23</td><td>1.10</td></tr><tr><td>En-Ro</td><td>25.75</td><td>27.11</td><td>1.36</td></tr><tr><td>En-Ru</td><td>16.38</td><td>17.42</td><td>1.04</td></tr><tr><td>En-Th</td><td>27.52</td><td>27.62</td><td>0.10</td></tr><tr><td>En-Tr</td><td>11.11</td><td>12.84</td><td>1.73</td></tr><tr><td>En-Vi</td><td>28.08</td><td>28.69</td><td>0.61</td></tr><tr><td>En-Zh</td><td>10.25</td><td>10.41</td><td>0.16</td></tr></table>
+
+Table 10: BLEU score improvements of the individual models with back distillation on the IWSLT dataset.   
+
+<table><tr><td>Language</td><td>Ar</td><td>Cs</td><td>De</td><td>N1</td><td>Ro</td><td>Ru</td><td>Th</td><td>Tr</td><td>Vi</td></tr><tr><td>Individual</td><td>31.19</td><td>28.04</td><td>33.07</td><td>35.94</td><td>36.92</td><td>23.04</td><td>18.24</td><td>22.74</td><td>26.06</td></tr><tr><td>+Back Distillation</td><td>31.39</td><td>29.44</td><td>33.71</td><td>36.86</td><td>37.28</td><td>23.36</td><td>19.42</td><td>23.58</td><td>27.17</td></tr><tr><td>△</td><td>+0.20</td><td>+1.40</td><td>+0.64</td><td>+0.92</td><td>+0.36</td><td>+0.32</td><td>+1.18</td><td>+0.84</td><td>+1.11</td></tr></table>
+
+Generalization Analysis Previous works (Yang et al., 2018; Lan et al., 2018) have shown that knowledge distillation can help a model generalize well to unseen data, and thus yield better performance. We analyze how distillation in multilingual setting helps the model generalization. Previous studies (Keskar et al., 2016; Chaudhari et al., 2016) demonstrate the relationship between model generalization and the width of local minima in loss surface. Wider local minima can make the model more robust to small perturbations in testing. Therefore, we compare the generalization capability of the two multilingual models (our method and the baseline) by perturbing their parameters.
+
+Specifically, we perturb a model $\theta$ as $\theta _ { i } ( \sigma ) = \theta _ { i } + \bar { \theta } * \mathcal { N } ( 0 , \sigma ^ { 2 } )$ , where $\theta _ { i }$ is the $i$ -th parameter of the model, $\bar { \theta }$ is the average of all the parameters in $\theta$ . We sample from the normal distribution $\mathcal { N }$ with standard variance $\sigma$ and larger $\sigma$ represents bigger perturbation on the parameter. We conduct the analyses on the IWSLT dataset and vary $\sigma \in [ 0 . 0 5 , 0 . 1 , 0 . 1 5 , 0 . 2 , 0 . 2 5 , 0 . 3$ ]. Figure 1a shows the loss curve in the test set with varying $\sigma$ . As can be seen, while both the two losses increase with the increase of $\sigma$ , the loss of the baseline model increases quicker than our method. We also show three test BLEU curves on three translation pairs (Figure 1b: Ar-En, Figure 1c: Cs-En, Figure 1d: De-En, which are randomly picked from the 12 languages pairs on the IWSLT dataset). We observe that the BLEU score of the multilingual baseline drops quicker than our method, which demonstrates that our method helps the model find wider local minima and thus generalize better.
+
+![](images/5e02a344e3254dec9e37d9982da94e1ca6d77df15f37ee1394cba78a00a0cd7a.jpg)  
+Figure 1: The loss (Figure a) and BLEU score (Figure b: Ar-En, Figure c: Cs-En, Figure d: De-En) changes on the test set of the IWSLT dataset, with varying perturbation parameter $\sigma$ .
+
+# 5 CONCLUSION
+
+In this work, we have proposed a distillation-based approach to boost the accuracy of multilingual NMT, which is usually of lower accuracy than the individual models in previous works. Experiments on three translation datasets with up to 44 languages demonstrate the multilingual model based on our proposed method can nearly match or even outperform the individual models, with just $1 / N$ model parameters (N is up to 44 in our experiments).
+
+In the future, we will conduct more deep analyses about how distillation helps the multilingual model training. We will apply our method to larger datasets and more languages pairs (hundreds or even thousands), to study the upper limit of our proposed method.
+
+# REFERENCES
+
+Rohan Anil, Gabriel Pereyra, Alexandre Passos, Robert Ormandi, George E Dahl, and Geoffrey E Hinton. Large scale distributed neural network training through online distillation. arXiv preprint arXiv:1804.03235, 2018.   
+Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. ICLR 2015, 2015.   
+Cristian Bucilu, Rich Caruana, and Alexandru Niculescu-Mizil. Model compression. In Proceedings of the 12th ACM SIGKDD international conference on Knowledge discovery and data mining, pp. 535–541. ACM, 2006.   
+Pratik Chaudhari, Anna Choromanska, Stefano Soatto, Yann LeCun, Carlo Baldassi, Christian Borgs, Jennifer Chayes, Levent Sagun, and Riccardo Zecchina. Entropy-sgd: Biasing gradient descent into wide valleys. arXiv preprint arXiv:1611.01838, 2016.   
+Daxiang Dong, Hua Wu, Wei He, Dianhai Yu, and Haifeng Wang. Multi-task learning for multiple language translation. In Proceedings of the 53rd Annual Meeting of the Association for Computational Linguistics and the 7th International Joint Conference on Natural Language Processing (Volume 1: Long Papers), volume 1, pp. 1723–1732, 2015.   
+Orhan Firat, Kyunghyun Cho, and Yoshua Bengio. Multi-way, multilingual neural machine translation with a shared attention mechanism. In NAACL HLT 2016, The 2016 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, San Diego California, USA, June 12-17, 2016, pp. 866–875, 2016.
+
+Markus Freitag, Yaser Al-Onaizan, and Baskaran Sankaran. Ensemble distillation for neural machine translation. arXiv preprint arXiv:1702.01802, 2017.
+
+Tommaso Furlanello, Zachary C Lipton, Michael Tschannen, Laurent Itti, and Anima Anandkumar. Born again neural networks. arXiv preprint arXiv:1805.04770, 2018.
+
+Jonas Gehring, Michael Auli, David Grangier, Denis Yarats, and Yann N. Dauphin. Convolutional sequence to sequence learning. In Proceedings of the 34th International Conference on Machine Learning, ICML 2017, Sydney, NSW, Australia, 6-11 August 2017, pp. 1243–1252, 2017.
+
+Chengyue Gong, Xu Tan, Di He, and Tao Qin. Sentence-wise smooth regularization for sequence to sequence learning. In AAAI, 2018.
+
+Jiatao Gu, Hany Hassan, Jacob Devlin, and Victor O. K. Li. Universal neural machine translation for extremely low resource languages. In NAACL-HLT 2018, New Orleans, Louisiana, USA, June 1-6, 2018, Volume 1 (Long Papers), pp. 344–354, 2018a.
+
+Jiatao Gu, Yong Wang, Yun Chen, Kyunghyun Cho, and Victor OK Li. Meta-learning for lowresource neural machine translation. arXiv preprint arXiv:1808.08437, 2018b.
+
+Junliang Guo, Xu Tan, Di He, Tao Qin, Linli Xu, and Tie-Yan Liu. Non-autoregressive neural machine translation with enhanced decoder input. In AAAI, 2018.
+
+Thanh-Le Ha, Jan Niehues, and Alexander H. Waibel. Toward multilingual neural machine translation with universal encoder and decoder. CoRR, abs/1611.04798, 2016. URL http: //arxiv.org/abs/1611.04798.
+
+Hany Hassan, Anthony Aue, Chang Chen, Vishal Chowdhary, Jonathan Clark, Christian Federmann, Xuedong Huang, Marcin Junczys-Dowmunt, William Lewis, Mu Li, Shujie Liu, Tie-Yan Liu, Renqian Luo, Arul Menezes, Tao Qin, Frank Seide, Xu Tan, Fei Tian, Lijun Wu, Shuangzhi Wu, Yingce Xia, Dongdong Zhang, Zhirui Zhang, and Ming Zhou. Achieving human parity on automatic chinese to english news translation. CoRR, abs/1803.05567, 2018. URL http: //arxiv.org/abs/1803.05567.
+
+Tianyu He, Xu Tan, Yingce Xia, Di He, Tao Qin, Zhibo Chen, and Tie-Yan Liu. Layer-wise coordination between encoder and decoder for neural machine translation. In NIPS, pp. 7955–7965, 2018.
+
+Geoffrey Hinton, Oriol Vinyals, and Jeff Dean. Distilling the knowledge in a neural network. arXiv preprint arXiv:1503.02531, 2015.
+
+Melvin Johnson, Mike Schuster, Quoc V. Le, Maxim Krikun, Yonghui Wu, Zhifeng Chen, Nikhil Thorat, Fernanda B. Viegas, Martin Wattenberg, Greg Corrado, Macduff Hughes, and Jeffrey ´ Dean. Google’s multilingual neural machine translation system: Enabling zero-shot translation. TACL, 5:339–351, 2017. URL https://transacl.org/ojs/index.php/tacl/ article/view/1081.
+
+Nitish Shirish Keskar, Dheevatsa Mudigere, Jorge Nocedal, Mikhail Smelyanskiy, and Ping Tak Peter Tang. On large-batch training for deep learning: Generalization gap and sharp minima. arXiv preprint arXiv:1609.04836, 2016.
+
+Yoon Kim and Alexander M. Rush. Sequence-level knowledge distillation. In Proceedings of the 2016 Conference on Empirical Methods in Natural Language Processing, EMNLP 2016, Austin, Texas, USA, November 1-4, 2016, pp. 1317–1327, 2016a.
+
+Yoon Kim and Alexander M Rush. Sequence-level knowledge distillation. arXiv preprint arXiv:1606.07947, 2016b.
+
+Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
+
+Xu Lan, Xiatian Zhu, and Shaogang Gong. Knowledge distillation by on-the-fly native ensemble. arXiv preprint arXiv:1806.04606, 2018.
+
+Yuncheng Li, Jianchao Yang, Yale Song, Liangliang Cao, Jiebo Luo, and Li-Jia Li. Learning from noisy labels with distillation. In ICCV, pp. 1928–1936, 2017.
+
+Yichao Lu, Phillip Keung, Faisal Ladhak, Vikas Bhardwaj, Shaonan Zhang, and Jason Sun. A neural interlingua for multilingual machine translation. CoRR, abs/1804.08198, 2018. URL http://arxiv.org/abs/1804.08198.
+
+Minh-Thang Luong, Quoc V. Le, Ilya Sutskever, Oriol Vinyals, and Lukasz Kaiser. Multi-task sequence to sequence learning. CoRR, abs/1511.06114, 2015a. URL http://arxiv.org/ abs/1511.06114.
+
+Thang Luong, Hieu Pham, and Christopher D. Manning. Effective approaches to attention-based neural machine translation. In Proceedings of the 2015 Conference on Empirical Methods in Natural Language Processing, EMNLP 2015, Lisbon, Portugal, September 17-21, 2015, pp. 1412– 1421, 2015b.
+
+Graham Neubig and Junjie Hu. Rapid adaptation of neural machine translation to new languages. arXiv preprint arXiv:1808.04189, 2018.
+
+Kishore Papineni, Salim Roukos, Todd Ward, and Wei-Jing Zhu. Bleu: a method for automatic evaluation of machine translation. In Proceedings of the 40th Annual Meeting of the Association for Computational Linguistics, July 6-12, 2002, Philadelphia, PA, USA., pp. 311–318, 2002. URL http://www.aclweb.org/anthology/P02-1040.pdf.
+
+Adriana Romero, Nicolas Ballas, Samira Ebrahimi Kahou, Antoine Chassang, Carlo Gatta, and Yoshua Bengio. Fitnets: Hints for thin deep nets. arXiv preprint arXiv:1412.6550, 2014.
+
+Rico Sennrich, Barry Haddow, and Alexandra Birch. Neural machine translation of rare words with subword units. In ACL 2016, August 7-12, 2016, Berlin, Germany, Volume 1: Long Papers, 2016. URL http://aclweb.org/anthology/P/P16/P16-1162.pdf.
+
+Yanyao Shen, Xu Tan, Di He, Tao Qin, and Tie-Yan Liu. Dense information flow for neural machine translation. In NAACL, volume 1, pp. 1294–1303, 2018.
+
+Kaitao Song, Xu Tan, Di He, Jianfeng Lu, Tao Qin, and Tie-Yan Liu. Double path networks for sequence to sequence learning. In COLING, pp. 3064–3074, 2018.
+
+Ilya Sutskever, Oriol Vinyals, and Quoc V. Le. Sequence to sequence learning with neural networks. In NIPS 2014, December 8-13 2014, Montreal, Quebec, Canada, pp. 3104–3112, 2014.
+
+Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Lukasz Kaiser, and Illia Polosukhin. Attention is all you need. In NIPS 2017, 4-9 December 2017, Long Beach, CA, USA, pp. 6000–6010, 2017.
+
+Lijun Wu, Xu Tan, Di He, Fei Tian, Tao Qin, Jianhuang Lai, and Tie-Yan Liu. Beyond error propagation in neural machine translation: Characteristics of language also matter. In EMNLP, pp. 3602–3611, 2018.
+
+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. CoRR, abs/1609.08144, 2016. URL http://arxiv.org/abs/1609.08144.
+
+Chenglin Yang, Lingxi Xie, Siyuan Qiao, and Alan Yuille. Knowledge distillation in generations: More tolerant teachers educate better students. arXiv preprint arXiv:1805.05551, 2018.
+
+Qi Ye, Sachan Devendra, Felix Matthieu, Padmanabhan Sarguna, and Neubig Graham. When and why are pre-trained word embeddings useful for neural machine translation. In HLT-NAACL, 2018.
+
+Junho Yim, Donggyu Joo, Jihoon Bae, and Junmo Kim. A gift from knowledge distillation: Fast optimization, network minimization and transfer learning. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), volume 2, 2017.
+
+Ying Zhang, Tao Xiang, Timothy M Hospedales, and Huchuan Lu. Deep mutual learning. arXiv preprint arXiv:1706.00384, 6, 2017.
+
+# APPENDIX
+
+# 1 DATASET DESCRIPTION
+
+We give a detailed description about the IWSLT,WMT and Ted Talk datasets used in experiments.
+
+IWSLT: We collect 12 languages English translation pairs from IWSLT evaluation campaign8 from year 2014 to 2016. Each language pair contains roughly 80K to 200K sentence pairs. We use the official validation and test sets for each language pair. The data sizes of the training set for each language English pair are listed in Table 11.
+
+<table><tr><td>Language</td><td>Ar</td><td>Cs</td><td>De</td><td>He</td><td>N1</td><td>Pt</td></tr><tr><td>Training Data</td><td>174K</td><td>114K</td><td>167K</td><td>180K</td><td>174K</td><td>167K</td></tr><tr><td>Language</td><td>Ro</td><td>Ru</td><td>Th</td><td>Tr</td><td>Vi</td><td>Zh</td></tr><tr><td>Training Data</td><td>177K</td><td>173K</td><td>83K</td><td>150K</td><td>131K</td><td>209K</td></tr></table>
+
+Table 11: The training data size on the 12 languages English on the IWSLT dataset.
+
+WMT: We collect 6 languages English translation pairs from WMT translation task9. We use 5 language English translation pairs from WMT 2016 dataset: Cs-En, De-En, Fi-En, Ro-En, RuEn and one other translation pair from WMT 2017 dataset: Lv-En. We use the official released validation and test sets for each language pair. The training data sizes of each language English pair are shown in the Table 12.
+
+Table 12: The training data size on the 6 languages English on the WMT dataset.   
+
+<table><tr><td>Language</td><td>Cs</td><td>De</td><td>Fi</td><td>Lv</td><td>Ro</td><td>Ru</td></tr><tr><td>Training Data</td><td>1.0M</td><td>4.5M</td><td>2.5M</td><td>4.5M</td><td>2.2M</td><td>2.1M</td></tr></table>
+
+Ted Talk: We use the common corpus of TED talk which contains translations between multiple languages (Ye et al., 2018)10. We select 44 languages in this corpus that has sufficient data for our experiments. We use the official validation and test sets for each language pair. The data sizes of the training set for each language English pair are listed in Table 13.
+
+Table 13: The training data size on the 44 languages English on the Ted talk dataset.   
+
+<table><tr><td>Language</td><td>Ar</td><td>Bg</td><td>Cs</td><td>Da</td><td>De</td><td>E1</td><td>Es</td><td>Et</td><td>Fa</td><td>Fi</td><td>Frca</td></tr><tr><td>Training Data</td><td>214K</td><td>174k</td><td>103k</td><td>45k</td><td>168k</td><td>134k</td><td>196k</td><td>11k</td><td>151k</td><td>24k</td><td>20k</td></tr><tr><td>Language</td><td>Fr</td><td>Gl</td><td>He</td><td>Hi</td><td>Hr</td><td>Hu</td><td>Hy</td><td>Id</td><td>It</td><td>Ja</td><td>Ka</td></tr><tr><td>Training Data</td><td>192K</td><td>10K</td><td>212K</td><td>19K</td><td>122K</td><td>147K</td><td>21K</td><td>87K</td><td>205K</td><td>204K</td><td>13K</td></tr><tr><td>Language</td><td>Ko</td><td>Ku</td><td>Lt</td><td>Mk</td><td>My</td><td>Nb</td><td>NI</td><td>Pl</td><td>Ptbr</td><td>Pt</td><td>Ro</td></tr><tr><td>Training Data</td><td>206K</td><td>10K</td><td>42K</td><td>25K</td><td>21K</td><td>16K</td><td>184K</td><td>176K</td><td>185K</td><td>52K</td><td>180K</td></tr><tr><td>Language</td><td>Ru</td><td>Sk</td><td>S1</td><td>Sq</td><td>Sr</td><td>Sv</td><td>Th</td><td>Tr</td><td>Uk</td><td>Vi</td><td>Zh</td></tr><tr><td>Training Data</td><td>208K</td><td>61K</td><td>20K</td><td>45K</td><td>137K</td><td>57K</td><td>98K</td><td>182K</td><td>108K</td><td>172K</td><td>200K</td></tr></table>
+
+# 2 LANGUAGE NAME AND CODE
+
+The language names and their corresponding language codes according to ISO 639-1 standard11 are listed in Table 14.
+
+<table><tr><td>Language</td><td>Code</td><td>Language</td><td>Code</td><td>Language</td><td>Code</td><td>Language</td><td>Code</td></tr><tr><td>Arabic</td><td>Ar</td><td>Bulgarian</td><td>Bg</td><td>Czech</td><td>Cs</td><td>Danish</td><td>Da</td></tr><tr><td>German</td><td>De</td><td>Greek</td><td>El</td><td>English</td><td>En</td><td>Spanish</td><td>Es</td></tr><tr><td>Persian</td><td>Fa</td><td>Finnish</td><td>Fi</td><td>French</td><td>Fr</td><td>Galician</td><td>Gl</td></tr><tr><td>Hebrew</td><td>He</td><td>Hindi</td><td>Hi</td><td>Croatian</td><td>Hr</td><td>Hungarian</td><td>Hu</td></tr><tr><td>Armenian</td><td>Hy</td><td>Indonesian</td><td>Id</td><td>Italian</td><td>It</td><td>Japanese</td><td>Ja</td></tr><tr><td>Georgian</td><td>Ka</td><td>Korean</td><td>Ko</td><td>Kurdish</td><td>Ku</td><td>Lithuanian</td><td>Lt</td></tr><tr><td>Latvian</td><td>Lv</td><td>Macedonian</td><td>Mk</td><td>Burmese</td><td>My</td><td>Norwegian</td><td>Nb</td></tr><tr><td>Dutch</td><td>N1</td><td>Polish</td><td>Pl</td><td>Portuguese</td><td>Pt</td><td>Romanian</td><td>Ro</td></tr><tr><td>Russian</td><td>Ru</td><td>Slovak</td><td>Sk</td><td>Slovenian</td><td>S1</td><td>Albanian</td><td>Sq</td></tr><tr><td>Serbian</td><td>Sr</td><td>Swedish</td><td>Sv</td><td>Thai</td><td>Th</td><td>Turkish</td><td>Tr</td></tr><tr><td>Ukrainian</td><td>Uk</td><td>Vietnamese</td><td>Vi</td><td>Chinese</td><td>Zh</td><td></td><td></td></tr></table>
+
+Table 14: The ISO 639-1 code of each language in our experiments. There are two extra language codes in our datasets: Ptbr represents Portuguese spoken in Brazil, Frca represents French spoken in Canada.
+
+# 3 RESULTS ON TED TALK DATASET
+
+The detailed results of the 44 languages English on the Ted talk dataset are listed in Table 15. It can be seen that while multilingual baseline performs worse than the individual model, multilingual model based on our method nearly matches and even outperforms the individual model. Note that the multilingual model handles 44 languages in total, which means our method can reduce the model parameters size to $1 / 4 4$ without loss of accuracy.   
+Table 15: BLEU scores of the individual and multilingual models on the 44 languages English on the Ted talk dataset.   
+
+<table><tr><td>Language</td><td>Ar</td><td>Bg</td><td>Cs</td><td>Da</td><td>De</td><td>E1</td><td>Es</td><td>Et</td><td>Fa</td></tr><tr><td>Individual</td><td>31.07</td><td>38.64</td><td>26.42</td><td>38.21</td><td>34.63</td><td>36.69</td><td>41.20</td><td>7.43</td><td>26.67</td></tr><tr><td>Multilingual (Baseline)</td><td>27.84</td><td>27.76</td><td>27.17</td><td>40.41</td><td>32.85</td><td>36.04</td><td>39.80</td><td>14.86</td><td>24.93</td></tr><tr><td>Multilingual (Our method)</td><td>29.57</td><td>29.18</td><td>28.30</td><td>42.23</td><td>34.53</td><td>37.49</td><td>41.43</td><td>15.63</td><td>26.76</td></tr><tr><td>Language</td><td>Fi</td><td>Frca</td><td>Fr</td><td>Gl</td><td>He</td><td>Hi</td><td>Hr</td><td>Hu</td><td>Hy</td></tr><tr><td>Individual</td><td>10.78</td><td>18.52</td><td>39.62</td><td>12.64</td><td>36.81</td><td>10.84</td><td>34.14</td><td>24.67</td><td>12.30</td></tr><tr><td>Multilingual (Baseline)</td><td>16.12</td><td>33.08</td><td>38.27</td><td>30.32</td><td>32.96</td><td>19.93</td><td>34.39</td><td>22.76</td><td>20.25</td></tr><tr><td>Multilingual (Our method)</td><td>17.22</td><td>34.32</td><td>39.75</td><td>31.9</td><td>35.22</td><td>21.00</td><td>35.6</td><td>24.56</td><td>21.17</td></tr><tr><td>Language</td><td>Id</td><td>It</td><td>Ja</td><td>Ka</td><td>Ko</td><td>Ku</td><td>Lt</td><td>Mk</td><td>My</td></tr><tr><td>Individual</td><td>29.20</td><td>38.06</td><td>13.31</td><td>7.06</td><td>18.54</td><td>5.63</td><td>18.19</td><td>21.93</td><td>7.53</td></tr><tr><td>Multilingual (Baseline)</td><td>29.08</td><td>36.02</td><td>12.33</td><td>16.71</td><td>16.71</td><td>11.83</td><td>20.96</td><td>31.85</td><td>13.85</td></tr><tr><td>Multilingual (Our method)</td><td>30.56</td><td>37.50</td><td>13.28</td><td>18.26</td><td>18.14</td><td>13.38</td><td>22.65</td><td>32.65</td><td>15.16</td></tr><tr><td>Language</td><td>Nb</td><td>NI</td><td>PI</td><td>Ptbr</td><td>Pt</td><td>Ro</td><td>Ru</td><td>Sk</td><td>SI</td></tr><tr><td>Individual</td><td>27.28</td><td>35.85</td><td>22.98</td><td>44.28</td><td>33.81</td><td>34.07</td><td>24.36</td><td>25.67</td><td>11.80</td></tr><tr><td>Multilingual (Baseline)</td><td>39.88</td><td>33.97</td><td>23.50</td><td>42.96</td><td>40.59</td><td>33.03</td><td>24.02</td><td>28.97</td><td>22.52</td></tr><tr><td>Multilingual (Our method)</td><td>41.35</td><td>35.65</td><td>24.30</td><td>44.41</td><td>42.57</td><td>34.73</td><td>25.01</td><td>29.90</td><td>23.67</td></tr><tr><td>Language</td><td>Sq</td><td>Sr</td><td>Sv</td><td>Th</td><td>Tr</td><td>Uk</td><td>Vi</td><td>Zh</td><td></td></tr><tr><td>Individual</td><td>29.70</td><td>32.13</td><td>34.53</td><td>20.95</td><td>24.46</td><td>25.76</td><td>26.38</td><td>12.56</td><td></td></tr><tr><td>Multilingual (Baseline)</td><td>33.05</td><td>32.27</td><td>35.92</td><td>21.50</td><td>21.79</td><td>26.82</td><td>25.76</td><td>18.81</td><td></td></tr><tr><td>Multilingual (Our method)</td><td>34.73</td><td>33.71</td><td>36.92</td><td>22.12</td><td>23.67</td><td>27.80</td><td>26.53</td><td>19.39</td><td></td></tr></table>

parse/train/S1gUsoR9YX/S1gUsoR9YX_content_list.json

@@ -0,0 +1,1591 @@
+[
+    {
+        "type": "text",
+        "text": "MULTILINGUAL NEURAL MACHINE TRANSLATION WITH KNOWLEDGE DISTILLATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            821,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Xu Tan1∗, Yi Ren2∗, Di $\\mathbf { H e ^ { 3 } }$ , Tao ${ \\bf { Q } i n } ^ { 1 }$ , Zhou Zhao2 & Tie-Yan Liu1 ",
+        "bbox": [
+            184,
+            167,
+            691,
+            184
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1Microsoft Research Asia {xuta,taoqin,tyliu}@microsoft.com ",
+        "bbox": [
+            184,
+            198,
+            506,
+            227
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "2Zhejiang University rayeren,zhaozhou@zju.edu.cn ",
+        "bbox": [
+            184,
+            239,
+            450,
+            268
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "3Key Laboratory of Machine Perception, MOE, School of EECS, Peking University di he@pku.edu.cn ",
+        "bbox": [
+            184,
+            281,
+            733,
+            310
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            347,
+            544,
+            362
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Multilingual machine translation, which translates multiple languages with a single model, has attracted much attention due to its efficiency of offline training and online serving. However, traditional multilingual translation usually yields inferior accuracy compared with the counterpart using individual models for each language pair, due to language diversity and model capacity limitations. In this paper, we propose a distillation-based approach to boost the accuracy of multilingual machine translation. Specifically, individual models are first trained and regarded as teachers, and then the multilingual model is trained to fit the training data and match the outputs of individual models simultaneously through knowledge distillation. Experiments on IWSLT, WMT and Ted talk translation datasets demonstrate the effectiveness of our method. Particularly, we show that one model is enough to handle multiple languages (up to 44 languages in our experiment), with comparable or even better accuracy than individual models. ",
+        "bbox": [
+            233,
+            380,
+            764,
+            559
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            588,
+            336,
+            604
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Neural Machine Translation (NMT) has witnessed rapid development in recent years (Bahdanau et al., 2015; Luong et al., 2015b; Wu et al., 2016; Gehring et al., 2017; Vaswani et al., 2017; Wu et al., 2018; Song et al., 2018; Shen et al., 2018; Guo et al., 2018; He et al., 2018; Gong et al., 2018), including advanced model structures (Gehring et al., 2017; Vaswani et al., 2017) and human parity achievements (Hassan et al., 2018). While conventional NMT can well handle single pair translation, training a separate model for each language pair is resource consuming, considering there are thousands of languages in the world1. Therefore, multilingual NMT (Johnson et al., 2017; Firat et al., 2016; Ha et al., 2016; Lu et al., 2018) is developed which handles multiple language pairs in one model, greatly reducing the offline training and online serving cost. ",
+        "bbox": [
+            174,
+            621,
+            825,
+            746
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Previous works on multilingual NMT mainly focus on model architecture design through parameter sharing, e.g., sharing encoder, decoder or attention module (Firat et al., 2016; Lu et al., 2018) or sharing the entire models (Johnson et al., 2017; Ha et al., 2016). They achieve comparable accuracy with individual models (each language pair with a separate model) when the languages are similar to each other and the number of language pairs is small (e.g., two or three). However, when handling more language pairs (dozens or even hundreds), the translation accuracy of multilingual model is usually inferior to individual models, due to language diversity. ",
+        "bbox": [
+            174,
+            752,
+            825,
+            851
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "It is challenging to train a multilingual translation model supporting dozens of language pairs while achieving comparable accuracy as individual models. Observing that individual models are usually of higher accuracy than the multilingual model in conventional model training, we propose to transfer the knowledge from individual models to the multilingual model with knowledge distillation, which has been studied for model compression and knowledge transfer and well matches our setting of multilingual translation. It usually starts by training a big/deep teacher model (or ensemble of multiple models), and then train a small/shallow student model to mimic the behaviors of the teacher model, such as its hidden representation (Yim et al., 2017; Romero et al., 2014), its output probabilities (Hinton et al., 2015; Freitag et al., 2017) or directly training on the sentences generated by the teacher model in neural machine translation (Kim & Rush, 2016a). The student model can (nearly) match the accuracy of the cumbersome teacher model (or the ensemble of multiple models) with knowledge distillation. ",
+        "bbox": [
+            176,
+            857,
+            821,
+            886
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            242
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we propose a new method based on knowledge distillation for multilingual translation to eliminate the accuracy gap between the multilingual model and individual models. In our method, multiple individual models serve as teachers, each handling a separate language pair, while the student handles all the language pairs in a single model, which is different from the conventional knowledge distillation where the teacher and student models usually handle the same task. We first train the individual models for each translation pair and then we train the multilingual model by matching with the outputs of all the individual models and the ground-truth translation simultaneously. After some iterations of training, the multilingual model may get higher translation accuracy than the individual models on some language pairs. Then we remove the distillation loss and keep training the multilingual model on these languages pairs with the original log-likelihood loss of the ground-truth translation. ",
+        "bbox": [
+            174,
+            250,
+            825,
+            401
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We conduct experiments on three translation datasets: IWSLT with 12 language pairs, WMT with 6 language pairs and Ted talk with 44 language pairs. Our proposed method boosts the translation accuracy of the baseline multilingual model and achieve similar (or even better) accuracy as individual models for most language pairs. Specifically, the multilingual model with only $1 / 4 4$ parameters can match or surpass the accuracy of individual models on the Ted talk datasets. ",
+        "bbox": [
+            174,
+            410,
+            825,
+            479
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 BACKGROUND ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            500,
+            326,
+            517
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 NEURAL MACHINE TRANSLATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            532,
+            452,
+            547
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Given a set of bilingual sentence pairs $D = \\{ ( x , y ) \\in \\mathcal { X } { \\times } \\mathcal { Y } \\}$ , an NMT model learns the parameter $\\theta$ by minimizing the negative log-likelihood $\\begin{array} { r } { - \\sum _ { ( x , y ) \\in D } \\log { P ( y | x ; \\theta ) } . \\ P ( y | x ; \\theta ) } \\end{array}$ is calculated based on the chain rule $\\prod _ { t = 1 } ^ { T _ { y } } P ( y _ { t } | y _ { < t } , x ; \\theta )$ , where $y _ { < t }$ represents the tokens preceding position $t$ , and $T _ { y }$ is the length of sentence $y$ . ",
+        "bbox": [
+            174,
+            559,
+            825,
+            622
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The encoder-decoder framework (Bahdanau et al., 2015; Luong et al., 2015b; Sutskever et al., 2014; Wu et al., 2016; Gehring et al., 2017; Vaswani et al., 2017) is usually adopted to model the conditional probability $P ( \\boldsymbol { y } | \\boldsymbol { x } ; \\boldsymbol { \\theta } )$ , where the encoder maps the input to a set of hidden representations $h$ and the decoder generates each target token $y _ { t }$ using the previous generated tokens $y _ { < t }$ as well as the representations $h$ . ",
+        "bbox": [
+            174,
+            628,
+            825,
+            698
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.2 MULTILINGUAL NMT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            717,
+            367,
+            731
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "NMT has been extended from the translation of a single language pair to multilingual translation (Dong et al., 2015; Luong et al., $2 0 1 5 \\mathrm { a }$ ; Firat et al., 2016; Lu et al., 2018; Johnson et al., 2017; Ha et al., 2016), considering the large amount of languages pairs in the world. Some of these works focus on how to share the components of the NMT model among multiple language pairs. Dong et al. (2015) use a shared encoder but different decoders to translate the same source language to multiple target languages. Luong et al. (2015a) use the combination of multiple encoders and decoders, with one encoder for each source language and one decoder for each target language respectively, to translate multiple source languages to multiple target languages. Firat et al. (2016) share the attention mechanism but use different encoders and decoders for multilingual translation. Similarly, Lu et al. (2018) design the neural interlingua, which is an attentional LSTM encoder to bridge multiple encoders and decoders for different language pairs. In Johnson et al. (2017) and Ha et al. (2016), multiple source and target languages are handled with a universal model (one encoder and decoder), with a special tag in the encoder to determine which target language to translate. In Gu et al. (2018a;b) and Neubig & Hu (2018), multilingual translation is leveraged to boost the accuracy of low-resource language pairs with better model structure or training mechanism. ",
+        "bbox": [
+            174,
+            743,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            821,
+            132
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "It is observed that when there are dozens of language pairs, multilingual NMT usually achieves inferior accuracy compared with its counterpart which trains an individual model for each language pair. In this work we propose the multilingual distillation framework to boost the accuracy of multilingual NMT, so as to match or even surpass the accuracy of individual models. ",
+        "bbox": [
+            174,
+            138,
+            823,
+            194
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.3 KNOWLEDGE DISTILLATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            219,
+            411,
+            233
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The early adoption of knowledge distillation is for model compression (Bucilu et al., 2006), where the goal is to deliver a compact student model that matches the accuracy of a large teacher model or the ensemble of multiple models. Knowledge distillation has soon been applied to a variety of tasks, including image classification (Hinton et al., 2015; Furlanello et al., 2018; Yang et al., 2018; Anil et al., 2018; Li et al., 2017), speech recognition (Hinton et al., 2015) and natural language processing (Kim & Rush, 2016a; Freitag et al., 2017). Recent works (Furlanello et al., 2018; Yang et al., 2018) even demonstrate that student model can surpass the accuracy of the teacher model, even if the teacher model is of the same capacity as the student model. Zhang et al. (2017) propose the mutual learning to enable multiple student models to learn collaboratively and teach each other by knowledge distillation, which can improve the accuracy of those individual models. Anil et al. (2018) propose online distillation to improve the scalability of distributed model training and the training accuracy. ",
+        "bbox": [
+            174,
+            247,
+            825,
+            414
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we develop the multilingual distillation framework for multilingual NMT. Our work differs from Zhang et al. (2017) and Anil et al. (2018) in that they collaboratively train multiple student models with codistillation, while we use multiple teacher models to train a single student model, the multilingual NMT model. ",
+        "bbox": [
+            174,
+            421,
+            825,
+            477
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 METHOD ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            505,
+            282,
+            520
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "As mentioned, when there are many language pairs and each pair has enough training data, the accuracy of individual models for those language pairs is usually higher than that of the multilingual model, given that the multilingual model has limited capacity comparing with the sum of all the individual models. Therefore, we propose to teach the multilingual model using the individual models as teachers. Here we first describe the idea of knowledge distillation in neural machine translation for the case of one teacher and one student, and then introduce our method in the multilingual setting with multiple teachers (the individual models) and one student (the multilingual model). ",
+        "bbox": [
+            174,
+            540,
+            825,
+            637
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 ONE TEACHER AND ONE STUDENT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            661,
+            459,
+            676
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Denote $D = \\{ ( x , y ) \\in \\mathcal { X } \\times \\mathcal { Y } \\}$ as the bilingual corpus of a language pair. The log-likelihood loss (cross-entropy with one-hot label) on corpus $D$ with regard to an NMT model $\\theta$ can be formulated as follows: ",
+        "bbox": [
+            174,
+            689,
+            825,
+            732
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c6b7d0928b4f7b10f71a64a56c5f7368462fa97048dce07e9a3538bed12d6b25.jpg",
+        "text": "$$\n\\begin{array} { r l } & { { \\mathcal { L } } _ { \\mathrm { N L L } } ( D ; \\theta ) = - \\displaystyle \\sum _ { ( x , y ) \\in D } \\log P ( y | x ; \\theta ) , } \\\\ & { \\log P ( y | x ; \\theta ) = \\displaystyle \\sum _ { t = 1 } ^ { T _ { y } } \\sum _ { k = 1 } ^ { | V | } \\mathbb { 1 } \\{ y _ { t } = k \\} \\log P ( y _ { t } = k | y _ { < t } , x ; \\theta ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            300,
+            736,
+            696,
+            821
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $T _ { y }$ is the length of the target sentence, $| V |$ is the vocabulary size of the target language, $y _ { t }$ is the $t$ -th target token, $\\mathbb { 1 } \\{ \\cdot \\}$ is the indicator function that represents the one-hot label, and $P ( \\cdot | \\cdot )$ is the conditional probability with model $\\theta$ . ",
+        "bbox": [
+            178,
+            832,
+            821,
+            875
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In knowledge distillation, the student (with model parameter $\\theta$ ) not only matches the outputs of the ground-truth one-hot label, but also to the probability outputs of the teacher model (with parameter $\\theta _ { T }$ ). Denote the output distribution of the teacher model for token $y _ { t }$ as $Q \\big ( y _ { t } | y _ { < t } , x ; \\theta _ { T } \\big )$ . The cross ",
+        "bbox": [
+            174,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "entropy between two distributions serves as the distillation loss: ",
+        "bbox": [
+            173,
+            103,
+            591,
+            118
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/98905039105c29a249e708779460768106ca9672fbee260031319d6596d6fcf3.jpg",
+        "text": "$$\n\\mathcal { L } _ { \\mathrm { K D } } ( D ; \\theta , \\theta _ { T } ) = - \\sum _ { ( x , y ) \\in D } \\sum _ { t = 1 } ^ { T _ { y } } \\sum _ { k = 1 } ^ { | V | } Q \\{ y _ { t } = k | y _ { < t } , x ; \\theta _ { T } \\} \\log P ( y _ { t } = k | y _ { < t } , x ; \\theta ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            225,
+            125,
+            771,
+            172
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The difference between $\\mathcal { L } _ { \\mathrm { N L L } } ( D ; \\theta )$ and $\\mathcal { L } _ { \\mathrm { K D } } ( D ; \\theta , \\theta _ { T } )$ is that the target distribution of $\\mathcal { L } _ { \\mathrm { K D } } ( D ; \\theta , \\theta _ { T } )$ is no longer the original one-hot label, but teacher’s output distribution which is more smooth by assigning non-zero probabilities to more than one word and yields smaller variance in gradients (Hinton et al., 2015). Then the total loss function becomes ",
+        "bbox": [
+            174,
+            179,
+            823,
+            236
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/18ce6de7b3599aa51a7291222693686c66e5a401faff4c9a0b5e7942c5deaca2.jpg",
+        "text": "$$\n\\mathcal { L } _ { \\mathrm { A L L } } ( D ; \\theta , \\theta _ { T } ) = ( 1 - \\lambda ) \\mathcal { L } _ { \\mathrm { N L L } } ( D ; \\theta ) + \\lambda \\mathcal { L } _ { \\mathrm { K D } } ( D ; \\theta , \\theta _ { T } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            307,
+            241,
+            689,
+            260
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\lambda$ is the coefficient to trade off the two loss terms. ",
+        "bbox": [
+            174,
+            266,
+            542,
+            281
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 MULTILINGUAL DISTILLATION WITH MULTIPLE TEACHERS AND ONE STUDENT",
+        "text_level": 1,
+        "bbox": [
+            173,
+            296,
+            767,
+            313
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Let $L$ denote the total number of language pairs in our setting, superscript $l \\in [ L ]$ denote the index of language pair, $D ^ { l }$ denote the bilingual corpus for the $l$ -th language pair, $\\theta _ { M }$ denote the parameters of the (student) multilingual model, and $\\theta _ { I } ^ { l }$ denote the parameters of the (teacher) individual model for $l$ -th language pair. Therefore, $\\mathcal { L } _ { \\mathrm { N L L } } ( \\mathrm { \\bar { \\it D } } ; \\theta _ { M } )$ denotes the log-likelihood loss on training data $D$ , and $\\mathcal { L } _ { \\mathrm { A L L } } ( \\bar { D ^ { l } } ; \\bar { \\theta } _ { M } , \\theta _ { I } ^ { l } )$ denotes the total loss on training data $\\bar { D } ^ { l }$ , which consists of the original log-likelihood loss and the distillation loss by matching to the outputs from the teacher model $\\theta _ { I } ^ { l }$ . ",
+        "bbox": [
+            173,
+            323,
+            825,
+            409
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The multilingual distillation process is summarized in Algorithm 1. As can be seen in Line 1, our algorithm takes pretrained individual models for each language pair as inputs. Note that those models can be pretrained using the same datasets $\\{ D ^ { l } \\} _ { l = 1 } ^ { L }$ or different datasets, and they can share the same network structure as the multilingual model or use different architectures. For simplification, in our experiments, we use the same datasets to pretrain the individual models and they share the same architecture as the multilingual model. In Line 8-9, the multilingual model learns from both the ground-truth data and the individual models with loss ${ \\mathcal { L } } _ { \\mathrm { A L L } }$ when its accuracy has not surpassed the individual model for a certain threshold $\\tau$ (which is checked in Line 15-19 every $\\tau _ { \\mathrm { c h e c k } }$ steps according to the accuracy in validation set); otherwise, the multilingual model only learns from the ground-truth data using the original log-likelihood loss ${ \\mathcal { L } } _ { \\mathrm { N L L } }$ (in Line 10-11). ",
+        "bbox": [
+            173,
+            415,
+            825,
+            554
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 Knowledge Distillation for Multilingual NMT ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            569,
+            565,
+            585
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "1: Input: Training corpus $\\{ D ^ { l } \\} _ { l = 1 } ^ { L }$ and pretrained individual models $\\{ \\theta _ { I } ^ { l } \\} _ { l = 1 } ^ { L }$ for $L$ language pairs,   \nlearning rate $\\eta$ , total training steps $\\tau$ , distillation check step $\\tau _ { \\mathrm { c h e c k } }$ , threshold $\\tau$ of distillation   \naccuracy.   \n2: Initialize: Randomly initialize multilingual model $\\theta _ { M }$ . Set current training step $T = 0$ , accu  \nmulated gradient $g = \\mathbf { 0 }$ , distillation flag ${ \\bf { \\bar { \\boldsymbol { f } } } } ^ { l } = T r u e$ for $l \\in [ L ]$ .   \n3: while $T < \\tau$ do   \n4: $T = T { + } 1$   \n5: $g = \\mathbf { 0 }$   \n6: for $l \\in [ L ]$ do   \n7: Randomly sample a mini-batch of sentence pairs $( \\mathbf { x } ^ { l } , \\mathbf { y } ^ { l } )$ from $D ^ { l }$ .   \n8: if $f ^ { l } = = \\dot { T } r u e$ do   \n9: Compute and accumulate the gradient on loss $\\mathcal { L } _ { \\mathrm { A L L } } ( ( \\mathbf { x } ^ { l } , \\mathbf { y } ^ { l } ) ; \\theta _ { M } , \\theta _ { I } ^ { l } )$ : $g + = \\partial \\mathcal { L } _ { \\mathrm { A L L } } / \\partial \\theta _ { M }$ .   \n10: else   \n11: Compute and accumulate the gradient on loss $\\mathcal { L } _ { \\mathrm { N L L } } \\big ( ( \\mathbf { x } ^ { l } , \\mathbf { y } ^ { l } ) ; \\theta _ { M } \\big )$ : $g + = \\partial \\mathcal { L } _ { \\mathrm { N L L } } / \\partial \\theta _ { M }$ .   \n12: end if   \n13: end for   \n14: Update $\\theta _ { M }$ : $\\theta _ { M } = \\theta _ { M } - \\eta * g$   \n15: if $T \\% \\ T _ { \\mathrm { c h e c k } } = = 0$ do   \n16: for $l \\in [ L ]$ do   \n17: if Accuracy(θM ) < Accuracy $( \\theta _ { I } ^ { l } ) + \\tau$ do $f ^ { l } = T r u e$ else $f ^ { l } =$ False end if   \n18: end for   \n19: end if   \n20: end while ",
+        "bbox": [
+            176,
+            590,
+            825,
+            912
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.3 DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            302,
+            117
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Selective Distillation Considering that distillation from a bad teacher model is likely to hurt the student model and thus result in inferior accuracy, we selectively use distillation in the training process, as shown in Line 15-19 in Algorithm 1. When the accuracy of multilingual model surpasses the individual model for the accuracy threshold $\\tau$ on a certain language pair, we remove the distillation loss and just train the model with original negative log-likelihood loss for this pair. Note that in one iteration, one language may not uses the distillation loss; it is very likely in later iterations that this language will be distilled again since the multilingual model may become worse than the teacher model for this language. Therefore, we call this mechanism as selective distillation. We also verify the effectiveness of the selective distillation in experiment part (Section 4.3). ",
+        "bbox": [
+            174,
+            131,
+            825,
+            256
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Top-K Distillation It is burdensome to load all the teacher models in the GPU memory for distillation considering there are dozens or even hundreds of language pairs in the multilingual setting. Alternatively, we first generate the output probability distribution of each teacher model for the sentence pairs offline, and then just load the top-K probabilities of the distribution into memory and normalize them so that they sum to 1 for distillation. This can reduce the memory cost again from the scale of $| V |$ (the vocabulary size) to K. We also study in Section 4.3 that top-K distribution can result in comparable or better distillation accuracy than the full distribution. ",
+        "bbox": [
+            174,
+            272,
+            825,
+            371
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            393,
+            326,
+            409
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We test our proposed method on three public datasets: IWSLT, WMT, and Ted talk translation tasks.   \nWe first describe experimental settings, report results, and conduct some analyses on our method. ",
+        "bbox": [
+            174,
+            425,
+            823,
+            454
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 SETTINGS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            473,
+            284,
+            487
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Datasets We use three datasets in our experiment. IWSLT: We collect 12 languages English translation pairs from IWSLT evaluation campaign2 from year 2014 to 2016. WMT: We collect 6 languages English translation pairs from WMT translation task3. Ted Talk: We use the common corpus of TED talk which contains translations between multiple languages (Ye et al., 2018). We select 44 languages in this corpus that has sufficient data for our experiments. More descriptions about the three datasets can be found in Appendix (Section 1). We also list the language code according to ISO-639-1 standard4 for the languages used in our experiments in Appendix (Section 2). All the sentences are first tokenized with moses tokenizer5 and then segmented into subword symbols using Byte Pair Encoding (BPE) (Sennrich et al., 2016). We learn the BPE merge operations across all the languages and keep the output vocabulary of the teacher and student model the same, to ensure knowledge distillation. ",
+        "bbox": [
+            174,
+            500,
+            825,
+            652
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Model Configurations We use the Transformer (Vaswani et al., 2017) as the basic NMT model structure since it achieves state-of-the-art accuracy and becomes a popular choice for recent NMT researches. We use the same model configuration for individual models and the multilingual model. For IWSLT and Ted talk tasks, the model hidden size $d _ { \\mathrm { m o d e l } }$ , feed-forward hidden size $d _ { \\mathrm { f f } }$ , number of layer are 256, 1024 and 2, while for WMT task, the three parameters are 512, 2048 and 6 respectively considering its large scale of training data. ",
+        "bbox": [
+            174,
+            670,
+            825,
+            753
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Training and Inference For the multilingual model training, we up sample the data of each language to make all languages have the same size of data. The mini batch size is set to roughly 8192 tokens. We train the individual models with 4 NVIDIA Tesla V100 GPU cards and multilingual models with 8 of them. We follow the default parameters of Adam optimizer (Kingma & Ba, 2014) and learning rate schedule in Vaswani et al. (2017). For the individual models, we use 0.2 dropout, while for multilingual models, we use 0.1 dropout according to the validation performance. For knowledge distillation, we set $\\mathcal { T } _ { \\mathrm { c h e c k } } = 3 0 0 0$ steps (nearly two training epochs), the accuracy threshold $\\tau = 1$ BLEU score, the distillation coefficient $\\lambda = 0 . 5$ and the number of teacher’s outputs $K = 8$ according to the validation performance. During inference, we decode with beam search and set beam size to 4 and length penalty $\\alpha = 1 . 0$ for all the languages. We evaluate the translation quality by tokenized case sensitive BLEU (Papineni et al., 2002) with multi-bleu.pl6. Our codes are implemented based on fairseq7 and we will release the codes once the paper is published. ",
+        "bbox": [
+            174,
+            771,
+            825,
+            854
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            188
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/f97f47348a1a9e624638458e36d561252c8a01eec1f6564f47e4322bcffd6020.jpg",
+        "table_caption": [
+            "Table 1: BLEU scores of 12 languages English on the IWLST dataset. The BLEU scores in () represent the difference between the multilingual model and individual models. $\\Delta$ represents the improvements of our multi-distillation method over the multi-baseline. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Language</td><td>Individual</td><td>Multi-Baseline</td><td>Multi-Distillation</td><td>△</td></tr><tr><td>Ar→En</td><td>31.19</td><td>29.24 (-1.95)</td><td>31.25 (+0.06)</td><td>+2.01</td></tr><tr><td>Cs-→En</td><td>28.04</td><td>26.09 (-1.95)</td><td>27.09 (-0.95)</td><td>+1.00</td></tr><tr><td>De→En</td><td>33.07</td><td>32.74 (-0.33)</td><td>34.02 (+0.95)</td><td>+1.28</td></tr><tr><td>He-→En</td><td>37.42</td><td>35.18 (-2.24)</td><td>37.33 (-0.09)</td><td>+2.15</td></tr><tr><td>N1-→En</td><td>35.94</td><td>36.54 (+0.60)</td><td>37.69 (+1.75)</td><td>+1.15</td></tr><tr><td>Pt-→En</td><td>44.30</td><td>43.49 (-0.81)</td><td>44.69 (+0.39)</td><td>+1.20</td></tr><tr><td>Ro-→En</td><td>36.92</td><td>36.41 1 (-0.51)</td><td>38.01 (+1.09)</td><td>+1.60</td></tr><tr><td>Ru→En</td><td>23.04</td><td>23.12 (+0.08)</td><td>23.76 (+0.72)</td><td>+0.64</td></tr><tr><td>Th→En</td><td>18.24</td><td>19.33 3 (+1.09)</td><td>19.90 (+1.66)</td><td>+0.57</td></tr><tr><td>Tr→En</td><td>22.74</td><td>22.42 (-0.32)</td><td>23.75 (+1.01)</td><td>+1.33</td></tr><tr><td>Vi→En</td><td>26.06</td><td>26.37 (+0.31)</td><td>27.04 4 (+0.98)</td><td>+0.67</td></tr><tr><td>Zh→En</td><td>19.44</td><td>18.82 2 (-0.62)</td><td>19.52 (+0.08)</td><td>+0.70</td></tr></table>",
+        "bbox": [
+            236,
+            199,
+            761,
+            378
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/197ae6ebf249d157f37aa1475bb473851b9517549e62e217f46a89e238c400a0.jpg",
+        "table_caption": [
+            "Table 2: BLEU scores of English $ 1 2$ languages on the IWLST dataset. The BLEU scores in () represent the difference between the multilingual model and individual models. $\\Delta$ represents the improvements of our multi-distillation method over the multi-baseline. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Language</td><td>Individual</td><td>Multi-Baseline</td><td>Multi-Distillation</td><td>△</td></tr><tr><td>En→Ar</td><td>13.67</td><td>12.73 (-0.94)</td><td>13.80 (+0.13)</td><td>+1.07</td></tr><tr><td>En→Cs</td><td>17.81</td><td>17.33 (-0.48)</td><td>18.69 (+0.88)</td><td>+1.37</td></tr><tr><td>En→De</td><td>26.13</td><td>25.16 (-0.97)</td><td>26.76 (+0.63)</td><td>+1.60</td></tr><tr><td>En→He</td><td>24.15</td><td>22.73 (-1.42)</td><td>24.42 (+0.27)</td><td>+1.69</td></tr><tr><td>En-→Nl</td><td>30.88</td><td>29.51 (-1.37)</td><td>30.52 (-0.36)</td><td>+1.01</td></tr><tr><td>En→Pt</td><td>37.63</td><td>35.93 (-1.70)</td><td>37.23 (-0.40)</td><td>+1.30</td></tr><tr><td>En→Ro</td><td>27.23</td><td>25.68 (-1.55)</td><td>27.11 (-0.12)</td><td>+1.42</td></tr><tr><td>En→Ru</td><td>17.40</td><td>16.26 (-1.14)</td><td>17.42 (+0.02)</td><td>+1.16</td></tr><tr><td>En→Th</td><td>26.45</td><td>27.18 (+0.73)</td><td>27.62 (+1.17)</td><td>+0.45</td></tr><tr><td>En→Tr</td><td>12.47</td><td>11.63 (-0.84)</td><td>12.84 (+0.37)</td><td>+1.21</td></tr><tr><td>En→Vi</td><td>27.88</td><td>28.04 (+0.16)</td><td>28.69 (+0.81)</td><td>+0.65</td></tr><tr><td>En→Zh</td><td>10.95</td><td>10.12 (-0.83)</td><td>10.41 (-0.54)</td><td>+0.29</td></tr></table>",
+        "bbox": [
+            236,
+            450,
+            761,
+            631
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            708,
+            277,
+            722
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Results on IWSLT Multilingual NMT usually consists of three settings: many-to-one, one-tomany and many-to-many. As many-many translation can be bridged though many-to-one and oneto-many setting, we just conduct the experiments on many-to-one and one-to-many settings. We first show the results of 12 languages English translations on the IWLST dataset are shown in Table 1. There are 3 methods for comparison: 1) Individual, each language pair with a separate model; 2) Multi-Baseline, the baseline multilingual model, simply training all the language pairs in one model; 3) Multi-Distillation, our multilingual model with knowledge distillation. We have several observations. First, the multilingual baseline performs worse than individual models on most languages. The only exception is the languages with small training data, which benefit from data augmentation in multilingual training. Second, our method outperforms the multilingual baseline for all the languages, demonstrating the effectiveness of our framework for multilingual NMT. More importantly, compared with the individual models, our method achieves similar or even better accuracy (better on 10 out of 12 languages), with only $1 / 1 2$ model parameters of the sum of all individual models. ",
+        "bbox": [
+            173,
+            733,
+            825,
+            887
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "One-to-many setting is usually considered as more difficult than many-to-one setting, as it contains different target languages which is hard to handle. Here we show how our method performs in oneto-many setting in Table 2. It can be seen that our method can maintain the accuracy (even better on most languages) compared with the individual models. We still improve over the multilingual baseline by nearly 1 BLEU score, which demonstrates the effectiveness of our method. ",
+        "bbox": [
+            174,
+            138,
+            823,
+            209
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/1e6b0fc5298c46bd676cdfc3a200da9ed2ac5bb7b160bee7f11c50f69406505d.jpg",
+        "table_caption": [
+            "Table 3: BLEU scores of 6 languages English on the WMT dataset. The BLEU scores in () represent the difference between the multilingual model and individual models. $\\Delta$ represents the improvements of our multi-distillation method over the multi-baseline. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Language</td><td>Individual</td><td>Multi-Baseline</td><td>Multi-Distillation</td><td>△</td></tr><tr><td>Cs-En</td><td>25.29</td><td>23.82 (-1.47)</td><td>25.37 (+0.08)</td><td>+1.55</td></tr><tr><td>De-En</td><td>34.44</td><td>34.21 (-0.23)</td><td>36.22 (+1.78)</td><td>+2.01</td></tr><tr><td>Fi-En</td><td>21.23</td><td>22.99 (+1.76)</td><td>24.32 (+3.09)</td><td>+1.33</td></tr><tr><td>Lv-En</td><td>16.26</td><td>16.25 (-0.01)</td><td>18.43 (+2.17)</td><td>+2.18</td></tr><tr><td>Ro-En</td><td>35.81</td><td>35.04 (-0.77)</td><td>36.51 (+0.70)</td><td>+1.47</td></tr><tr><td>Ru-En</td><td>29.39</td><td>28.92 (-0.47)</td><td>30.82 (+1.43)</td><td>+1.90</td></tr></table>",
+        "bbox": [
+            236,
+            223,
+            761,
+            328
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/5bc038732651465854e4327de5f088fdabda8f9db3965080476f0f77dcb1c196.jpg",
+        "table_caption": [
+            "Table 4: BLEU scores of English $ 6$ languages on the WMT dataset. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Language</td><td>Individual</td><td>Multi-Baseline</td><td>Multi-Distillation</td><td>△</td></tr><tr><td>En-Cs</td><td>22.58</td><td>21.39 (-1.19)</td><td>23.10 (+0.62)</td><td>+1.81</td></tr><tr><td>En-De</td><td>31.40</td><td>30.08 3 (-1.32)</td><td>31.42 (+0.02)</td><td>+1.34</td></tr><tr><td>En-Fi</td><td>22.08</td><td>19.52 (-2.56)</td><td>21.56 (-0.52)</td><td>+2.04</td></tr><tr><td>En-Lv</td><td>14.92</td><td>14.51 (-0.41)</td><td>15.32 (+0.40)</td><td>+0.81</td></tr><tr><td>En-Ro</td><td>31.67</td><td>29.88 (-1.79)</td><td>31.39 (-0.28)</td><td>+1.51</td></tr><tr><td>En-Ru</td><td>24.36</td><td>22.96 (-1.40)</td><td>24.02 (-0.34)</td><td>+1.06</td></tr></table>",
+        "bbox": [
+            236,
+            405,
+            761,
+            511
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Results on WMT The results of 6 languages English translations on the WMT dataset are reported in Table 3. It can be seen that the multi-baseline model performs worse than the individual models on 5 out of 6 languages, while in contrast, our method performs better on all the 6 languages. Particularly, our method improves the accuracy of some languages with more than 2 BLEU scores over individual models. The results of one-to-many setting on WMT dataset are reported in Table 4. It can be seen that our method outperforms the multilingual baseline by more than 1 BLEU score on nearly all the languages. ",
+        "bbox": [
+            173,
+            563,
+            825,
+            661
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/1b347e2be1d6fa12f6cd5a1f003e3a4a6d4d62c2e8358b2136ae3c4e73381b74.jpg",
+        "table_caption": [
+            "Table 5: BLEU scores improvements of our method over the individual models $( \\Delta _ { 1 } )$ and multibaseline model $\\left( \\Delta _ { 2 } \\right)$ on the 44 languages English in the Ted talk dataset. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Language</td><td>Ar</td><td>Bg</td><td>Cs</td><td>Da</td><td>De</td><td>E1</td><td>Es</td><td>Et</td><td>Fa</td><td>Fi</td><td>Frca</td></tr><tr><td>△1</td><td>-1.50</td><td>-9.46</td><td>1.88</td><td>4.02</td><td>-0.10</td><td>0.80</td><td>0.23</td><td>8.20</td><td>0.09</td><td>6.44</td><td>15.8</td></tr><tr><td>△2</td><td>1.73</td><td>1.42</td><td>1.13</td><td>1.82</td><td>1.68</td><td>1.45</td><td>1.63</td><td>0.77</td><td>1.83</td><td>1.10</td><td>1.24</td></tr><tr><td>Language</td><td>Fr</td><td>Gl</td><td>He</td><td>Hi</td><td>Hr</td><td>Hu</td><td>Hy</td><td>Id</td><td>It</td><td>Ja</td><td>Ka</td></tr><tr><td>△1</td><td>0.13</td><td>19.26</td><td>-1.59</td><td>10.16</td><td>1.46</td><td>-0.11</td><td>8.87</td><td>1.36</td><td>-0.56</td><td>-0.03</td><td>11.20</td></tr><tr><td>△2</td><td>1.48</td><td>1.58</td><td>2.26</td><td>1.07</td><td>1.21</td><td>1.80</td><td>0.92</td><td>1.48</td><td>1.48</td><td>0.95</td><td>1.55</td></tr><tr><td>Language</td><td>Ko</td><td>Ku</td><td>Lt</td><td>Mk</td><td>My</td><td>Nb</td><td>N1</td><td>PI</td><td>Ptbr</td><td>Pt</td><td>Ro</td></tr><tr><td>△1</td><td>-0.42</td><td>7.75</td><td>4.46</td><td>10.72</td><td>7.63</td><td>14.07</td><td>-0.20</td><td>1.32</td><td>0.13</td><td>8.76</td><td>0.66</td></tr><tr><td>△2</td><td>1.43</td><td>1.55</td><td>1.69</td><td>0.80</td><td>1.31</td><td>1.47</td><td>1.68</td><td>0.80</td><td>1.45</td><td>1.98</td><td>1.70</td></tr><tr><td>Language</td><td>Ru</td><td>Sk</td><td>S1</td><td>Sq</td><td>Sr</td><td>Sv</td><td>Th</td><td>Tr</td><td>Uk</td><td>Vi</td><td>Zh</td></tr><tr><td>△1</td><td>0.65</td><td>4.23</td><td>11.87</td><td>5.03</td><td>1.58</td><td>2.39</td><td>1.17</td><td>-0.79</td><td>2.04</td><td>0.15</td><td>6.83</td></tr><tr><td>△2</td><td>0.99</td><td>0.93</td><td>1.15</td><td>1.68</td><td>1.44</td><td>1.00</td><td>0.62</td><td>1.88</td><td>0.98</td><td>0.77</td><td>0.58</td></tr></table>",
+        "bbox": [
+            176,
+            676,
+            823,
+            872
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Results on Ted Talk Now we study the effectiveness of our method on a large number of languages. The experiments are conducted on the 44 languages English on the Ted talk dataset. Due to the large number of languages and space limitations, we just show the BLEU score improvements of our method over individual models and the multi-baseline for each language in Table 5, and leave the detailed experiment results to Appendix (Section 3). It can be seen that our method can improve over the multi-baseline for all the languages, mostly with more than 1 BLEU score improvements. Our method can also match or even surpass individual models for most languages, not to mention that the number of parameters of our method is only $1 / 4 4$ of that of the sum of 44 individual models. Our method achieves larger improvements on some languages, such as Da, Et, Fi, Hi and Hy, than others. We find this is correlated with the data size of the languages, which are listed in Appendix (Table 13). When a language is of smaller data size, it may get more improvement due to the benefit of multilingual training. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            270
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.3 ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            287,
+            285,
+            301
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this section, we conduct thorough analyses on our proposed method for multilingual NMT. ",
+        "bbox": [
+            173,
+            313,
+            784,
+            328
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Selective Distillation We study the effectiveness of the selective distillation (discussed in Section 3.3) on the Ted talk dataset, as shown in Table 6. We list the 16 languages on which the two methods (selective distillation, and distillation all the time) that have difference bigger than 0.5 in terms of BLEU score. It can be seen that selective distillation performs better on 13 out of 16 languages, with large BLEU score improvements, which demonstrates the effectiveness of the selective distillation. ",
+        "bbox": [
+            173,
+            342,
+            825,
+            426
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/3a715b2a40f4460b47ec408829bd4ccc96a718d67db48ddb1bcc3862b35d54a3.jpg",
+        "table_caption": [
+            "Table 6: BLEU scores of selective distillation (our method) and distillation all the time during the training process on the Ted talk dataset. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>Bg</td><td>Et</td><td>Fi</td><td>Fr</td><td>Gl</td><td>Hi</td><td>Hy</td><td>Ka</td></tr><tr><td>distillation all the time</td><td>28.07</td><td>12.64</td><td>15.13</td><td>33.69</td><td>30.28</td><td>18.86</td><td>19.88</td><td>14.04</td></tr><tr><td>selective distillation</td><td>29.18</td><td>15.63</td><td>17.23</td><td>34.32</td><td>31.90</td><td>21.00</td><td>21.17</td><td>18.27</td></tr><tr><td>△</td><td>+1.11</td><td>+2.99</td><td>+2.10</td><td>+0.63</td><td>+1.62</td><td>+2.14</td><td>+1.29</td><td>+4.23</td></tr><tr><td></td><td>Ku</td><td>Mk</td><td>My</td><td>SI</td><td>Zh</td><td>Pl</td><td>Sk</td><td>Sv</td></tr><tr><td>distillation all the time</td><td>8.50</td><td>32.10</td><td>14.02</td><td>22.10</td><td>17.22</td><td>25.05</td><td>30.45</td><td>37.88</td></tr><tr><td>selective distillation</td><td>13.38</td><td>32.65</td><td>15.17</td><td>23.68</td><td>19.39</td><td>24.30</td><td>29.91</td><td>36.92</td></tr><tr><td>△</td><td>+4.88</td><td>+0.55</td><td>+1.15</td><td>+1.58</td><td>+2.17</td><td>-0.75</td><td>-0.54</td><td>-0.96</td></tr></table>",
+        "bbox": [
+            196,
+            435,
+            802,
+            575
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Top-K Distillation In our experiments, the student model just matches the top-K output distribution of the teacher model, instead of the full distribution, in order to reduce the memory cost. We analyze whether there is accuracy difference between the top- $\\mathbf { \\nabla } \\cdot \\mathbf { K }$ distribution and the full distribution. We conduct experiments on IWSLT dataset with varying $K$ (from 1 to $| V |$ , where $| V |$ is the vocabulary size), and just show the BLEU scores on the validation set of De-En translation due to space limitation, as illustrated in Table 7. It can be seen that increasing $K$ from 1 to 8 will improve the accuracy, while bigger $K$ will bring no gains, even with the full distribution $( K = | V | )$ ). ",
+        "bbox": [
+            174,
+            640,
+            825,
+            738
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/50d1aa22538b09e0bfcdb55867b96821be9bce9f851a73c00e2ed5ce1289d43f.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Top-K</td><td>1</td><td>2</td><td>4</td><td>8</td><td>16</td><td>32</td><td>64</td><td>128</td><td>IVI</td></tr><tr><td>BLEU</td><td>33.45</td><td>33.86</td><td>34.47</td><td>34.76</td><td>34.66</td><td>34.68</td><td>34.54</td><td>34.47</td><td>34.49</td></tr></table>",
+        "bbox": [
+            222,
+            751,
+            779,
+            792
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 7: BLEU scores on De-En translation with varying Top-K distillation on the IWSLT dataset. ",
+        "bbox": [
+            178,
+            803,
+            818,
+            818
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Back Distillation In our current distillation algorithm, we fix the individual models and use them to teach and improve the multilingual model. After such a distillation process, the multilingual model outperforms the individual models on most of the languages. Then naturally, we may wonder whether this improved multilingual model can further be used to teach and improve individual models through knowledge distillation. We call such a process back distillation. We conduct the experiments on the IWSLT dataset, and find that the accuracy of 9 out of 12 languages gets improved, as shown in Table 10. The other 3 languages (He, Pt, Zh) cannot get improvements because the improved multilingual model performs very close to individual models, as shown in Table 1. ",
+        "bbox": [
+            173,
+            839,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/e496db88ba87864dc1365cf9a64865225114731f3fe10468f2e835f31548fb65.jpg",
+        "table_caption": [
+            "Table 8: BLEU score improvements of the individual models with back distillation on the IWSLT dataset. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Language</td><td>Ar</td><td>Cs</td><td>De</td><td>N1</td><td>Ro</td><td>Ru</td><td>Th</td><td>Tr</td><td>Vi</td></tr><tr><td>Individual</td><td>31.19</td><td>28.04</td><td>33.07</td><td>35.94</td><td>36.92</td><td>23.04</td><td>18.24</td><td>22.74</td><td>26.06</td></tr><tr><td>+Back Distillation</td><td>31.39</td><td>29.44</td><td>33.71</td><td>36.86</td><td>37.28</td><td>23.36</td><td>19.42</td><td>23.58</td><td>27.17</td></tr><tr><td>△</td><td>+0.20</td><td>+1.40</td><td>+0.64</td><td>+0.92</td><td>+0.36</td><td>+0.32</td><td>+1.18</td><td>+0.84</td><td>+1.11</td></tr></table>",
+        "bbox": [
+            191,
+            101,
+            807,
+            174
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            239,
+            823,
+            270
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Comparison with Sequence-Level Knowledge Distillation We conduct experiments to compare the word-level knowledge distillation (the exact method used in our paper) with sequence-level knowledge distillation(Kim & Rush, 2016b) on IWSLT dataset. As shown in Table 9, sequencelevel knowledge distillation results in consistently inferior accuracy on all languages compared with word-level knowledge distillation used in our work. ",
+        "bbox": [
+            176,
+            285,
+            823,
+            356
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/bd9f4cf042d8def04a67cb36daabcaa14298bbf7a002e581cff79b7220fb6159.jpg",
+        "table_caption": [
+            "Table 9: BLEU scores of sequence-level knowledge distillation and word-level knowledge distillation on the IWSLT dataset. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Language</td><td>Sequence-level</td><td>Word-level (OurMethod)</td><td>△</td></tr><tr><td>En-Ar</td><td>12.79</td><td>13.80</td><td>1.01</td></tr><tr><td>En-Cs</td><td>17.01</td><td>18.69</td><td>1.68</td></tr><tr><td>En-De</td><td>25.89</td><td>26.76</td><td>0.87</td></tr><tr><td>En-He</td><td>22.92</td><td>24.42</td><td>1.50</td></tr><tr><td>En-N1</td><td>29.99</td><td>30.52</td><td>0.53</td></tr><tr><td>En-Pt</td><td>36.12</td><td>37.23</td><td>1.10</td></tr><tr><td>En-Ro</td><td>25.75</td><td>27.11</td><td>1.36</td></tr><tr><td>En-Ru</td><td>16.38</td><td>17.42</td><td>1.04</td></tr><tr><td>En-Th</td><td>27.52</td><td>27.62</td><td>0.10</td></tr><tr><td>En-Tr</td><td>11.11</td><td>12.84</td><td>1.73</td></tr><tr><td>En-Vi</td><td>28.08</td><td>28.69</td><td>0.61</td></tr><tr><td>En-Zh</td><td>10.25</td><td>10.41</td><td>0.16</td></tr></table>",
+        "bbox": [
+            295,
+            369,
+            700,
+            549
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/434d9dacbb2892277bb6dda4e244d8ecf4ec07d242ba36134ec8c699e3034d0d.jpg",
+        "table_caption": [
+            "Table 10: BLEU score improvements of the individual models with back distillation on the IWSLT dataset. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Language</td><td>Ar</td><td>Cs</td><td>De</td><td>N1</td><td>Ro</td><td>Ru</td><td>Th</td><td>Tr</td><td>Vi</td></tr><tr><td>Individual</td><td>31.19</td><td>28.04</td><td>33.07</td><td>35.94</td><td>36.92</td><td>23.04</td><td>18.24</td><td>22.74</td><td>26.06</td></tr><tr><td>+Back Distillation</td><td>31.39</td><td>29.44</td><td>33.71</td><td>36.86</td><td>37.28</td><td>23.36</td><td>19.42</td><td>23.58</td><td>27.17</td></tr><tr><td>△</td><td>+0.20</td><td>+1.40</td><td>+0.64</td><td>+0.92</td><td>+0.36</td><td>+0.32</td><td>+1.18</td><td>+0.84</td><td>+1.11</td></tr></table>",
+        "bbox": [
+            191,
+            611,
+            807,
+            685
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Generalization Analysis Previous works (Yang et al., 2018; Lan et al., 2018) have shown that knowledge distillation can help a model generalize well to unseen data, and thus yield better performance. We analyze how distillation in multilingual setting helps the model generalization. Previous studies (Keskar et al., 2016; Chaudhari et al., 2016) demonstrate the relationship between model generalization and the width of local minima in loss surface. Wider local minima can make the model more robust to small perturbations in testing. Therefore, we compare the generalization capability of the two multilingual models (our method and the baseline) by perturbing their parameters. ",
+        "bbox": [
+            173,
+            750,
+            825,
+            848
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Specifically, we perturb a model $\\theta$ as $\\theta _ { i } ( \\sigma ) = \\theta _ { i } + \\bar { \\theta } * \\mathcal { N } ( 0 , \\sigma ^ { 2 } )$ , where $\\theta _ { i }$ is the $i$ -th parameter of the model, $\\bar { \\theta }$ is the average of all the parameters in $\\theta$ . We sample from the normal distribution $\\mathcal { N }$ with standard variance $\\sigma$ and larger $\\sigma$ represents bigger perturbation on the parameter. We conduct the analyses on the IWSLT dataset and vary $\\sigma \\in [ 0 . 0 5 , 0 . 1 , 0 . 1 5 , 0 . 2 , 0 . 2 5 , 0 . 3$ ]. Figure 1a shows the loss curve in the test set with varying $\\sigma$ . As can be seen, while both the two losses increase with the increase of $\\sigma$ , the loss of the baseline model increases quicker than our method. We also show three test BLEU curves on three translation pairs (Figure 1b: Ar-En, Figure 1c: Cs-En, Figure 1d: De-En, which are randomly picked from the 12 languages pairs on the IWSLT dataset). We observe that the BLEU score of the multilingual baseline drops quicker than our method, which demonstrates that our method helps the model find wider local minima and thus generalize better. ",
+        "bbox": [
+            174,
+            853,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/5e02a344e3254dec9e37d9982da94e1ca6d77df15f37ee1394cba78a00a0cd7a.jpg",
+        "image_caption": [
+            "Figure 1: The loss (Figure a) and BLEU score (Figure b: Ar-En, Figure c: Cs-En, Figure d: De-En) changes on the test set of the IWSLT dataset, with varying perturbation parameter $\\sigma$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            187,
+            186,
+            810,
+            358
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            426,
+            318,
+            441
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this work, we have proposed a distillation-based approach to boost the accuracy of multilingual NMT, which is usually of lower accuracy than the individual models in previous works. Experiments on three translation datasets with up to 44 languages demonstrate the multilingual model based on our proposed method can nearly match or even outperform the individual models, with just $1 / N$ model parameters (N is up to 44 in our experiments). ",
+        "bbox": [
+            174,
+            457,
+            825,
+            526
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In the future, we will conduct more deep analyses about how distillation helps the multilingual model training. We will apply our method to larger datasets and more languages pairs (hundreds or even thousands), to study the upper limit of our proposed method. ",
+        "bbox": [
+            174,
+            534,
+            825,
+            577
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            597,
+            285,
+            611
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Rohan Anil, Gabriel Pereyra, Alexandre Passos, Robert Ormandi, George E Dahl, and Geoffrey E Hinton. Large scale distributed neural network training through online distillation. arXiv preprint arXiv:1804.03235, 2018.   \nDzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. ICLR 2015, 2015.   \nCristian Bucilu, Rich Caruana, and Alexandru Niculescu-Mizil. Model compression. In Proceedings of the 12th ACM SIGKDD international conference on Knowledge discovery and data mining, pp. 535–541. ACM, 2006.   \nPratik Chaudhari, Anna Choromanska, Stefano Soatto, Yann LeCun, Carlo Baldassi, Christian Borgs, Jennifer Chayes, Levent Sagun, and Riccardo Zecchina. Entropy-sgd: Biasing gradient descent into wide valleys. arXiv preprint arXiv:1611.01838, 2016.   \nDaxiang Dong, Hua Wu, Wei He, Dianhai Yu, and Haifeng Wang. Multi-task learning for multiple language translation. In Proceedings of the 53rd Annual Meeting of the Association for Computational Linguistics and the 7th International Joint Conference on Natural Language Processing (Volume 1: Long Papers), volume 1, pp. 1723–1732, 2015.   \nOrhan Firat, Kyunghyun Cho, and Yoshua Bengio. Multi-way, multilingual neural machine translation with a shared attention mechanism. In NAACL HLT 2016, The 2016 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, San Diego California, USA, June 12-17, 2016, pp. 866–875, 2016. ",
+        "bbox": [
+            171,
+            618,
+            826,
+            926
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Markus Freitag, Yaser Al-Onaizan, and Baskaran Sankaran. Ensemble distillation for neural machine translation. arXiv preprint arXiv:1702.01802, 2017. ",
+        "bbox": [
+            169,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tommaso Furlanello, Zachary C Lipton, Michael Tschannen, Laurent Itti, and Anima Anandkumar. Born again neural networks. arXiv preprint arXiv:1805.04770, 2018. ",
+        "bbox": [
+            171,
+            141,
+            823,
+            171
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jonas Gehring, Michael Auli, David Grangier, Denis Yarats, and Yann N. Dauphin. Convolutional sequence to sequence learning. In Proceedings of the 34th International Conference on Machine Learning, ICML 2017, Sydney, NSW, Australia, 6-11 August 2017, pp. 1243–1252, 2017. ",
+        "bbox": [
+            176,
+            179,
+            823,
+            223
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Chengyue Gong, Xu Tan, Di He, and Tao Qin. Sentence-wise smooth regularization for sequence to sequence learning. In AAAI, 2018. ",
+        "bbox": [
+            173,
+            232,
+            821,
+            261
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jiatao Gu, Hany Hassan, Jacob Devlin, and Victor O. K. Li. Universal neural machine translation for extremely low resource languages. In NAACL-HLT 2018, New Orleans, Louisiana, USA, June 1-6, 2018, Volume 1 (Long Papers), pp. 344–354, 2018a. ",
+        "bbox": [
+            171,
+            270,
+            826,
+            314
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jiatao Gu, Yong Wang, Yun Chen, Kyunghyun Cho, and Victor OK Li. Meta-learning for lowresource neural machine translation. arXiv preprint arXiv:1808.08437, 2018b. ",
+        "bbox": [
+            173,
+            321,
+            821,
+            352
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Junliang Guo, Xu Tan, Di He, Tao Qin, Linli Xu, and Tie-Yan Liu. Non-autoregressive neural machine translation with enhanced decoder input. In AAAI, 2018. ",
+        "bbox": [
+            173,
+            359,
+            823,
+            390
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Thanh-Le Ha, Jan Niehues, and Alexander H. Waibel. Toward multilingual neural machine translation with universal encoder and decoder. CoRR, abs/1611.04798, 2016. URL http: //arxiv.org/abs/1611.04798. ",
+        "bbox": [
+            173,
+            398,
+            826,
+            441
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Hany Hassan, Anthony Aue, Chang Chen, Vishal Chowdhary, Jonathan Clark, Christian Federmann, Xuedong Huang, Marcin Junczys-Dowmunt, William Lewis, Mu Li, Shujie Liu, Tie-Yan Liu, Renqian Luo, Arul Menezes, Tao Qin, Frank Seide, Xu Tan, Fei Tian, Lijun Wu, Shuangzhi Wu, Yingce Xia, Dongdong Zhang, Zhirui Zhang, and Ming Zhou. Achieving human parity on automatic chinese to english news translation. CoRR, abs/1803.05567, 2018. URL http: //arxiv.org/abs/1803.05567. ",
+        "bbox": [
+            173,
+            450,
+            825,
+            535
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tianyu He, Xu Tan, Yingce Xia, Di He, Tao Qin, Zhibo Chen, and Tie-Yan Liu. Layer-wise coordination between encoder and decoder for neural machine translation. In NIPS, pp. 7955–7965, 2018. ",
+        "bbox": [
+            173,
+            544,
+            825,
+            587
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Geoffrey Hinton, Oriol Vinyals, and Jeff Dean. Distilling the knowledge in a neural network. arXiv preprint arXiv:1503.02531, 2015. ",
+        "bbox": [
+            173,
+            595,
+            823,
+            626
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Melvin Johnson, Mike Schuster, Quoc V. Le, Maxim Krikun, Yonghui Wu, Zhifeng Chen, Nikhil Thorat, Fernanda B. Viegas, Martin Wattenberg, Greg Corrado, Macduff Hughes, and Jeffrey ´ Dean. Google’s multilingual neural machine translation system: Enabling zero-shot translation. TACL, 5:339–351, 2017. URL https://transacl.org/ojs/index.php/tacl/ article/view/1081. ",
+        "bbox": [
+            173,
+            633,
+            825,
+            705
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nitish Shirish Keskar, Dheevatsa Mudigere, Jorge Nocedal, Mikhail Smelyanskiy, and Ping Tak Peter Tang. On large-batch training for deep learning: Generalization gap and sharp minima. arXiv preprint arXiv:1609.04836, 2016. ",
+        "bbox": [
+            173,
+            714,
+            823,
+            757
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yoon Kim and Alexander M. Rush. Sequence-level knowledge distillation. In Proceedings of the 2016 Conference on Empirical Methods in Natural Language Processing, EMNLP 2016, Austin, Texas, USA, November 1-4, 2016, pp. 1317–1327, 2016a. ",
+        "bbox": [
+            174,
+            766,
+            823,
+            810
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yoon Kim and Alexander M Rush. Sequence-level knowledge distillation. arXiv preprint arXiv:1606.07947, 2016b. ",
+        "bbox": [
+            169,
+            818,
+            826,
+            848
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014. ",
+        "bbox": [
+            171,
+            857,
+            823,
+            886
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Xu Lan, Xiatian Zhu, and Shaogang Gong. Knowledge distillation by on-the-fly native ensemble. arXiv preprint arXiv:1806.04606, 2018. ",
+        "bbox": [
+            173,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yuncheng Li, Jianchao Yang, Yale Song, Liangliang Cao, Jiebo Luo, and Li-Jia Li. Learning from noisy labels with distillation. In ICCV, pp. 1928–1936, 2017. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            133
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yichao Lu, Phillip Keung, Faisal Ladhak, Vikas Bhardwaj, Shaonan Zhang, and Jason Sun. A neural interlingua for multilingual machine translation. CoRR, abs/1804.08198, 2018. URL http://arxiv.org/abs/1804.08198. ",
+        "bbox": [
+            176,
+            142,
+            820,
+            185
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Minh-Thang Luong, Quoc V. Le, Ilya Sutskever, Oriol Vinyals, and Lukasz Kaiser. Multi-task sequence to sequence learning. CoRR, abs/1511.06114, 2015a. URL http://arxiv.org/ abs/1511.06114. ",
+        "bbox": [
+            173,
+            195,
+            826,
+            238
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Thang Luong, Hieu Pham, and Christopher D. Manning. Effective approaches to attention-based neural machine translation. In Proceedings of the 2015 Conference on Empirical Methods in Natural Language Processing, EMNLP 2015, Lisbon, Portugal, September 17-21, 2015, pp. 1412– 1421, 2015b. ",
+        "bbox": [
+            173,
+            247,
+            825,
+            304
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Graham Neubig and Junjie Hu. Rapid adaptation of neural machine translation to new languages. arXiv preprint arXiv:1808.04189, 2018. ",
+        "bbox": [
+            171,
+            314,
+            823,
+            343
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Kishore Papineni, Salim Roukos, Todd Ward, and Wei-Jing Zhu. Bleu: a method for automatic evaluation of machine translation. In Proceedings of the 40th Annual Meeting of the Association for Computational Linguistics, July 6-12, 2002, Philadelphia, PA, USA., pp. 311–318, 2002. URL http://www.aclweb.org/anthology/P02-1040.pdf. ",
+        "bbox": [
+            173,
+            353,
+            825,
+            411
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Adriana Romero, Nicolas Ballas, Samira Ebrahimi Kahou, Antoine Chassang, Carlo Gatta, and Yoshua Bengio. Fitnets: Hints for thin deep nets. arXiv preprint arXiv:1412.6550, 2014. ",
+        "bbox": [
+            173,
+            420,
+            823,
+            449
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Rico Sennrich, Barry Haddow, and Alexandra Birch. Neural machine translation of rare words with subword units. In ACL 2016, August 7-12, 2016, Berlin, Germany, Volume 1: Long Papers, 2016. URL http://aclweb.org/anthology/P/P16/P16-1162.pdf. ",
+        "bbox": [
+            174,
+            459,
+            825,
+            502
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yanyao Shen, Xu Tan, Di He, Tao Qin, and Tie-Yan Liu. Dense information flow for neural machine translation. In NAACL, volume 1, pp. 1294–1303, 2018. ",
+        "bbox": [
+            174,
+            512,
+            823,
+            541
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Kaitao Song, Xu Tan, Di He, Jianfeng Lu, Tao Qin, and Tie-Yan Liu. Double path networks for sequence to sequence learning. In COLING, pp. 3064–3074, 2018. ",
+        "bbox": [
+            173,
+            550,
+            823,
+            580
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ilya Sutskever, Oriol Vinyals, and Quoc V. Le. Sequence to sequence learning with neural networks. In NIPS 2014, December 8-13 2014, Montreal, Quebec, Canada, pp. 3104–3112, 2014. ",
+        "bbox": [
+            169,
+            589,
+            823,
+            619
+        ],
+        "page_idx": 11
+    },
+    {
+        "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 NIPS 2017, 4-9 December 2017, Long Beach, CA, USA, pp. 6000–6010, 2017. ",
+        "bbox": [
+            174,
+            628,
+            823,
+            672
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Lijun Wu, Xu Tan, Di He, Fei Tian, Tao Qin, Jianhuang Lai, and Tie-Yan Liu. Beyond error propagation in neural machine translation: Characteristics of language also matter. In EMNLP, pp. 3602–3611, 2018. ",
+        "bbox": [
+            173,
+            681,
+            823,
+            724
+        ],
+        "page_idx": 11
+    },
+    {
+        "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. CoRR, abs/1609.08144, 2016. URL http://arxiv.org/abs/1609.08144. ",
+        "bbox": [
+            174,
+            734,
+            825,
+            833
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Chenglin Yang, Lingxi Xie, Siyuan Qiao, and Alan Yuille. Knowledge distillation in generations: More tolerant teachers educate better students. arXiv preprint arXiv:1805.05551, 2018. ",
+        "bbox": [
+            171,
+            842,
+            823,
+            871
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Qi Ye, Sachan Devendra, Felix Matthieu, Padmanabhan Sarguna, and Neubig Graham. When and why are pre-trained word embeddings useful for neural machine translation. In HLT-NAACL, 2018. ",
+        "bbox": [
+            174,
+            882,
+            825,
+            922
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Junho Yim, Donggyu Joo, Jihoon Bae, and Junmo Kim. A gift from knowledge distillation: Fast optimization, network minimization and transfer learning. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), volume 2, 2017. ",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Ying Zhang, Tao Xiang, Timothy M Hospedales, and Huchuan Lu. Deep mutual learning. arXiv preprint arXiv:1706.00384, 6, 2017. ",
+        "bbox": [
+            173,
+            155,
+            823,
+            183
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            264,
+            118
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "1 DATASET DESCRIPTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            135,
+            403,
+            151
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We give a detailed description about the IWSLT,WMT and Ted Talk datasets used in experiments. ",
+        "bbox": [
+            171,
+            165,
+            805,
+            180
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "IWSLT: We collect 12 languages English translation pairs from IWSLT evaluation campaign8 from year 2014 to 2016. Each language pair contains roughly 80K to 200K sentence pairs. We use the official validation and test sets for each language pair. The data sizes of the training set for each language English pair are listed in Table 11. ",
+        "bbox": [
+            174,
+            186,
+            825,
+            243
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/c03e6691604534996e6f5ac772ee9d52a46386363e82446498a61391212b920f.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Language</td><td>Ar</td><td>Cs</td><td>De</td><td>He</td><td>N1</td><td>Pt</td></tr><tr><td>Training Data</td><td>174K</td><td>114K</td><td>167K</td><td>180K</td><td>174K</td><td>167K</td></tr><tr><td>Language</td><td>Ro</td><td>Ru</td><td>Th</td><td>Tr</td><td>Vi</td><td>Zh</td></tr><tr><td>Training Data</td><td>177K</td><td>173K</td><td>83K</td><td>150K</td><td>131K</td><td>209K</td></tr></table>",
+        "bbox": [
+            289,
+            253,
+            709,
+            332
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Table 11: The training data size on the 12 languages English on the IWSLT dataset. ",
+        "bbox": [
+            217,
+            340,
+            779,
+            356
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "WMT: We collect 6 languages English translation pairs from WMT translation task9. We use 5 language English translation pairs from WMT 2016 dataset: Cs-En, De-En, Fi-En, Ro-En, RuEn and one other translation pair from WMT 2017 dataset: Lv-En. We use the official released validation and test sets for each language pair. The training data sizes of each language English pair are shown in the Table 12. ",
+        "bbox": [
+            173,
+            369,
+            826,
+            439
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/c5ffc0cd70615b977bdc69f9b923c93a944d372f80e98a031e985bc0f177dc79.jpg",
+        "table_caption": [
+            "Table 12: The training data size on the 6 languages English on the WMT dataset. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Language</td><td>Cs</td><td>De</td><td>Fi</td><td>Lv</td><td>Ro</td><td>Ru</td></tr><tr><td>Training Data</td><td>1.0M</td><td>4.5M</td><td>2.5M</td><td>4.5M</td><td>2.2M</td><td>2.1M</td></tr></table>",
+        "bbox": [
+            292,
+            450,
+            704,
+            493
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Ted Talk: We use the common corpus of TED talk which contains translations between multiple languages (Ye et al., 2018)10. We select 44 languages in this corpus that has sufficient data for our experiments. We use the official validation and test sets for each language pair. The data sizes of the training set for each language English pair are listed in Table 13. ",
+        "bbox": [
+            173,
+            531,
+            826,
+            588
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/46e89d9b78b5e8969ab45f89aa283a9d330eaff05c618bad1c7ebfebf4396610.jpg",
+        "table_caption": [
+            "Table 13: The training data size on the 44 languages English on the Ted talk dataset. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Language</td><td>Ar</td><td>Bg</td><td>Cs</td><td>Da</td><td>De</td><td>E1</td><td>Es</td><td>Et</td><td>Fa</td><td>Fi</td><td>Frca</td></tr><tr><td>Training Data</td><td>214K</td><td>174k</td><td>103k</td><td>45k</td><td>168k</td><td>134k</td><td>196k</td><td>11k</td><td>151k</td><td>24k</td><td>20k</td></tr><tr><td>Language</td><td>Fr</td><td>Gl</td><td>He</td><td>Hi</td><td>Hr</td><td>Hu</td><td>Hy</td><td>Id</td><td>It</td><td>Ja</td><td>Ka</td></tr><tr><td>Training Data</td><td>192K</td><td>10K</td><td>212K</td><td>19K</td><td>122K</td><td>147K</td><td>21K</td><td>87K</td><td>205K</td><td>204K</td><td>13K</td></tr><tr><td>Language</td><td>Ko</td><td>Ku</td><td>Lt</td><td>Mk</td><td>My</td><td>Nb</td><td>NI</td><td>Pl</td><td>Ptbr</td><td>Pt</td><td>Ro</td></tr><tr><td>Training Data</td><td>206K</td><td>10K</td><td>42K</td><td>25K</td><td>21K</td><td>16K</td><td>184K</td><td>176K</td><td>185K</td><td>52K</td><td>180K</td></tr><tr><td>Language</td><td>Ru</td><td>Sk</td><td>S1</td><td>Sq</td><td>Sr</td><td>Sv</td><td>Th</td><td>Tr</td><td>Uk</td><td>Vi</td><td>Zh</td></tr><tr><td>Training Data</td><td>208K</td><td>61K</td><td>20K</td><td>45K</td><td>137K</td><td>57K</td><td>98K</td><td>182K</td><td>108K</td><td>172K</td><td>200K</td></tr></table>",
+        "bbox": [
+            173,
+            598,
+            841,
+            744
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "2 LANGUAGE NAME AND CODE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            804,
+            454,
+            820
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "The language names and their corresponding language codes according to ISO 639-1 standard11 are listed in Table 14. ",
+        "bbox": [
+            173,
+            834,
+            825,
+            863
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/97fa5db2adf2374211e6086c20a0156114c3741b48fd080f72f2b3771edc56b7.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Table 14: The ISO 639-1 code of each language in our experiments. There are two extra language codes in our datasets: Ptbr represents Portuguese spoken in Brazil, Frca represents French spoken in Canada. "
+        ],
+        "table_body": "<table><tr><td>Language</td><td>Code</td><td>Language</td><td>Code</td><td>Language</td><td>Code</td><td>Language</td><td>Code</td></tr><tr><td>Arabic</td><td>Ar</td><td>Bulgarian</td><td>Bg</td><td>Czech</td><td>Cs</td><td>Danish</td><td>Da</td></tr><tr><td>German</td><td>De</td><td>Greek</td><td>El</td><td>English</td><td>En</td><td>Spanish</td><td>Es</td></tr><tr><td>Persian</td><td>Fa</td><td>Finnish</td><td>Fi</td><td>French</td><td>Fr</td><td>Galician</td><td>Gl</td></tr><tr><td>Hebrew</td><td>He</td><td>Hindi</td><td>Hi</td><td>Croatian</td><td>Hr</td><td>Hungarian</td><td>Hu</td></tr><tr><td>Armenian</td><td>Hy</td><td>Indonesian</td><td>Id</td><td>Italian</td><td>It</td><td>Japanese</td><td>Ja</td></tr><tr><td>Georgian</td><td>Ka</td><td>Korean</td><td>Ko</td><td>Kurdish</td><td>Ku</td><td>Lithuanian</td><td>Lt</td></tr><tr><td>Latvian</td><td>Lv</td><td>Macedonian</td><td>Mk</td><td>Burmese</td><td>My</td><td>Norwegian</td><td>Nb</td></tr><tr><td>Dutch</td><td>N1</td><td>Polish</td><td>Pl</td><td>Portuguese</td><td>Pt</td><td>Romanian</td><td>Ro</td></tr><tr><td>Russian</td><td>Ru</td><td>Slovak</td><td>Sk</td><td>Slovenian</td><td>S1</td><td>Albanian</td><td>Sq</td></tr><tr><td>Serbian</td><td>Sr</td><td>Swedish</td><td>Sv</td><td>Thai</td><td>Th</td><td>Turkish</td><td>Tr</td></tr><tr><td>Ukrainian</td><td>Uk</td><td>Vietnamese</td><td>Vi</td><td>Chinese</td><td>Zh</td><td></td><td></td></tr></table>",
+        "bbox": [
+            207,
+            101,
+            794,
+            284
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "3 RESULTS ON TED TALK DATASET ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            361,
+            483,
+            378
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/1aaa1a1b862bd77c4e97c9a0be8d1e051b43dac324a8086882a849cbbff2b76f.jpg",
+        "table_caption": [
+            "The detailed results of the 44 languages English on the Ted talk dataset are listed in Table 15. It can be seen that while multilingual baseline performs worse than the individual model, multilingual model based on our method nearly matches and even outperforms the individual model. Note that the multilingual model handles 44 languages in total, which means our method can reduce the model parameters size to $1 / 4 4$ without loss of accuracy. ",
+            "Table 15: BLEU scores of the individual and multilingual models on the 44 languages English on the Ted talk dataset. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Language</td><td>Ar</td><td>Bg</td><td>Cs</td><td>Da</td><td>De</td><td>E1</td><td>Es</td><td>Et</td><td>Fa</td></tr><tr><td>Individual</td><td>31.07</td><td>38.64</td><td>26.42</td><td>38.21</td><td>34.63</td><td>36.69</td><td>41.20</td><td>7.43</td><td>26.67</td></tr><tr><td>Multilingual (Baseline)</td><td>27.84</td><td>27.76</td><td>27.17</td><td>40.41</td><td>32.85</td><td>36.04</td><td>39.80</td><td>14.86</td><td>24.93</td></tr><tr><td>Multilingual (Our method)</td><td>29.57</td><td>29.18</td><td>28.30</td><td>42.23</td><td>34.53</td><td>37.49</td><td>41.43</td><td>15.63</td><td>26.76</td></tr><tr><td>Language</td><td>Fi</td><td>Frca</td><td>Fr</td><td>Gl</td><td>He</td><td>Hi</td><td>Hr</td><td>Hu</td><td>Hy</td></tr><tr><td>Individual</td><td>10.78</td><td>18.52</td><td>39.62</td><td>12.64</td><td>36.81</td><td>10.84</td><td>34.14</td><td>24.67</td><td>12.30</td></tr><tr><td>Multilingual (Baseline)</td><td>16.12</td><td>33.08</td><td>38.27</td><td>30.32</td><td>32.96</td><td>19.93</td><td>34.39</td><td>22.76</td><td>20.25</td></tr><tr><td>Multilingual (Our method)</td><td>17.22</td><td>34.32</td><td>39.75</td><td>31.9</td><td>35.22</td><td>21.00</td><td>35.6</td><td>24.56</td><td>21.17</td></tr><tr><td>Language</td><td>Id</td><td>It</td><td>Ja</td><td>Ka</td><td>Ko</td><td>Ku</td><td>Lt</td><td>Mk</td><td>My</td></tr><tr><td>Individual</td><td>29.20</td><td>38.06</td><td>13.31</td><td>7.06</td><td>18.54</td><td>5.63</td><td>18.19</td><td>21.93</td><td>7.53</td></tr><tr><td>Multilingual (Baseline)</td><td>29.08</td><td>36.02</td><td>12.33</td><td>16.71</td><td>16.71</td><td>11.83</td><td>20.96</td><td>31.85</td><td>13.85</td></tr><tr><td>Multilingual (Our method)</td><td>30.56</td><td>37.50</td><td>13.28</td><td>18.26</td><td>18.14</td><td>13.38</td><td>22.65</td><td>32.65</td><td>15.16</td></tr><tr><td>Language</td><td>Nb</td><td>NI</td><td>PI</td><td>Ptbr</td><td>Pt</td><td>Ro</td><td>Ru</td><td>Sk</td><td>SI</td></tr><tr><td>Individual</td><td>27.28</td><td>35.85</td><td>22.98</td><td>44.28</td><td>33.81</td><td>34.07</td><td>24.36</td><td>25.67</td><td>11.80</td></tr><tr><td>Multilingual (Baseline)</td><td>39.88</td><td>33.97</td><td>23.50</td><td>42.96</td><td>40.59</td><td>33.03</td><td>24.02</td><td>28.97</td><td>22.52</td></tr><tr><td>Multilingual (Our method)</td><td>41.35</td><td>35.65</td><td>24.30</td><td>44.41</td><td>42.57</td><td>34.73</td><td>25.01</td><td>29.90</td><td>23.67</td></tr><tr><td>Language</td><td>Sq</td><td>Sr</td><td>Sv</td><td>Th</td><td>Tr</td><td>Uk</td><td>Vi</td><td>Zh</td><td></td></tr><tr><td>Individual</td><td>29.70</td><td>32.13</td><td>34.53</td><td>20.95</td><td>24.46</td><td>25.76</td><td>26.38</td><td>12.56</td><td></td></tr><tr><td>Multilingual (Baseline)</td><td>33.05</td><td>32.27</td><td>35.92</td><td>21.50</td><td>21.79</td><td>26.82</td><td>25.76</td><td>18.81</td><td></td></tr><tr><td>Multilingual (Our method)</td><td>34.73</td><td>33.71</td><td>36.92</td><td>22.12</td><td>23.67</td><td>27.80</td><td>26.53</td><td>19.39</td><td></td></tr></table>",
+        "bbox": [
+            171,
+            477,
+            826,
+            829
+        ],
+        "page_idx": 14
+    }
+]

parse/train/SJQO7UJCW/SJQO7UJCW.md

@@ -0,0 +1,279 @@
+# ADVERSARIAL LEARNING FORSEMI-SUPERVISED SEMANTIC SEGMENTATION
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+We propose a method for semi-supervised semantic segmentation using the adversarial network. While most existing discriminators are trained to classify input images as real or fake on the image level, we design a discriminator in a fully convolutional manner to differentiate the predicted probability maps from the ground truth segmentation distribution with the consideration of the spatial resolution. We show that the proposed discriminator can be used to improve the performance on semantic segmentation by coupling the adversarial loss with the standard cross entropy loss on the segmentation network. In addition, the fully convolutional discriminator enables the semi-supervised learning through discovering the trustworthy regions in prediction results of unlabeled images, providing additional supervisory signals. In contrast to existing methods that utilize weakly-labeled images, our method leverages unlabeled images without any annotation to enhance the segmentation model. Experimental results on both the PASCAL VOC 2012 dataset and the Cityscapes dataset demonstrate the effectiveness of our algorithm.
+
+# 1 INTRODUCTION
+
+Semantic segmentation is the task to assign a semantic label, e.g., person, dog, or road, to each pixel in images. It is essential to a wide range of applications, such as autonomous driving and image editing. For decades, many methods have been proposed to tackle this task (Long et al., 2015; Zheng et al., 2015; Liu et al., 2015; Yu & Koltun, 2016; Lin et al., 2016), and abundant standard benchmark datasets have been constructed (Everingham et al., 2010; Mottaghi et al., 2014; Cordts et al., 2016; Zhou et al., 2017), targeting different sets of scene/object categories as well as various real-world applications. However, this task remains challenging because of the object/scene appearance variations, occlusions, and the lack of context understanding. Recently, Convolutional Neural Network (CNN) based methods such as fully convolutional neural network (FCN) (Long et al., 2015) have achieved significant improvement on the task of semantic segmentation, and most state-of-the-art algorithms are based on FCN with advanced modifications and additional modules.
+
+Although CNN-based approaches have achieved astonishing performance, they require an enormous amount of training data. Different from image classification and object detection, semantic segmentation requires accurate per-pixel annotations for each training image, which can cost considerable expense and time. To ease the effort of acquiring high-quality data, semi/weakly-supervised methods have been applied to the task of semantic segmentation. These methods often assume that there is limited or none per-pixel annotations available, such as additional annotations on the image-level (Pinheiro & Collobert, 2015; Papandreou et al., 2015; Hong et al., 2015; Qi et al., 2016; Pathak et al., 2015a), box-level (Dai et al., 2015), or point-level (Bearman et al., 2016).
+
+In this paper, we propose a semi-supervised semantic segmentation algorithm via adversarial learning. The recent success of Generative Adversarial Networks (GANs) (Goodfellow et al., 2014) enables many possibilities for unsupervised and semi-supervised learning. A typical GAN consists of two sub-networks, i.e., generator and discriminator, in which these two sub-networks play a min-max game in the training process. The generator takes a sample vector and outputs a sample of the target data distribution, e.g., human faces, while the discriminator aims to differentiate generated samples from target ones. Then the generator is trained to confuse the discriminator through back-propagation and therefore generates samples that are similar to the target distribution. In this paper, we apply a similar methodology and treat the segmentation network as the generator in a GAN framework.
+
+Different from the typical generators that are trained to generate images given noise vectors, our segmentation network outputs the probability maps of the semantic labels given an input image. Under this setting, we wish to push the outputs of the segmentation network as close as the ground truth label maps spatially.
+
+To this end, we adopt an adversarial learning scheme and propose a fully convolutional discriminator that learns to differentiate ground truth label maps from probability maps of segmentation predictions. Combined with the spatial cross-entropy loss, our method use an adversarial loss that encourages the segmentation network to produce predicted probability maps close to the ground truth label maps in a high-order structure. The idea is similar to the use of probabilistic graphical models such as Conditional Random Fields (CRFs) (Zheng et al., 2015; Chen et al., 2017; Lin et al., 2016), but without the extra post-processing module during the testing phase. In addition, the discriminator is not required during inference, and hence our proposed framework does not increase any computational power for testing. By employing the adversarial learning, we further take advantage of the proposed fully convolutional discriminator under the semi-supervised setting.
+
+One way to allow the discriminator exploiting unlabeled data is to train the segmentation network using the adversarial learning without the cross-entropy loss. However, this approach does not improve the performance according to our experiments because the adversarial loss will aggressively encourage the predictions to be close to the ground truth distribution and neglects the correctness of segmentation. Instead, we utilize the confidence maps generated by our discriminator network as the supervisory signal to guide the cross-entropy loss in a “self-taught” manner. The confidence maps indicate which regions of the prediction distribution are close to the ground truth label distribution, so that the segmentation network can trust these predictions and hence can be trained via a masked cross-entropy loss. By adopting the proposed framework, we show that the segmentation accuracy can be further improved by adding images without any annotations in the domain of labeled images.
+
+The contributions of this work are as follows. First, we develop an adversarial framework that improves semantic segmentation accuracy without requiring additional computation loads during inference. Second, we facilitate the semi-supervised learning by leveraging the discriminator network response of unlabeled images to aid the training of the segmentation network. Experimental results validate the proposed adversarial framework for semi-supervised semantic segmentation on the PASCAL VOC 2012 (Everingham et al., 2010) and Cityscapes (Cordts et al., 2016) datasets.
+
+# 2 RELATED WORK
+
+Semantic segmentation. Recent state-of-the-art methods for semantic segmentation are based on the rapid development of CNN. As proposed by Long et al. (2015), one can transform a classification CNN, e.g. AlexNet (Krizhevsky et al., 2012), VGG (Simonyan & Zisserman, 2015), or ResNet (He et al., 2016), to a fully-convolutional network (FCN) that tackles the task of semantic segmentation. However, pixel-level annotations are usually expensive and difficult to collect. To reduce the heavy effort of labeling segmentation ground truth, many weakly-supervised approaches are proposed in recent years. In the weakly-supervised setting, the segmentation network is not trained at the pixel level with fully annotated ground truth. Instead, the network is trained with various weak-supervisory signals that are more easily to obtain. Image-level labels are exploited as the supervisory signal in most methods. Pinheiro & Collobert (2015) and Pathak et al. (2015b) use Multiple Instance Learning (MIL) to generate latent segmentation label maps for supervised training. On the other hand, Papandreou et al. (2015) refer to the image-level labels to penalize the prediction of non-existent object classes, while similarly Qi et al. (2016) use object localization to refine the segmentation. Hong et al. (2015) refer to the labeled images to train a classification network as the feature extractor for deconvolution. In addition to image-level supervisions, the segmentation network can also be trained with bounding boxes (Dai et al., 2015; Khoreva et al., 2017), point supervision (Bearman et al., 2016), or web videos (Hong et al., 2017).
+
+However, these weakly supervised approaches still fall behind the fully-supervised ones, especially because the detailed boundary information is difficult to infer from these weak-supervisory signals. Hence semi-supervised learning is also considered in some methods to enhance the prediction performance. In such setting, partial fully-annotated data and optional weakly-labeled data are used for the segmentation network training. Hong et al. (2015) jointly train their network with image-level supervised images and few fully-annotated images in the encoder-decoder framework.
+
+Dai et al. (2015) and Papandreou et al. (2015) also expand their weakly-supervised approaches to the semi-supervised setting for utilizing extra strongly-annotated data.
+
+Different from the aforementioned methods, our method can leverage unlabeled images in model training, hence greatly saving the cost of manual annotation. In fact, we treat the output of our fully convolutional discriminator as the supervisory signals, which compensate for the absence of image annotations and enable semi-supervised semantic segmentation. Our self-taught learning framework for segmentation is related to Pathak et al. (2015a) where the prediction maps of unlabeled images are used as ground truth. However, in Pathak et al. (2015a), the prediction maps are refined by several hand-designed constraints before training, while we learn the confidence map through the discriminator network as the selection criterion for self-taught learning.
+
+Generative adversarial networks. After Goodfellow et al. (2014) propose the GAN framework and its theoretical foundation, the GAN draws great attention with several improvements in implementation (Radford et al., 2016; Denton et al., 2015; Arjovsky et al., 2017; Mao et al., 2016; Berthelot et al., 2017). The methodology of adversarial training has been applied to a wide range of applications, including image genration (Radford et al., 2016), image completion (Li et al., 2017), super-resolution (Ledig et al., 2016), object detection (Wang et al., 2017), domain adaptation (Hoffman et al., 2016) and semantic segmentation (Luc et al., 2016; Souly et al., 2017).
+
+The work closest in scope to ours is the one proposed by Luc et al. (2016), where the adversarial network is used to aid the training for semantic segmentation. However, it does not show substantial improvement over the baseline. On the other hand, Souly et al. (2017) propose to generate adversarial examples using GAN for semi-supervised semantic segmentation, but these generated examples may not be sufficiently close to real images to help the segmentation network.
+
+# 3 ALGORITHM OVERVIEW
+
+Figure 1 shows the overview of the proposed algorithm. Our system is composed of two networks: the segmentation network and the discriminator network. The former can be any network designed for semantic segmentation, e.g., FCN (Long et al., 2015), DeepLab (Chen et al., 2017), DilatedNet (Yu & Koltun, 2016). Given an input image with dimension $H \times W \times 3$ , the segmentation network outputs the class probability maps of size $H \times W \times C$ , where $C$ is the number of semantic categories of the target dataset.
+
+Our discriminator network is an FCN-based network, which takes class probability maps as the input, either from the segmentation network or ground truth label maps, and then outputs spatial probability maps with a size of $H \times W \times 1$ . Each pixel of the discriminator outputs map represents whether that pixel is sampled from the ground truth label $( p = 1 )$ ) or from the segmentation network $( p = 0$ ). In contrast to the typical GAN discriminators which take fix-sized input images ( $6 4 \times 6 4$ in most cases) and output a single probability value, we transform our discriminator to a fully-convolutional network that can take inputs of arbitrary sizes. Importantly, we find this transformation is essential to enable the proposed adversarial learning scheme.
+
+During the training process, we use both labeled and unlabeled images under the semi-supervised setting. When using the labeled data, the segmentation network is supervised by both the standard cross-entropy loss with the ground truth label map and the adversarial loss with the discriminator network. Note that we train the discriminator network only with the labeled data.
+
+For the unlabeled data, we train the segmentation network with the proposed semi-supervised method. After obtaining the initial segmentation prediction of the unlabeled image from the segmentation network, we obtain a confidence map by passing the segmentation prediction through the discriminator network. We in turn treat this confidence map as the supervisory signal using a “self-taught” scheme to train the segmentation network with a masked cross-entropy loss. The intuition is that this confidence map indicates the local quality of the predicted segmentation, so that the segmentation network knows which regions to trust during training.
+
+# 4 SEMI-SUPERVISED TRAINING WITH ADVERSARIAL NETWORK
+
+In this section, we address the detailed learning scheme of the segmentation and discriminator networks, as well as the designed network architectures.
+
+![](images/b5dd4ca7c956097b67faeeb23d1d0bf7322a37e58237ea892ed75121fca0199d.jpg)  
+Figure 1: Overview of the proposed system for semi-supervised semantic segmentation. With a fully-convolution discriminator network trained using the loss $\mathcal { L } _ { D }$ , we optimize the segmentation netwrok using three loss functions during the training process: cross-entropy loss $\mathcal { L } _ { c e }$ , adversarial loss $\mathcal { L } _ { a d v }$ , and semi-supervised loss $\mathcal { L } _ { s e m i }$ .
+
+# 4.1 TRAINING OBJECTIVE
+
+Given an input image $\mathbf { X } _ { n }$ of size $H \times W \times 3$ , we denote the segmentation network as $S ( \cdot )$ and the predicted probability map as $S ( \mathbf { X } _ { n } )$ of size $H \times W \times C$ , where $\textrm { C }$ is the category number. For our fully convolutional discriminator, we denote it as $D ( \cdot )$ which outputs a two-class confidence map $D ( \mathbf { P } _ { n } )$ with the size of $H \times W \times 1$ , where $\mathbf { P } _ { n }$ is the class probability map of size $H \times W \times C$ , from either the ground truth label $Y _ { n }$ or the segmentation network as $S ( \mathbf { X } _ { n } )$ .
+
+Discriminator network training. To train the discriminator network, we minimize the spatial cross-entropy loss $\mathcal { L } _ { D }$ with respect to two classes. The loss can be formally written as:
+
+$$
+\mathcal { L } _ { D } = - \sum _ { h , w } \left( 1 - y _ { n } \right) \log ( D ( \mathbf { P } _ { n } ) ^ { ( h , w , 0 ) } ) + y _ { n } \log ( D ( \mathbf { P } _ { n } ) ^ { ( h , w , 1 ) } ) ,
+$$
+
+where $y _ { n } = 0$ if the sample is drawn from the segmentation network, and $y _ { n } = 1$ if the sample is from the ground truth label. Note that, the discriminator network takes a C-channel probability map as input. In order to convert the ground truth label map $Y _ { n }$ of size $H \times W \times 1$ to $\textrm { C }$ channels, we simply employ one-hot encoding scheme by constructing the probability maps $P _ { n }$ , where $P _ { n } ^ { ( h , w , c ) }$ takes value 1 if Y (h,w)n , and 0 otherwise.
+
+One concern raised by (Luc et al., 2016) is that the discriminator network may easily distinguish whether the probability maps come from the ground truth by detecting the one-hot probability. However, we do not observe this phenomenon during the training phase. One reason is that we use a fully-convolutional scheme to predict spatial confidence, which increases the difficulty to learn the discriminator. In addition, we try the Scale scheme proposed in (Luc et al., 2016), where the ground truth probability channel is slightly diffused to other channels according to the distribution of segmentation network output. However, the results show no difference, and thus we do not adopt this scheme in the experiments.
+
+Segmentation network training. We propose to train the segmentation network via minimizing a multi-task loss function:
+
+$$
+\mathcal { L } _ { s e g } = \mathcal { L } _ { c e } + \lambda _ { a d v } \mathcal { L } _ { a d v } + \lambda _ { s e m i } \mathcal { L } _ { s e m i } ,
+$$
+
+where $\mathcal { L } _ { c e }$ , $\mathcal { L } _ { a d v }$ , and $\mathcal { L } _ { s e m i }$ denote the spatial multi-class cross entropy loss, the adversarial loss, and the semi-supervised loss, respectively. $\lambda _ { a d v }$ and $\lambda _ { s e m i }$ are two constants for balancing the multi-task training.
+
+We first consider the scenario of using annotated data. Given an input image ${ \bf X } _ { n }$ , ground truth ${ \bf Y } _ { n }$ and prediction results ${ \bf P } _ { n } = S ( { \bf X } _ { n } )$ , the cross-entropy loss is obtained by:
+
+$$
+\mathcal { L } _ { c e } = - \sum _ { h , w } \sum _ { c \in C } \mathbf { Y } _ { n } ^ { ( h , w , c ) } \log ( \mathbf { P } _ { n } ^ { ( h , w , c ) } ) .
+$$
+
+We adopt the adversarial learning through the adversarial loss $\mathcal { L } _ { a d v }$ given a fully convolutional discriminator network $D ( \cdot )$ :
+
+$$
+\mathcal { L } _ { a d v } = - \sum _ { h , w } \log ( D ( \mathbf { P } _ { n } ) ^ { ( h , w , 1 ) } ) .
+$$
+
+With this adversarial loss, we seek to train the segmentation network to fool the discriminator by maximizing the probability of the segmentation prediction being considered as the ground truth distribution.
+
+Training with unlabeled data. Now we consider the adversarial training under the semi-supervised setting. For unlabeled data, it is obvious that we cannot apply $\mathcal { L } _ { c e }$ since there is no ground truth annotation available. The adversarial loss $\mathcal { L } _ { a d v }$ is still applicable as it only requires the discriminator network. However, we find that the performance degenerates when only applying the adversarial loss on unlabeled data without $\mathcal { L } _ { c e }$ . This is reasonable because the discriminator serves as a regularization and may over-correct the prediction to fit the ground truth distribution.
+
+Thus, we propose to utilize the trained discriminator with unlabeled data using a “self-taught” strategy. The main idea is that the trained discriminator can generate a confidence map, i.e. $D ( \mathbf { P } _ { n } ) ^ { ( h , w , 1 ) }$ , which infers the regions where the prediction results are close enough to the ground truth distribution. We then binarize this confidence map with a threshold to highlight the trustworthy region. As a result, we define the self-taught ground truth as the masked segmentation prediction $\hat { { \mathbf Y } } _ { n } = a r g m a x ( { \mathbf P } _ { n } )$ using this binarized confidence map. The resulting semi-supervised loss is defined by:
+
+$$
+\mathcal { L } _ { s e m i } = - \sum _ { h , w } \sum _ { c \in C } I ( D ( \mathbf { P } _ { n } ) ^ { ( h , w , 1 ) } > T _ { s e m i } ) \cdot \hat { \mathbf { Y } } _ { n } ^ { ( h , w , c ) } \log ( \mathbf { P } _ { n } ^ { ( h , w , c ) } ) ,
+$$
+
+where $I ( \cdot )$ is the indicator function, and $T _ { s e m i }$ is the threshold to control the sensitivity of the self-taught process. Note that during training we treat both the self-taught target $\hat { { \mathbf Y } } _ { n }$ and the value of indicator function as constant, and thus (5) can be simply viewed as a masked spatial cross entropy loss. In practice, we find that this strategy works robustly with $T _ { s e m i }$ ranging between 0.1 and 0.3.
+
+# 4.2 NETWORK ARCHITECTURE
+
+Segmentation network. We adopt the DeepLab-v2 (Chen et al., 2017) framework with ResNet101 (He et al., 2016) model pre-trained on the ImageNet dataset (Deng et al., 2009) as our segmentation baseline network. However, we do not employ the multi-scale fusion proposed in Chen et al. (2017) due to the memory concern. Following the practice of recent work on semantic segmentation (Chen et al., 2017; Yu & Koltun, 2016), we remove the last classification layer and modify the stride of the last two convolution layers from 2 to 1, making the resolution of the output feature maps effectively $1 / 8$ times the input image size. To enlarge the receptive fields, we apply the dilated convolution (Yu & Koltun, 2016) in conv4 and conv5 layers with a stride of 2 and 4, respectively. After the last layer, we employ the Atrous Spatial Pyramid Pooling (ASPP) proposed in Chen et al. (2017) as the final classifier. Finally, we apply an up-sampling layer along with the softmax output to match the size of the input image.
+
+Discriminator network. For the discriminator network, we follow the structure used in Radford et al. (2016). It consists of 5 convolution layers with kernel $4 \times 4$ with channel numbers {64, 128, 256, 512, 1} and stride of 2. Each convolution layer is followed by a Leaky-ReLU (Maas et al., 2013) parameterized by 0.2 except the last layer. To transform the network to a fully convolutional network, an up-sampling layer is added to the last layer to rescale the output to the size of the input map. Note that we do not employ the batch-normalization layers. We find that the batch-normalization layer (Ioffe & Szegedy, 2015) is highly unstable since the system can be only trained with a small batch size.
+
+# 5 EXPERIMENTAL RESULTS
+
+Implementation details. We implement our network using the PyTorch framework. We train our system on a single TitanX GPU with 12 GB memory. To train the segmentation network, we use
+
+Table 1: Results on the VOC 2012 validation set.   
+
+<table><tr><td></td><td colspan="4">Data Amount</td></tr><tr><td>Methods</td><td>1/8</td><td>1/4</td><td>1/2</td><td>Full</td></tr><tr><td>FCN-8s (Long et al.,2015)</td><td>N/A</td><td>N/A</td><td>N/A</td><td>67.2</td></tr><tr><td>Dilationl0(Yu&amp; Koltun,2016)</td><td>N/A</td><td>N/A</td><td>N/A</td><td>73.9</td></tr><tr><td>DeepLab-v2 (Chen et al.,2017)</td><td>N/A</td><td>N/A</td><td>N/A</td><td>77.7</td></tr><tr><td>our baseline</td><td>66.0</td><td>68.3</td><td>69.8</td><td>73.6</td></tr><tr><td>baseline+Ladu</td><td>67.6</td><td>71.0</td><td>72.6</td><td>74.9</td></tr><tr><td>baseline+Ladu +Lsemi</td><td>68.8</td><td>71.6</td><td>73.2</td><td>N/A</td></tr></table>
+
+Table 2: Results on the Cityscapes validation set.   
+
+<table><tr><td></td><td colspan="4">Data Amount</td></tr><tr><td>Methods</td><td>1/8</td><td>1/4</td><td>1/2</td><td>Full</td></tr><tr><td>FCN-8s (Long et al., 2015)</td><td>N/A</td><td>N/A</td><td>N/A</td><td>65.3</td></tr><tr><td>Dilationi0 (Yu &amp; Koltun,2016)</td><td>N/A</td><td>N/A</td><td>N/A</td><td>67.1</td></tr><tr><td>DeepLab-v2 (Chen et al.,2017)</td><td>N/A</td><td>N/A</td><td>N/A</td><td>70.4</td></tr><tr><td>our baseline</td><td>52.4</td><td>58.3</td><td>62.6</td><td>66.4</td></tr><tr><td>baseline+Ladu</td><td>53.8</td><td>59.1</td><td>63.7</td><td>67.7</td></tr><tr><td>baseline+Ladu +Lsemi</td><td>54.2</td><td>59.7</td><td>64.5</td><td>N/A</td></tr></table>
+
+Stochastic Gradient Descent (SGD) with Nesterov acceleration as the optimizer, where the momentum is 0.9 and the weight decay is $1 0 ^ { - 4 }$ . The initial learning rate is set as $2 . 5 \times 1 0 ^ { - 4 }$ and is decreased with polynomial decay with power of 0.9 as mentioned in Chen et al. (2017). For training the discriminator, we adopt Adam optimizer (Kingma & Ba, 2014) with the learning rate as $1 0 ^ { - 4 }$ and the same polynomial decay as the segmentation network. The momentum is set as 0.9 and 0.999.
+
+For semi-supervised training, we randomly interleave the labeled data and unlabeled data iteratively and apply the training scheme described in section 4.1 accordingly. We update both the segmentation network and discriminator network jointly. In each iteration, only the batch containing the ground truth data are used for training the discriminator. When randomly sampling partial labeled and unlabeled data from the datasets, we average several experiment results with different random seeds to ensure the evaluation robustness.
+
+Evaluation datasets and metric. In this work, we conduct experiments on two semantic segmentation datasets: PASCAL VOC 2012 (Everingham et al., 2010) and Cityscapes (Cordts et al., 2016). While the PASCAL VOC dataset contains common objects in photos captured in daily activities, the Cityscapes dataset mainly targets urban street scenes. On both datasets, we use the mean intersection-over-union (mean IU) as the evaluation metric.
+
+The PASCAL VOC 2012 dataset is a commonly used evaluation dataset for semantic segmentation. It comprises 20 common objects with annotations on daily captured photos. We use the extra annotation set in SBD (Hariharan et al., 2011), resulting in 10,582 training images. We evaluate our models on the standard validation set with 1449 images. During training, we employ the random scaling and cropping with size $3 2 1 \times 3 2 1$ . We train each model on the PASCAL VOC dataset for 20k iterations with batch size 10.
+
+The Cityscapes dataset has 50 videos with driving scenes, and 2975, 500, 1525 images are extracted and annotated with 19 classes for training, validation, and testing, respectively. Each annotated frame is the $2 0 ^ { t h }$ frame in a 30-frames snippet, where only these images with annotations are considered in the training process. We resize the input image to $5 1 2 \times 1 0 2 4$ without any random cropping/scaling. We train each model on the Cityscapes dataset for $4 0 \mathrm { k }$ iterations with batch size 2.
+
+Results on the PASCAL VOC 2012 dataset. Table 1 shows the evaluation results on the PASCAL VOC 2012 dataset. To validate the semi-supervising scheme, we randomly sample 1/8, 1/4, 1/2 images as labeled, and used the rest of training images as the unlabeled data. We show the performance comparisons with FCN (Long et al., 2015), Dilation10 (Yu & Koltun, 2016), and DeepLab-v2 (Chen et al., 2017) to demonstrate that our baseline model is comparable with other state-of-the-art methods. Note that our baseline model is equivalent to the DeepLab-v2 model without multi-scale fusion. The adversarial loss brings consistent performance improvement $( 1 . 6 \% - 2 . 8 \% )$ over different amounts of training data. Incorporating the proposed semi-supervised learning scheme brings overall $2 . 8 \% - 3 . 4 \%$ improvement. Figure 2 shows visual comparisons of the segmentation results generated by the proposed method. We observe that the segmentation boundary has significant improvement when compared to the baseline model.
+
+Results on the Cityscapes dataset. Table 2 shows evaluation results on the Cityscapes dataset. By applying the adversarial loss $\mathcal { L } _ { a d v }$ , the model achieves $0 . 8 \% - 1 . 4 \%$ gain over the baseline model under the semi-supervised setting. This shows that our adversarial training scheme can encourage the segmentation network to learn the structural information from the ground truth distribution. Combining the adversarial learning and proposed semi-supervised learning, the performance further improves with overall $1 . 4 \% - 1 . 9 \%$ mean IU gain.
+
+![](images/ad761a8eb8df14912d63bd76a3a14905ae6ebd66914a0c05acbdd1e29c0249aa.jpg)  
+Figure 2: Comparisons on the PASCAL VOC 2012 dataset using 1/2 labeled data.
+
+Table 3: Adversarial learning comparison with Luc et al. (2016) on VOC 2012 validation set.   
+
+<table><tr><td></td><td>Baseline</td><td>Adversarial</td></tr><tr><td>Luc et al. (2016)</td><td>71.8</td><td>72.0</td></tr><tr><td>ours</td><td>73.6</td><td>74.9</td></tr></table>
+
+Table 4: Semi-supervised learning comparisons on VOC 2012 validation set without using additional labels of SBD.   
+
+<table><tr><td></td><td>Data Amount</td><td>Fully- supervised</td><td>Semi- supervised</td></tr><tr><td>Papandreou et al. (2015)</td><td>Full</td><td>62.5</td><td>64.6</td></tr><tr><td>Souly et al. (2017)</td><td>Full</td><td>59.5</td><td>64.1</td></tr><tr><td>ours</td><td>Full</td><td>66.3</td><td>68.4</td></tr><tr><td>Souly et al. (2017)</td><td>30%</td><td>38.9</td><td>42.2</td></tr><tr><td>ours</td><td>30%</td><td>57.4</td><td>60.6</td></tr></table>
+
+Comparisons with state-of-the-art methods Table 3 shows comparisons with Luc et al. (2016) that utilizes adversarial learning. There are major design differences of the adversarial learning step between Luc et al. (2016) and our method. First, we design a universal discriminator for various datasets, while Luc et al. (2016) utilizes different network structures for different datasets. Second, our discriminator is not required to take the RGB image as an additional input but directly work on the prediction map from the segmentation network. In Table 3, our method achieves $1 . 2 \%$ gain in mean IU, which is significantly better then the gain in Luc et al. (2016).
+
+We show comparisons for the semi-supervised setting in Table 4. To compare with Papandreou et al. (2015) and Souly et al. (2017), we train our model on the original PASCAL VOC 2012 train set (1464 images) and use the SBD (Hariharan et al., 2011) set as unlabeled data. It is worth noting that in Papandreou et al. (2015), image-level labels are available for the SBD (Hariharan et al., 2011) set, and in Souly et al. (2017), additional unlabeled images are generated through their generator during the training stage.
+
+Hyper-parameter analysis. The proposed algorithm is parametrized by three hyper parameters: $\lambda _ { a d v }$ and $\lambda _ { s e m i }$ are two parameters for balancing the multi-task learning in (2), and $T _ { s e m i }$ is used to control the sensitivity in the semi-supervised learning described in (5). We evaluate these hyper parameters using the PASCAL VOC dataset under the fully/semi-supervised setting. We show comparison results of different parameter settings in Table 5. We first evaluate the effect on $\lambda _ { a d v }$ using fully-supervised setting. Note that we do not use any unlabeled data, i.e. $\lambda _ { s e m i } = 0$ . The baseline model without adversarial learning $\begin{array} { r } { { } ^ { \prime } \lambda _ { a d v } = 0 } \end{array}$ ) achieves $7 3 . 6 \%$ mean IU. When $\lambda _ { a d v } = 0 . 0 1$ , the model achieves $7 4 . 9 \%$ mean IU with $1 . 3 \%$ improvement. When $\lambda _ { a d v } = 0 . 0 5$ , the performance deprecates to $7 3 . 0 \%$ mean IU, which indicates that the adversarial loss is too large.
+
+Second, we show comparisons of different values of $\lambda _ { s e m i }$ with 1/8 amount of data under the semisupervised setting. We set $\lambda _ { a d v } = 0 . 0 1$ and $T _ { s e m i } = 0 . 2$ for the comparisons. Overall, $\lambda _ { s e m i } = 0 . 1$ achieves the best performance of $6 8 . 8 \%$ mean IU with $1 . 2 \%$ gain.
+
+![](images/155186d45f56a986f5493901ce8e03360e5280cab7564bd958e197faab5f239b.jpg)  
+Figure 3: Visualization of the confidence maps. Given the probability maps generated by the segmentation network, the confidence maps is then obtained from the discriminator. In the confidence maps, the brighter regions indicate that they are close to the ground truth distribution.
+
+Lastly, we perform the experiments with different value of $T _ { s e m i }$ , where we set $\lambda _ { a d v } = 0 . 0 1$ and $\lambda _ { s e m i } = 0 . 1$ . High $T _ { s e m i }$ suggests that we only trust regions of high structural similarity as the ground truth distribution. We find that our proposed strategy performs well for a wide range of values $T _ { s e m i }$ (0.1 to 0.3). The method performs the best when $T _ { s e m i } = 0 . 2$ . When $T _ { s e m i } = 0$ , we trust all the pixel predictions in unlabeled images, resulting in performance degradation. In Figure 3, we show the visualization of generated confidence maps given the predicted probability maps.
+
+Ablation study. We present the ablation study of our proposed system in Table 6 on the PASCAL VOC dataset. First, we examine the impact of using fully convolutional discriminator (FCD). To construct a discriminator that is not fully-convolutional, we replace the last convolution layer of the discriminator with a fully-connected layer that outputs a single neuron as in typical GAN models. Without using FCD, the performance drops $1 . 0 \%$ using full data and $0 . 9 \%$ with 1/8 data. This shows that the use of FCD is essential to the adversarial learning. Second, we apply the semi-supervised learning method without the adversarial loss. The results show that the adversarial training on the labeled data is important to our semi-supervised scheme. If the segmentation network does not seek to fool the discriminator, the confidence maps generated by the discriminator would be meaningless, providing weaker supervisory signals.
+
+Table 5: Hyper parameter analysis.   
+
+<table><tr><td>Data Amount</td><td>Xadu</td><td>Xsemi</td><td>Tsemi</td><td>Mean IU</td></tr><tr><td>Full</td><td>0</td><td>0</td><td>N/A</td><td>73.6</td></tr><tr><td>Full</td><td>0.005</td><td>0</td><td>N/A</td><td>74.0</td></tr><tr><td>Full</td><td>0.01</td><td>0</td><td>N/A</td><td>74.9</td></tr><tr><td>Full</td><td>0.02</td><td>0</td><td>N/A</td><td>74.6</td></tr><tr><td>Full</td><td>0.04</td><td>0</td><td>N/A</td><td>74.1</td></tr><tr><td>Full</td><td>0.05</td><td>0</td><td>N/A</td><td>73.0</td></tr><tr><td>1/8</td><td>0.01</td><td>0</td><td>N/A</td><td>67.6</td></tr><tr><td>1/8</td><td>0.01</td><td>0.05</td><td>0.2</td><td>68.6</td></tr><tr><td>1/8</td><td>0.01</td><td>0.1</td><td>0.2</td><td>68.8</td></tr><tr><td>1/8</td><td>0.01</td><td>0.2</td><td>0.2</td><td>68.5</td></tr><tr><td>1/8</td><td>0.01</td><td>0.1</td><td>0</td><td>66.5</td></tr><tr><td>1/8</td><td>0.01</td><td>0.1</td><td>0.1</td><td>68.0</td></tr><tr><td>1/8</td><td>0.01</td><td>0.1</td><td>0.2</td><td>68.8</td></tr><tr><td>1/8</td><td>0.01</td><td>0.1</td><td>0.3</td><td>68.7</td></tr><tr><td>1/8</td><td>0.01</td><td>0.1</td><td>1.0</td><td>67.6</td></tr></table>
+
+Table 6: Ablation study of the proposed method on the PASCAL VOC dataset.   
+
+<table><tr><td>Ladu</td><td>Lsemi</td><td>FCD</td><td>Data Amount 1/8</td><td>Full</td></tr><tr><td></td><td></td><td></td><td>66.0</td><td>73.6</td></tr><tr><td>√</td><td></td><td>1</td><td>67.6</td><td>74.9</td></tr><tr><td></td><td></td><td></td><td>66.6</td><td>74.0</td></tr><tr><td></td><td>V</td><td>?</td><td>65.7</td><td>N/A</td></tr><tr><td>√</td><td></td><td></td><td>68.8</td><td>N/A</td></tr></table>
+
+# 6 CONCLUSIONS
+
+In this work, we propose an adversarial learning scheme for semi-supervised semantic segmentation. We train a fully convolutional discriminator network to enhance the segmentation network with both labeled and unlabeled data. With labeled data, the adversarial loss for the segmentation network is designed to learn higher order structural information without post-processing. For unlabeled data, the confidence maps generated by the discriminator network act as the self-taught signal for refining the segmentation network. Extensive experiments on the PASCAL VOC 2012 dataset and on the Cityscapes dataset are performed to validate the effectiveness of the proposed algorithm.
+
+# REFERENCES
+
+Martin Arjovsky, Soumith Chintala, and Léon Bottou. Wasserstein gan. arXiv preprint arXiv:1701.07875, 2017.
+
+Amy Bearman, Olga Russakovsky, Vittorio Ferrari, and Li Fei-Fei. What’s the point: Semantic segmentation with point supervision. In ECCV, 2016.
+
+David Berthelot, Tom Schumm, and Luke Metz. Began: Boundary equilibrium generative adversarial networks. arXiv preprint arXiv:1703.10717, 2017.
+
+Liang-Chieh Chen, George Papandreou, Iasonas Kokkinos, Kevin Murphy, and Alan L Yuille. Deeplab: Semantic image segmentation with deep convolutional nets, atrous convolution, and fully connected crfs. In TPAMI, 2017.
+
+Marius Cordts, Mohamed Omran, Sebastian Ramos, Timo Rehfeld, Markus Enzweiler, Rodrigo Benenson, Uwe Franke, Stefan Roth, and Bernt Schiele. The cityscapes dataset for semantic urban scene understanding. In CVPR, 2016.
+
+Jifeng Dai, Kaiming He, and Jian Sun. Boxsup: Exploiting bounding boxes to supervise convolutional networks for semantic segmentation. In ICCV, 2015.
+
+Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. In CVPR, 2009.
+
+Emily L Denton, Soumith Chintala, Rob Fergus, et al. Deep generative image models using a laplacian pyramid of adversarial networks. In NIPS, 2015.
+
+Mark Everingham, Luc Van Gool, Christopher KI Williams, John Winn, and Andrew Zisserman. The pascal visual object classes (voc) challenge. In IJCV, 2010.
+
+Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In NIPS, 2014.
+
+Bharath Hariharan, Pablo Arbeláez, Lubomir Bourdev, Subhransu Maji, and Jitendra Malik. Semantic contours from inverse detectors. In ICCV, 2011.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, 2016.
+
+Judy Hoffman, Dequan Wang, Fisher Yu, and Trevor Darrell. Fcns in the wild: Pixel-level adversarial and constraint-based adaptation. In arXiv preprint arXiv:1612.02649, 2016.
+
+Seunghoon Hong, Hyeonwoo Noh, and Bohyung Han. Decoupled deep neural network for semisupervised semantic segmentation. In NIPS, 2015.
+
+Seunghoon Hong, Donghun Yeo, Suha Kwak, Honglak Lee, and Bohyung Han. Weakly supervised semantic segmentation using web-crawled videos. In CVPR, 2017.
+
+Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In ICML, 2015.
+
+A. Khoreva, R. Benenson, J. Hosang, M. Hein, and B. Schiele. Simple does it: Weakly supervised instance and semantic segmentation. In CVPR, 2017.
+
+Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In arXiv preprint arXiv:1412.6980, 2014.
+
+Mateusz Kozinski, Loïc Simon, and Frédéric Jurie. An adversarial regularisation for semi-supervised ´ training of structured output neural networks. In arXiv preprint arXiv:1702.02382, 2017.
+
+Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. In NIPS, 2012.
+
+Christian Ledig, Lucas Theis, Ferenc Huszár, Jose Caballero, Andrew Cunningham, Alejandro Acosta, Andrew Aitken, Alykhan Tejani, Johannes Totz, Zehan Wang, et al. Photo-realistic single image super-resolution using a generative adversarial network. In arXiv preprint arXiv:1609.04802, 2016.
+
+Yijun Li, Sifei Liu, Jimei Yang, and Ming-Hsuan Yang. Generative face completion. In CVPR, 2017.
+
+Guosheng Lin, Chunhua Shen, Anton van dan Hengel, and Ian Reid. Efficient piecewise training of deep structured models for semantic segmentation. In CVPR, 2016.
+
+Ziwei Liu, Xiaoxiao Li, Ping Luo, Chen Change Loy, and Xiaoou Tang. Semantic Image Segmentation via Deep Parsing Network. In ICCV, 2015.
+
+Jonathan Long, Evan Shelhamer, and Trevor Darrell. Fully convolutional networks for semantic segmentation. In CVPR, 2015.
+
+Pauline Luc, Camille Couprie, Soumith Chintala, and Jakob Verbeek. Semantic segmentation using adversarial networks. In NIPS Workshop on Adversarial Training, 2016.
+
+Andrew L Maas, Awni Y Hannun, and Andrew Y Ng. Rectifier nonlinearities improve neural network acoustic models. In ICML, 2013.
+
+Xudong Mao, Qing Li, Haoran Xie, Raymond YK Lau, and Zhen Wang. Multi-class generative adversarial networks with the l2 loss function. arXiv preprint arXiv:1611.04076, 2016.
+
+Roozbeh Mottaghi, Xianjie Chen, Xiaobai Liu, Nam-Gyu Cho, Seong-Whan Lee, Sanja Fidler, Raquel Urtasun, and Alan Yuille. The Role of Context for Object Detection and Semantic Segmentation in the Wild. In CVPR, 2014.
+
+George Papandreou, Liang-Chieh Chen, Kevin Murphy, and Alan L Yuille. Weakly-and semisupervised learning of a dcnn for semantic image segmentation. In ICCV, 2015.
+
+Deepak Pathak, Philipp Krahenbuhl, and Trevor Darrell. Constrained convolutional neural networks for weakly supervised segmentation. In ICCV, 2015a.
+
+Deepak Pathak, Evan Shelhamer, Jonathan Long, and Trevor Darrell. Fully convolutional multi-class multiple instance learning. In ICLR, 2015b.
+
+Pedro O Pinheiro and Ronan Collobert. Weakly supervised semantic segmentation with convolutional networks. In CVPR, 2015.
+
+Xiaojuan Qi, Zhengzhe Liu, Jianping Shi, Hengshuang Zhao, and Jiaya Jia. Augmented feedback in semantic segmentation under image level supervision. In ECCV, 2016.
+
+Alec Radford, Luke Metz, and Soumith Chintala. Unsupervised representation learning with deep convolutional generative adversarial networks. In ICLR, 2016.
+
+Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. In ICLR, 2015.
+
+Nasim Souly, Concetto Spampinato, and Mubarak Shah. Semi and weakly supervised semantic segmentation using generative adversarial network. In ICCV, 2017.
+
+Xiaolong Wang, Abhinav Shrivastava, and Abhinav Gupta. A-fast-rcnn: Hard positive generation via adversary for object detection. In CVPR, 2017.
+
+Fisher Yu and Vladlen Koltun. Multi-scale context aggregation by dilated convolutions. In ICLR, 2016.
+
+Hengshuang Zhao, Jianping Shi, Xiaojuan Qi, Xiaogang Wang, and Jiaya Jia. Pyramid scene parsing network. In CVPR, 2017.
+
+Shuai Zheng, Sadeep Jayasumana, Bernardino Romera-Paredes, Vibhav Vineet, Zhizhong Su, Dalong Du, Chang Huang, and Philip HS Torr. Conditional random fields as recurrent neural networks. In ICCV, 2015.
+
+Bolei Zhou, Hang Zhao, Xavier Puig, Sanja Fidler, Adela Barriuso, and Antonio Torralba. Semantic understanding of scenes through the ade20k dataset. In CVPR, 2017.
+
+# A OVERVIEW
+
+In this appendix, we present additional results of the proposed method. First, we provide the detailed training parameters for both evaluation datasets. Second, we show more qualitative comparisons of our proposed method on both the PASCAL VOC dataset (Everingham et al., 2010) and on the Cityscapes dataset (Cordts et al., 2016).
+
+# B TRAINING PARAMETERS
+
+Table 7: Training parameters.   
+
+<table><tr><td>Parameter</td><td>Cityscaps</td><td>PASCAL VOC</td></tr><tr><td>Trained iterations</td><td>40,000</td><td>20.000</td></tr><tr><td>Learning rate</td><td>2.5e-4</td><td>2.5e-4</td></tr><tr><td>Learning rate (D)</td><td>1e-4</td><td>1e-4</td></tr><tr><td>Polynomial decay</td><td>0.9</td><td>0.9</td></tr><tr><td>Momentum</td><td>0.9</td><td>0.9</td></tr><tr><td>Optimizer</td><td>SGD</td><td>SGD</td></tr><tr><td>Optimizer (D)</td><td>Adam</td><td>Adam</td></tr><tr><td>Nesterov</td><td>True</td><td>True</td></tr><tr><td>Batch size</td><td>2</td><td>10</td></tr><tr><td>Weight decay</td><td>0.0001</td><td>0.0001</td></tr><tr><td>Crop size</td><td>512x1024</td><td>321x321</td></tr><tr><td>Random scale</td><td>No</td><td>Yes</td></tr></table>
+
+# C ADDITIONAL QUALITATIVE RESULTS
+
+In Figure 4-5, we show the additional qualitative comparisons with the models using half training data of the PSCAL VOC dataset. In Figure 6, we also show the additional qualitative comparisons with the models using half training data of the Cityscapes dataset. The results show that both the adversarial learning and the semi-supervised training scheme can improve the performance of the semantic segmentation.
+
+![](images/cefabd5956e18f6cf7a062db36f055bdf8def3425b8f2cac2fbbcd5bb44a5ce7.jpg)  
+Figure 4: Comparisons on the PASCAL VOC dataset using 1/2 training data.
+
+![](images/baec1e35d25251138549eecd7afc120fdd14b8e429ee7573c0d890f121e7f204.jpg)  
+Figure 5: Comparisons on the PASCAL VOC dataset using $1 / 2$ training data.
+
+![](images/65189e788827896e2bd401a87b6150de7fa2fae8da2729334991e522feac8ac7.jpg)  
+Figure 6: Comparisons on the Cityscapes dataset using 1/2 training data.

parse/train/SJQO7UJCW/SJQO7UJCW_content_list.json

@@ -0,0 +1,1460 @@
+[
+    {
+        "type": "text",
+        "text": "ADVERSARIAL LEARNING FORSEMI-SUPERVISED SEMANTIC SEGMENTATION",
+        "text_level": 1,
+        "bbox": [
+            176,
+            99,
+            736,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            170,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            234,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We propose a method for semi-supervised semantic segmentation using the adversarial network. While most existing discriminators are trained to classify input images as real or fake on the image level, we design a discriminator in a fully convolutional manner to differentiate the predicted probability maps from the ground truth segmentation distribution with the consideration of the spatial resolution. We show that the proposed discriminator can be used to improve the performance on semantic segmentation by coupling the adversarial loss with the standard cross entropy loss on the segmentation network. In addition, the fully convolutional discriminator enables the semi-supervised learning through discovering the trustworthy regions in prediction results of unlabeled images, providing additional supervisory signals. In contrast to existing methods that utilize weakly-labeled images, our method leverages unlabeled images without any annotation to enhance the segmentation model. Experimental results on both the PASCAL VOC 2012 dataset and the Cityscapes dataset demonstrate the effectiveness of our algorithm. ",
+        "bbox": [
+            233,
+            267,
+            766,
+            460
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            489,
+            336,
+            505
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Semantic segmentation is the task to assign a semantic label, e.g., person, dog, or road, to each pixel in images. It is essential to a wide range of applications, such as autonomous driving and image editing. For decades, many methods have been proposed to tackle this task (Long et al., 2015; Zheng et al., 2015; Liu et al., 2015; Yu & Koltun, 2016; Lin et al., 2016), and abundant standard benchmark datasets have been constructed (Everingham et al., 2010; Mottaghi et al., 2014; Cordts et al., 2016; Zhou et al., 2017), targeting different sets of scene/object categories as well as various real-world applications. However, this task remains challenging because of the object/scene appearance variations, occlusions, and the lack of context understanding. Recently, Convolutional Neural Network (CNN) based methods such as fully convolutional neural network (FCN) (Long et al., 2015) have achieved significant improvement on the task of semantic segmentation, and most state-of-the-art algorithms are based on FCN with advanced modifications and additional modules. ",
+        "bbox": [
+            174,
+            520,
+            825,
+            672
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Although CNN-based approaches have achieved astonishing performance, they require an enormous amount of training data. Different from image classification and object detection, semantic segmentation requires accurate per-pixel annotations for each training image, which can cost considerable expense and time. To ease the effort of acquiring high-quality data, semi/weakly-supervised methods have been applied to the task of semantic segmentation. These methods often assume that there is limited or none per-pixel annotations available, such as additional annotations on the image-level (Pinheiro & Collobert, 2015; Papandreou et al., 2015; Hong et al., 2015; Qi et al., 2016; Pathak et al., 2015a), box-level (Dai et al., 2015), or point-level (Bearman et al., 2016). ",
+        "bbox": [
+            174,
+            680,
+            825,
+            791
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we propose a semi-supervised semantic segmentation algorithm via adversarial learning. The recent success of Generative Adversarial Networks (GANs) (Goodfellow et al., 2014) enables many possibilities for unsupervised and semi-supervised learning. A typical GAN consists of two sub-networks, i.e., generator and discriminator, in which these two sub-networks play a min-max game in the training process. The generator takes a sample vector and outputs a sample of the target data distribution, e.g., human faces, while the discriminator aims to differentiate generated samples from target ones. Then the generator is trained to confuse the discriminator through back-propagation and therefore generates samples that are similar to the target distribution. In this paper, we apply a similar methodology and treat the segmentation network as the generator in a GAN framework. ",
+        "bbox": [
+            174,
+            799,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Different from the typical generators that are trained to generate images given noise vectors, our segmentation network outputs the probability maps of the semantic labels given an input image. Under this setting, we wish to push the outputs of the segmentation network as close as the ground truth label maps spatially. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            160
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To this end, we adopt an adversarial learning scheme and propose a fully convolutional discriminator that learns to differentiate ground truth label maps from probability maps of segmentation predictions. Combined with the spatial cross-entropy loss, our method use an adversarial loss that encourages the segmentation network to produce predicted probability maps close to the ground truth label maps in a high-order structure. The idea is similar to the use of probabilistic graphical models such as Conditional Random Fields (CRFs) (Zheng et al., 2015; Chen et al., 2017; Lin et al., 2016), but without the extra post-processing module during the testing phase. In addition, the discriminator is not required during inference, and hence our proposed framework does not increase any computational power for testing. By employing the adversarial learning, we further take advantage of the proposed fully convolutional discriminator under the semi-supervised setting. ",
+        "bbox": [
+            174,
+            166,
+            825,
+            305
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "One way to allow the discriminator exploiting unlabeled data is to train the segmentation network using the adversarial learning without the cross-entropy loss. However, this approach does not improve the performance according to our experiments because the adversarial loss will aggressively encourage the predictions to be close to the ground truth distribution and neglects the correctness of segmentation. Instead, we utilize the confidence maps generated by our discriminator network as the supervisory signal to guide the cross-entropy loss in a “self-taught” manner. The confidence maps indicate which regions of the prediction distribution are close to the ground truth label distribution, so that the segmentation network can trust these predictions and hence can be trained via a masked cross-entropy loss. By adopting the proposed framework, we show that the segmentation accuracy can be further improved by adding images without any annotations in the domain of labeled images. ",
+        "bbox": [
+            174,
+            313,
+            825,
+            452
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The contributions of this work are as follows. First, we develop an adversarial framework that improves semantic segmentation accuracy without requiring additional computation loads during inference. Second, we facilitate the semi-supervised learning by leveraging the discriminator network response of unlabeled images to aid the training of the segmentation network. Experimental results validate the proposed adversarial framework for semi-supervised semantic segmentation on the PASCAL VOC 2012 (Everingham et al., 2010) and Cityscapes (Cordts et al., 2016) datasets. ",
+        "bbox": [
+            174,
+            458,
+            825,
+            542
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            564,
+            344,
+            580
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Semantic segmentation. Recent state-of-the-art methods for semantic segmentation are based on the rapid development of CNN. As proposed by Long et al. (2015), one can transform a classification CNN, e.g. AlexNet (Krizhevsky et al., 2012), VGG (Simonyan & Zisserman, 2015), or ResNet (He et al., 2016), to a fully-convolutional network (FCN) that tackles the task of semantic segmentation. However, pixel-level annotations are usually expensive and difficult to collect. To reduce the heavy effort of labeling segmentation ground truth, many weakly-supervised approaches are proposed in recent years. In the weakly-supervised setting, the segmentation network is not trained at the pixel level with fully annotated ground truth. Instead, the network is trained with various weak-supervisory signals that are more easily to obtain. Image-level labels are exploited as the supervisory signal in most methods. Pinheiro & Collobert (2015) and Pathak et al. (2015b) use Multiple Instance Learning (MIL) to generate latent segmentation label maps for supervised training. On the other hand, Papandreou et al. (2015) refer to the image-level labels to penalize the prediction of non-existent object classes, while similarly Qi et al. (2016) use object localization to refine the segmentation. Hong et al. (2015) refer to the labeled images to train a classification network as the feature extractor for deconvolution. In addition to image-level supervisions, the segmentation network can also be trained with bounding boxes (Dai et al., 2015; Khoreva et al., 2017), point supervision (Bearman et al., 2016), or web videos (Hong et al., 2017). ",
+        "bbox": [
+            174,
+            597,
+            825,
+            833
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "However, these weakly supervised approaches still fall behind the fully-supervised ones, especially because the detailed boundary information is difficult to infer from these weak-supervisory signals. Hence semi-supervised learning is also considered in some methods to enhance the prediction performance. In such setting, partial fully-annotated data and optional weakly-labeled data are used for the segmentation network training. Hong et al. (2015) jointly train their network with image-level supervised images and few fully-annotated images in the encoder-decoder framework. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            922
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Dai et al. (2015) and Papandreou et al. (2015) also expand their weakly-supervised approaches to the semi-supervised setting for utilizing extra strongly-annotated data. ",
+        "bbox": [
+            173,
+            103,
+            821,
+            132
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Different from the aforementioned methods, our method can leverage unlabeled images in model training, hence greatly saving the cost of manual annotation. In fact, we treat the output of our fully convolutional discriminator as the supervisory signals, which compensate for the absence of image annotations and enable semi-supervised semantic segmentation. Our self-taught learning framework for segmentation is related to Pathak et al. (2015a) where the prediction maps of unlabeled images are used as ground truth. However, in Pathak et al. (2015a), the prediction maps are refined by several hand-designed constraints before training, while we learn the confidence map through the discriminator network as the selection criterion for self-taught learning. ",
+        "bbox": [
+            174,
+            138,
+            825,
+            251
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Generative adversarial networks. After Goodfellow et al. (2014) propose the GAN framework and its theoretical foundation, the GAN draws great attention with several improvements in implementation (Radford et al., 2016; Denton et al., 2015; Arjovsky et al., 2017; Mao et al., 2016; Berthelot et al., 2017). The methodology of adversarial training has been applied to a wide range of applications, including image genration (Radford et al., 2016), image completion (Li et al., 2017), super-resolution (Ledig et al., 2016), object detection (Wang et al., 2017), domain adaptation (Hoffman et al., 2016) and semantic segmentation (Luc et al., 2016; Souly et al., 2017). ",
+        "bbox": [
+            174,
+            257,
+            825,
+            354
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The work closest in scope to ours is the one proposed by Luc et al. (2016), where the adversarial network is used to aid the training for semantic segmentation. However, it does not show substantial improvement over the baseline. On the other hand, Souly et al. (2017) propose to generate adversarial examples using GAN for semi-supervised semantic segmentation, but these generated examples may not be sufficiently close to real images to help the segmentation network. ",
+        "bbox": [
+            174,
+            361,
+            825,
+            431
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 ALGORITHM OVERVIEW ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            452,
+            406,
+            468
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Figure 1 shows the overview of the proposed algorithm. Our system is composed of two networks: the segmentation network and the discriminator network. The former can be any network designed for semantic segmentation, e.g., FCN (Long et al., 2015), DeepLab (Chen et al., 2017), DilatedNet (Yu & Koltun, 2016). Given an input image with dimension $H \\times W \\times 3$ , the segmentation network outputs the class probability maps of size $H \\times W \\times C$ , where $C$ is the number of semantic categories of the target dataset. ",
+        "bbox": [
+            174,
+            479,
+            825,
+            564
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our discriminator network is an FCN-based network, which takes class probability maps as the input, either from the segmentation network or ground truth label maps, and then outputs spatial probability maps with a size of $H \\times W \\times 1$ . Each pixel of the discriminator outputs map represents whether that pixel is sampled from the ground truth label $( p = 1 )$ ) or from the segmentation network $( p = 0$ ). In contrast to the typical GAN discriminators which take fix-sized input images ( $6 4 \\times 6 4$ in most cases) and output a single probability value, we transform our discriminator to a fully-convolutional network that can take inputs of arbitrary sizes. Importantly, we find this transformation is essential to enable the proposed adversarial learning scheme. ",
+        "bbox": [
+            174,
+            570,
+            825,
+            683
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "During the training process, we use both labeled and unlabeled images under the semi-supervised setting. When using the labeled data, the segmentation network is supervised by both the standard cross-entropy loss with the ground truth label map and the adversarial loss with the discriminator network. Note that we train the discriminator network only with the labeled data. ",
+        "bbox": [
+            176,
+            689,
+            825,
+            744
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "For the unlabeled data, we train the segmentation network with the proposed semi-supervised method. After obtaining the initial segmentation prediction of the unlabeled image from the segmentation network, we obtain a confidence map by passing the segmentation prediction through the discriminator network. We in turn treat this confidence map as the supervisory signal using a “self-taught” scheme to train the segmentation network with a masked cross-entropy loss. The intuition is that this confidence map indicates the local quality of the predicted segmentation, so that the segmentation network knows which regions to trust during training. ",
+        "bbox": [
+            174,
+            752,
+            825,
+            851
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "4 SEMI-SUPERVISED TRAINING WITH ADVERSARIAL NETWORK ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            867,
+            722,
+            882
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section, we address the detailed learning scheme of the segmentation and discriminator networks, as well as the designed network architectures. ",
+        "bbox": [
+            174,
+            895,
+            820,
+            922
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/b5dd4ca7c956097b67faeeb23d1d0bf7322a37e58237ea892ed75121fca0199d.jpg",
+        "image_caption": [
+            "Figure 1: Overview of the proposed system for semi-supervised semantic segmentation. With a fully-convolution discriminator network trained using the loss $\\mathcal { L } _ { D }$ , we optimize the segmentation netwrok using three loss functions during the training process: cross-entropy loss $\\mathcal { L } _ { c e }$ , adversarial loss $\\mathcal { L } _ { a d v }$ , and semi-supervised loss $\\mathcal { L } _ { s e m i }$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            117,
+            808,
+            301
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.1 TRAINING OBJECTIVE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            383,
+            369,
+            397
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Given an input image $\\mathbf { X } _ { n }$ of size $H \\times W \\times 3$ , we denote the segmentation network as $S ( \\cdot )$ and the predicted probability map as $S ( \\mathbf { X } _ { n } )$ of size $H \\times W \\times C$ , where $\\textrm { C }$ is the category number. For our fully convolutional discriminator, we denote it as $D ( \\cdot )$ which outputs a two-class confidence map $D ( \\mathbf { P } _ { n } )$ with the size of $H \\times W \\times 1$ , where $\\mathbf { P } _ { n }$ is the class probability map of size $H \\times W \\times C$ , from either the ground truth label $Y _ { n }$ or the segmentation network as $S ( \\mathbf { X } _ { n } )$ . ",
+        "bbox": [
+            173,
+            409,
+            825,
+            481
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Discriminator network training. To train the discriminator network, we minimize the spatial cross-entropy loss $\\mathcal { L } _ { D }$ with respect to two classes. The loss can be formally written as: ",
+        "bbox": [
+            173,
+            486,
+            825,
+            516
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e73a0cb49d8660bab0822a6363d156e9e41abcb7fb1c269f37426699907326e8.jpg",
+        "text": "$$\n\\mathcal { L } _ { D } = - \\sum _ { h , w } \\left( 1 - y _ { n } \\right) \\log ( D ( \\mathbf { P } _ { n } ) ^ { ( h , w , 0 ) } ) + y _ { n } \\log ( D ( \\mathbf { P } _ { n } ) ^ { ( h , w , 1 ) } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            274,
+            534,
+            718,
+            570
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $y _ { n } = 0$ if the sample is drawn from the segmentation network, and $y _ { n } = 1$ if the sample is from the ground truth label. Note that, the discriminator network takes a C-channel probability map as input. In order to convert the ground truth label map $Y _ { n }$ of size $H \\times W \\times 1$ to $\\textrm { C }$ channels, we simply employ one-hot encoding scheme by constructing the probability maps $P _ { n }$ , where $P _ { n } ^ { ( h , w , c ) }$ takes value 1 if Y (h,w)n , and 0 otherwise. ",
+        "bbox": [
+            173,
+            580,
+            825,
+            659
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "One concern raised by (Luc et al., 2016) is that the discriminator network may easily distinguish whether the probability maps come from the ground truth by detecting the one-hot probability. However, we do not observe this phenomenon during the training phase. One reason is that we use a fully-convolutional scheme to predict spatial confidence, which increases the difficulty to learn the discriminator. In addition, we try the Scale scheme proposed in (Luc et al., 2016), where the ground truth probability channel is slightly diffused to other channels according to the distribution of segmentation network output. However, the results show no difference, and thus we do not adopt this scheme in the experiments. ",
+        "bbox": [
+            173,
+            665,
+            825,
+            777
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Segmentation network training. We propose to train the segmentation network via minimizing a multi-task loss function: ",
+        "bbox": [
+            173,
+            784,
+            823,
+            811
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d0c69311ba3dcbe18d4a12c0d1384835a1bf49f8c4e7b9ded1051ff06e09a8aa.jpg",
+        "text": "$$\n\\mathcal { L } _ { s e g } = \\mathcal { L } _ { c e } + \\lambda _ { a d v } \\mathcal { L } _ { a d v } + \\lambda _ { s e m i } \\mathcal { L } _ { s e m i } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            362,
+            820,
+            630,
+            838
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathcal { L } _ { c e }$ , $\\mathcal { L } _ { a d v }$ , and $\\mathcal { L } _ { s e m i }$ denote the spatial multi-class cross entropy loss, the adversarial loss, and the semi-supervised loss, respectively. $\\lambda _ { a d v }$ and $\\lambda _ { s e m i }$ are two constants for balancing the multi-task training. ",
+        "bbox": [
+            174,
+            845,
+            825,
+            888
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We first consider the scenario of using annotated data. Given an input image ${ \\bf X } _ { n }$ , ground truth ${ \\bf Y } _ { n }$ and prediction results ${ \\bf P } _ { n } = S ( { \\bf X } _ { n } )$ , the cross-entropy loss is obtained by: ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/681cd6cccf5d58b2682e0f0b01428dd299c780d867f68621cdd02a9545721113.jpg",
+        "text": "$$\n\\mathcal { L } _ { c e } = - \\sum _ { h , w } \\sum _ { c \\in C } \\mathbf { Y } _ { n } ^ { ( h , w , c ) } \\log ( \\mathbf { P } _ { n } ^ { ( h , w , c ) } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            361,
+            112,
+            635,
+            147
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We adopt the adversarial learning through the adversarial loss $\\mathcal { L } _ { a d v }$ given a fully convolutional discriminator network $D ( \\cdot )$ : ",
+        "bbox": [
+            173,
+            147,
+            823,
+            174
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e63211c04a8634e0b223aa1229ddd356918ee8ccaf030540801ab97536680ab2.jpg",
+        "text": "$$\n\\mathcal { L } _ { a d v } = - \\sum _ { h , w } \\log ( D ( \\mathbf { P } _ { n } ) ^ { ( h , w , 1 ) } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            382,
+            176,
+            616,
+            210
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "With this adversarial loss, we seek to train the segmentation network to fool the discriminator by maximizing the probability of the segmentation prediction being considered as the ground truth distribution. ",
+        "bbox": [
+            173,
+            212,
+            825,
+            253
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Training with unlabeled data. Now we consider the adversarial training under the semi-supervised setting. For unlabeled data, it is obvious that we cannot apply $\\mathcal { L } _ { c e }$ since there is no ground truth annotation available. The adversarial loss $\\mathcal { L } _ { a d v }$ is still applicable as it only requires the discriminator network. However, we find that the performance degenerates when only applying the adversarial loss on unlabeled data without $\\mathcal { L } _ { c e }$ . This is reasonable because the discriminator serves as a regularization and may over-correct the prediction to fit the ground truth distribution. ",
+        "bbox": [
+            173,
+            260,
+            825,
+            344
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Thus, we propose to utilize the trained discriminator with unlabeled data using a “self-taught” strategy. The main idea is that the trained discriminator can generate a confidence map, i.e. $D ( \\mathbf { P } _ { n } ) ^ { ( h , w , 1 ) }$ , which infers the regions where the prediction results are close enough to the ground truth distribution. We then binarize this confidence map with a threshold to highlight the trustworthy region. As a result, we define the self-taught ground truth as the masked segmentation prediction $\\hat { { \\mathbf Y } } _ { n } = a r g m a x ( { \\mathbf P } _ { n } )$ using this binarized confidence map. The resulting semi-supervised loss is defined by: ",
+        "bbox": [
+            173,
+            351,
+            826,
+            438
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/01df98573cbf27cf1e3871fcbc5f6fd69e6058d082ef70d9d99376b5fb289de6.jpg",
+        "text": "$$\n\\mathcal { L } _ { s e m i } = - \\sum _ { h , w } \\sum _ { c \\in C } I ( D ( \\mathbf { P } _ { n } ) ^ { ( h , w , 1 ) } > T _ { s e m i } ) \\cdot \\hat { \\mathbf { Y } } _ { n } ^ { ( h , w , c ) } \\log ( \\mathbf { P } _ { n } ^ { ( h , w , c ) } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            259,
+            438,
+            733,
+            473
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $I ( \\cdot )$ is the indicator function, and $T _ { s e m i }$ is the threshold to control the sensitivity of the self-taught process. Note that during training we treat both the self-taught target $\\hat { { \\mathbf Y } } _ { n }$ and the value of indicator function as constant, and thus (5) can be simply viewed as a masked spatial cross entropy loss. In practice, we find that this strategy works robustly with $T _ { s e m i }$ ranging between 0.1 and 0.3. ",
+        "bbox": [
+            174,
+            474,
+            825,
+            534
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.2 NETWORK ARCHITECTURE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            549,
+            403,
+            563
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Segmentation network. We adopt the DeepLab-v2 (Chen et al., 2017) framework with ResNet101 (He et al., 2016) model pre-trained on the ImageNet dataset (Deng et al., 2009) as our segmentation baseline network. However, we do not employ the multi-scale fusion proposed in Chen et al. (2017) due to the memory concern. Following the practice of recent work on semantic segmentation (Chen et al., 2017; Yu & Koltun, 2016), we remove the last classification layer and modify the stride of the last two convolution layers from 2 to 1, making the resolution of the output feature maps effectively $1 / 8$ times the input image size. To enlarge the receptive fields, we apply the dilated convolution (Yu & Koltun, 2016) in conv4 and conv5 layers with a stride of 2 and 4, respectively. After the last layer, we employ the Atrous Spatial Pyramid Pooling (ASPP) proposed in Chen et al. (2017) as the final classifier. Finally, we apply an up-sampling layer along with the softmax output to match the size of the input image. ",
+        "bbox": [
+            173,
+            574,
+            826,
+            728
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Discriminator network. For the discriminator network, we follow the structure used in Radford et al. (2016). It consists of 5 convolution layers with kernel $4 \\times 4$ with channel numbers {64, 128, 256, 512, 1} and stride of 2. Each convolution layer is followed by a Leaky-ReLU (Maas et al., 2013) parameterized by 0.2 except the last layer. To transform the network to a fully convolutional network, an up-sampling layer is added to the last layer to rescale the output to the size of the input map. Note that we do not employ the batch-normalization layers. We find that the batch-normalization layer (Ioffe & Szegedy, 2015) is highly unstable since the system can be only trained with a small batch size. ",
+        "bbox": [
+            173,
+            734,
+            825,
+            845
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "5 EXPERIMENTAL RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            864,
+            418,
+            881
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Implementation details. We implement our network using the PyTorch framework. We train our system on a single TitanX GPU with 12 GB memory. To train the segmentation network, we use ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/3d2b289bb5f0cbc73b8a27f8fa7232c0bc818c572ea9b3f392955b9c567e4946.jpg",
+        "table_caption": [
+            "Table 1: Results on the VOC 2012 validation set. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"4\">Data Amount</td></tr><tr><td>Methods</td><td>1/8</td><td>1/4</td><td>1/2</td><td>Full</td></tr><tr><td>FCN-8s (Long et al.,2015)</td><td>N/A</td><td>N/A</td><td>N/A</td><td>67.2</td></tr><tr><td>Dilationl0(Yu&amp; Koltun,2016)</td><td>N/A</td><td>N/A</td><td>N/A</td><td>73.9</td></tr><tr><td>DeepLab-v2 (Chen et al.,2017)</td><td>N/A</td><td>N/A</td><td>N/A</td><td>77.7</td></tr><tr><td>our baseline</td><td>66.0</td><td>68.3</td><td>69.8</td><td>73.6</td></tr><tr><td>baseline+Ladu</td><td>67.6</td><td>71.0</td><td>72.6</td><td>74.9</td></tr><tr><td>baseline+Ladu +Lsemi</td><td>68.8</td><td>71.6</td><td>73.2</td><td>N/A</td></tr></table>",
+        "bbox": [
+            173,
+            127,
+            500,
+            231
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/7cf7376114245046626b583508710d8672d6d8059bab7a9dad6b0cf07886128a.jpg",
+        "table_caption": [
+            "Table 2: Results on the Cityscapes validation set. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"4\">Data Amount</td></tr><tr><td>Methods</td><td>1/8</td><td>1/4</td><td>1/2</td><td>Full</td></tr><tr><td>FCN-8s (Long et al., 2015)</td><td>N/A</td><td>N/A</td><td>N/A</td><td>65.3</td></tr><tr><td>Dilationi0 (Yu &amp; Koltun,2016)</td><td>N/A</td><td>N/A</td><td>N/A</td><td>67.1</td></tr><tr><td>DeepLab-v2 (Chen et al.,2017)</td><td>N/A</td><td>N/A</td><td>N/A</td><td>70.4</td></tr><tr><td>our baseline</td><td>52.4</td><td>58.3</td><td>62.6</td><td>66.4</td></tr><tr><td>baseline+Ladu</td><td>53.8</td><td>59.1</td><td>63.7</td><td>67.7</td></tr><tr><td>baseline+Ladu +Lsemi</td><td>54.2</td><td>59.7</td><td>64.5</td><td>N/A</td></tr></table>",
+        "bbox": [
+            506,
+            127,
+            830,
+            229
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Stochastic Gradient Descent (SGD) with Nesterov acceleration as the optimizer, where the momentum is 0.9 and the weight decay is $1 0 ^ { - 4 }$ . The initial learning rate is set as $2 . 5 \\times 1 0 ^ { - 4 }$ and is decreased with polynomial decay with power of 0.9 as mentioned in Chen et al. (2017). For training the discriminator, we adopt Adam optimizer (Kingma & Ba, 2014) with the learning rate as $1 0 ^ { - 4 }$ and the same polynomial decay as the segmentation network. The momentum is set as 0.9 and 0.999. ",
+        "bbox": [
+            174,
+            268,
+            825,
+            338
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For semi-supervised training, we randomly interleave the labeled data and unlabeled data iteratively and apply the training scheme described in section 4.1 accordingly. We update both the segmentation network and discriminator network jointly. In each iteration, only the batch containing the ground truth data are used for training the discriminator. When randomly sampling partial labeled and unlabeled data from the datasets, we average several experiment results with different random seeds to ensure the evaluation robustness. ",
+        "bbox": [
+            174,
+            345,
+            825,
+            429
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Evaluation datasets and metric. In this work, we conduct experiments on two semantic segmentation datasets: PASCAL VOC 2012 (Everingham et al., 2010) and Cityscapes (Cordts et al., 2016). While the PASCAL VOC dataset contains common objects in photos captured in daily activities, the Cityscapes dataset mainly targets urban street scenes. On both datasets, we use the mean intersection-over-union (mean IU) as the evaluation metric. ",
+        "bbox": [
+            174,
+            436,
+            825,
+            506
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The PASCAL VOC 2012 dataset is a commonly used evaluation dataset for semantic segmentation. It comprises 20 common objects with annotations on daily captured photos. We use the extra annotation set in SBD (Hariharan et al., 2011), resulting in 10,582 training images. We evaluate our models on the standard validation set with 1449 images. During training, we employ the random scaling and cropping with size $3 2 1 \\times 3 2 1$ . We train each model on the PASCAL VOC dataset for 20k iterations with batch size 10. ",
+        "bbox": [
+            174,
+            513,
+            825,
+            597
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The Cityscapes dataset has 50 videos with driving scenes, and 2975, 500, 1525 images are extracted and annotated with 19 classes for training, validation, and testing, respectively. Each annotated frame is the $2 0 ^ { t h }$ frame in a 30-frames snippet, where only these images with annotations are considered in the training process. We resize the input image to $5 1 2 \\times 1 0 2 4$ without any random cropping/scaling. We train each model on the Cityscapes dataset for $4 0 \\mathrm { k }$ iterations with batch size 2. ",
+        "bbox": [
+            174,
+            603,
+            825,
+            672
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Results on the PASCAL VOC 2012 dataset. Table 1 shows the evaluation results on the PASCAL VOC 2012 dataset. To validate the semi-supervising scheme, we randomly sample 1/8, 1/4, 1/2 images as labeled, and used the rest of training images as the unlabeled data. We show the performance comparisons with FCN (Long et al., 2015), Dilation10 (Yu & Koltun, 2016), and DeepLab-v2 (Chen et al., 2017) to demonstrate that our baseline model is comparable with other state-of-the-art methods. Note that our baseline model is equivalent to the DeepLab-v2 model without multi-scale fusion. The adversarial loss brings consistent performance improvement $( 1 . 6 \\% - 2 . 8 \\% )$ over different amounts of training data. Incorporating the proposed semi-supervised learning scheme brings overall $2 . 8 \\% - 3 . 4 \\%$ improvement. Figure 2 shows visual comparisons of the segmentation results generated by the proposed method. We observe that the segmentation boundary has significant improvement when compared to the baseline model. ",
+        "bbox": [
+            173,
+            680,
+            825,
+            833
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Results on the Cityscapes dataset. Table 2 shows evaluation results on the Cityscapes dataset. By applying the adversarial loss $\\mathcal { L } _ { a d v }$ , the model achieves $0 . 8 \\% - 1 . 4 \\%$ gain over the baseline model under the semi-supervised setting. This shows that our adversarial training scheme can encourage the segmentation network to learn the structural information from the ground truth distribution. Combining the adversarial learning and proposed semi-supervised learning, the performance further improves with overall $1 . 4 \\% - 1 . 9 \\%$ mean IU gain. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/ad761a8eb8df14912d63bd76a3a14905ae6ebd66914a0c05acbdd1e29c0249aa.jpg",
+        "image_caption": [
+            "Figure 2: Comparisons on the PASCAL VOC 2012 dataset using 1/2 labeled data. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            161,
+            101,
+            823,
+            318
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/e1e460bb9ed10582b06b3abb2e95cfcd36804e0806956e9e2ec118668fa782be.jpg",
+        "table_caption": [
+            "Table 3: Adversarial learning comparison with Luc et al. (2016) on VOC 2012 validation set. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>Baseline</td><td>Adversarial</td></tr><tr><td>Luc et al. (2016)</td><td>71.8</td><td>72.0</td></tr><tr><td>ours</td><td>73.6</td><td>74.9</td></tr></table>",
+        "bbox": [
+            218,
+            425,
+            449,
+            472
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/c5f33a5d2811efb6278ab1eaa6b6aaa6607d247e4d6475da45fb29faf098a154.jpg",
+        "table_caption": [
+            "Table 4: Semi-supervised learning comparisons on VOC 2012 validation set without using additional labels of SBD. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>Data Amount</td><td>Fully- supervised</td><td>Semi- supervised</td></tr><tr><td>Papandreou et al. (2015)</td><td>Full</td><td>62.5</td><td>64.6</td></tr><tr><td>Souly et al. (2017)</td><td>Full</td><td>59.5</td><td>64.1</td></tr><tr><td>ours</td><td>Full</td><td>66.3</td><td>68.4</td></tr><tr><td>Souly et al. (2017)</td><td>30%</td><td>38.9</td><td>42.2</td></tr><tr><td>ours</td><td>30%</td><td>57.4</td><td>60.6</td></tr></table>",
+        "bbox": [
+            503,
+            424,
+            831,
+            517
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Comparisons with state-of-the-art methods Table 3 shows comparisons with Luc et al. (2016) that utilizes adversarial learning. There are major design differences of the adversarial learning step between Luc et al. (2016) and our method. First, we design a universal discriminator for various datasets, while Luc et al. (2016) utilizes different network structures for different datasets. Second, our discriminator is not required to take the RGB image as an additional input but directly work on the prediction map from the segmentation network. In Table 3, our method achieves $1 . 2 \\%$ gain in mean IU, which is significantly better then the gain in Luc et al. (2016). ",
+        "bbox": [
+            173,
+            554,
+            825,
+            652
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We show comparisons for the semi-supervised setting in Table 4. To compare with Papandreou et al. (2015) and Souly et al. (2017), we train our model on the original PASCAL VOC 2012 train set (1464 images) and use the SBD (Hariharan et al., 2011) set as unlabeled data. It is worth noting that in Papandreou et al. (2015), image-level labels are available for the SBD (Hariharan et al., 2011) set, and in Souly et al. (2017), additional unlabeled images are generated through their generator during the training stage. ",
+        "bbox": [
+            174,
+            659,
+            825,
+            743
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Hyper-parameter analysis. The proposed algorithm is parametrized by three hyper parameters: $\\lambda _ { a d v }$ and $\\lambda _ { s e m i }$ are two parameters for balancing the multi-task learning in (2), and $T _ { s e m i }$ is used to control the sensitivity in the semi-supervised learning described in (5). We evaluate these hyper parameters using the PASCAL VOC dataset under the fully/semi-supervised setting. We show comparison results of different parameter settings in Table 5. We first evaluate the effect on $\\lambda _ { a d v }$ using fully-supervised setting. Note that we do not use any unlabeled data, i.e. $\\lambda _ { s e m i } = 0$ . The baseline model without adversarial learning $\\begin{array} { r } { { } ^ { \\prime } \\lambda _ { a d v } = 0 } \\end{array}$ ) achieves $7 3 . 6 \\%$ mean IU. When $\\lambda _ { a d v } = 0 . 0 1$ , the model achieves $7 4 . 9 \\%$ mean IU with $1 . 3 \\%$ improvement. When $\\lambda _ { a d v } = 0 . 0 5$ , the performance deprecates to $7 3 . 0 \\%$ mean IU, which indicates that the adversarial loss is too large. ",
+        "bbox": [
+            173,
+            750,
+            825,
+            875
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Second, we show comparisons of different values of $\\lambda _ { s e m i }$ with 1/8 amount of data under the semisupervised setting. We set $\\lambda _ { a d v } = 0 . 0 1$ and $T _ { s e m i } = 0 . 2$ for the comparisons. Overall, $\\lambda _ { s e m i } = 0 . 1$ achieves the best performance of $6 8 . 8 \\%$ mean IU with $1 . 2 \\%$ gain. ",
+        "bbox": [
+            176,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/155186d45f56a986f5493901ce8e03360e5280cab7564bd958e197faab5f239b.jpg",
+        "image_caption": [
+            "Figure 3: Visualization of the confidence maps. Given the probability maps generated by the segmentation network, the confidence maps is then obtained from the discriminator. In the confidence maps, the brighter regions indicate that they are close to the ground truth distribution. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            209,
+            98,
+            789,
+            218
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Lastly, we perform the experiments with different value of $T _ { s e m i }$ , where we set $\\lambda _ { a d v } = 0 . 0 1$ and $\\lambda _ { s e m i } = 0 . 1$ . High $T _ { s e m i }$ suggests that we only trust regions of high structural similarity as the ground truth distribution. We find that our proposed strategy performs well for a wide range of values $T _ { s e m i }$ (0.1 to 0.3). The method performs the best when $T _ { s e m i } = 0 . 2$ . When $T _ { s e m i } = 0$ , we trust all the pixel predictions in unlabeled images, resulting in performance degradation. In Figure 3, we show the visualization of generated confidence maps given the predicted probability maps. ",
+        "bbox": [
+            173,
+            297,
+            825,
+            382
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Ablation study. We present the ablation study of our proposed system in Table 6 on the PASCAL VOC dataset. First, we examine the impact of using fully convolutional discriminator (FCD). To construct a discriminator that is not fully-convolutional, we replace the last convolution layer of the discriminator with a fully-connected layer that outputs a single neuron as in typical GAN models. Without using FCD, the performance drops $1 . 0 \\%$ using full data and $0 . 9 \\%$ with 1/8 data. This shows that the use of FCD is essential to the adversarial learning. Second, we apply the semi-supervised learning method without the adversarial loss. The results show that the adversarial training on the labeled data is important to our semi-supervised scheme. If the segmentation network does not seek to fool the discriminator, the confidence maps generated by the discriminator would be meaningless, providing weaker supervisory signals. ",
+        "bbox": [
+            173,
+            388,
+            826,
+            529
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/7d6dae6ea78ffa7cb4cbe483a04d43e2e3f6ec523fee5303eab692ea3775a190.jpg",
+        "table_caption": [
+            "Table 5: Hyper parameter analysis. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Data Amount</td><td>Xadu</td><td>Xsemi</td><td>Tsemi</td><td>Mean IU</td></tr><tr><td>Full</td><td>0</td><td>0</td><td>N/A</td><td>73.6</td></tr><tr><td>Full</td><td>0.005</td><td>0</td><td>N/A</td><td>74.0</td></tr><tr><td>Full</td><td>0.01</td><td>0</td><td>N/A</td><td>74.9</td></tr><tr><td>Full</td><td>0.02</td><td>0</td><td>N/A</td><td>74.6</td></tr><tr><td>Full</td><td>0.04</td><td>0</td><td>N/A</td><td>74.1</td></tr><tr><td>Full</td><td>0.05</td><td>0</td><td>N/A</td><td>73.0</td></tr><tr><td>1/8</td><td>0.01</td><td>0</td><td>N/A</td><td>67.6</td></tr><tr><td>1/8</td><td>0.01</td><td>0.05</td><td>0.2</td><td>68.6</td></tr><tr><td>1/8</td><td>0.01</td><td>0.1</td><td>0.2</td><td>68.8</td></tr><tr><td>1/8</td><td>0.01</td><td>0.2</td><td>0.2</td><td>68.5</td></tr><tr><td>1/8</td><td>0.01</td><td>0.1</td><td>0</td><td>66.5</td></tr><tr><td>1/8</td><td>0.01</td><td>0.1</td><td>0.1</td><td>68.0</td></tr><tr><td>1/8</td><td>0.01</td><td>0.1</td><td>0.2</td><td>68.8</td></tr><tr><td>1/8</td><td>0.01</td><td>0.1</td><td>0.3</td><td>68.7</td></tr><tr><td>1/8</td><td>0.01</td><td>0.1</td><td>1.0</td><td>67.6</td></tr></table>",
+        "bbox": [
+            184,
+            574,
+            483,
+            763
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/c82db825d687afa1b21f6bff9caddf10a3641dcd311f3b8c5ea45fcced0755a0.jpg",
+        "table_caption": [
+            "Table 6: Ablation study of the proposed method on the PASCAL VOC dataset. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Ladu</td><td>Lsemi</td><td>FCD</td><td>Data Amount 1/8</td><td>Full</td></tr><tr><td></td><td></td><td></td><td>66.0</td><td>73.6</td></tr><tr><td>√</td><td></td><td>1</td><td>67.6</td><td>74.9</td></tr><tr><td></td><td></td><td></td><td>66.6</td><td>74.0</td></tr><tr><td></td><td>V</td><td>?</td><td>65.7</td><td>N/A</td></tr><tr><td>√</td><td></td><td></td><td>68.8</td><td>N/A</td></tr></table>",
+        "bbox": [
+            549,
+            628,
+            779,
+            722
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSIONS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            794,
+            328,
+            810
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this work, we propose an adversarial learning scheme for semi-supervised semantic segmentation. We train a fully convolutional discriminator network to enhance the segmentation network with both labeled and unlabeled data. With labeled data, the adversarial loss for the segmentation network is designed to learn higher order structural information without post-processing. For unlabeled data, the confidence maps generated by the discriminator network act as the self-taught signal for refining the segmentation network. Extensive experiments on the PASCAL VOC 2012 dataset and on the Cityscapes dataset are performed to validate the effectiveness of the proposed algorithm. ",
+        "bbox": [
+            173,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            287,
+            118
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Martin Arjovsky, Soumith Chintala, and Léon Bottou. Wasserstein gan. arXiv preprint arXiv:1701.07875, 2017. ",
+        "bbox": [
+            173,
+            126,
+            825,
+            155
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Amy Bearman, Olga Russakovsky, Vittorio Ferrari, and Li Fei-Fei. What’s the point: Semantic segmentation with point supervision. In ECCV, 2016. ",
+        "bbox": [
+            173,
+            165,
+            823,
+            194
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "David Berthelot, Tom Schumm, and Luke Metz. Began: Boundary equilibrium generative adversarial networks. arXiv preprint arXiv:1703.10717, 2017. ",
+        "bbox": [
+            171,
+            204,
+            823,
+            233
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Liang-Chieh Chen, George Papandreou, Iasonas Kokkinos, Kevin Murphy, and Alan L Yuille. Deeplab: Semantic image segmentation with deep convolutional nets, atrous convolution, and fully connected crfs. In TPAMI, 2017. ",
+        "bbox": [
+            174,
+            242,
+            823,
+            286
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Marius Cordts, Mohamed Omran, Sebastian Ramos, Timo Rehfeld, Markus Enzweiler, Rodrigo Benenson, Uwe Franke, Stefan Roth, and Bernt Schiele. The cityscapes dataset for semantic urban scene understanding. In CVPR, 2016. ",
+        "bbox": [
+            173,
+            295,
+            823,
+            339
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jifeng Dai, Kaiming He, and Jian Sun. Boxsup: Exploiting bounding boxes to supervise convolutional networks for semantic segmentation. In ICCV, 2015. ",
+        "bbox": [
+            173,
+            348,
+            823,
+            378
+        ],
+        "page_idx": 8
+    },
+    {
+        "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 CVPR, 2009. ",
+        "bbox": [
+            173,
+            387,
+            823,
+            416
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Emily L Denton, Soumith Chintala, Rob Fergus, et al. Deep generative image models using a laplacian pyramid of adversarial networks. In NIPS, 2015. ",
+        "bbox": [
+            169,
+            426,
+            823,
+            457
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Mark Everingham, Luc Van Gool, Christopher KI Williams, John Winn, and Andrew Zisserman. The pascal visual object classes (voc) challenge. In IJCV, 2010. ",
+        "bbox": [
+            169,
+            465,
+            823,
+            496
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In NIPS, 2014. ",
+        "bbox": [
+            171,
+            505,
+            825,
+            534
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Bharath Hariharan, Pablo Arbeláez, Lubomir Bourdev, Subhransu Maji, and Jitendra Malik. Semantic contours from inverse detectors. In ICCV, 2011. ",
+        "bbox": [
+            174,
+            542,
+            821,
+            573
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, 2016. ",
+        "bbox": [
+            174,
+            582,
+            821,
+            612
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Judy Hoffman, Dequan Wang, Fisher Yu, and Trevor Darrell. Fcns in the wild: Pixel-level adversarial and constraint-based adaptation. In arXiv preprint arXiv:1612.02649, 2016. ",
+        "bbox": [
+            173,
+            621,
+            823,
+            651
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Seunghoon Hong, Hyeonwoo Noh, and Bohyung Han. Decoupled deep neural network for semisupervised semantic segmentation. In NIPS, 2015. ",
+        "bbox": [
+            174,
+            661,
+            823,
+            690
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Seunghoon Hong, Donghun Yeo, Suha Kwak, Honglak Lee, and Bohyung Han. Weakly supervised semantic segmentation using web-crawled videos. In CVPR, 2017. ",
+        "bbox": [
+            173,
+            699,
+            823,
+            729
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In ICML, 2015. ",
+        "bbox": [
+            171,
+            739,
+            823,
+            768
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "A. Khoreva, R. Benenson, J. Hosang, M. Hein, and B. Schiele. Simple does it: Weakly supervised instance and semantic segmentation. In CVPR, 2017. ",
+        "bbox": [
+            171,
+            777,
+            823,
+            808
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In arXiv preprint arXiv:1412.6980, 2014. ",
+        "bbox": [
+            173,
+            816,
+            823,
+            847
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Mateusz Kozinski, Loïc Simon, and Frédéric Jurie. An adversarial regularisation for semi-supervised ´ training of structured output neural networks. In arXiv preprint arXiv:1702.02382, 2017. ",
+        "bbox": [
+            173,
+            856,
+            823,
+            886
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. In NIPS, 2012. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Christian Ledig, Lucas Theis, Ferenc Huszár, Jose Caballero, Andrew Cunningham, Alejandro Acosta, Andrew Aitken, Alykhan Tejani, Johannes Totz, Zehan Wang, et al. Photo-realistic single image super-resolution using a generative adversarial network. In arXiv preprint arXiv:1609.04802, 2016. ",
+        "bbox": [
+            174,
+            103,
+            826,
+            159
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yijun Li, Sifei Liu, Jimei Yang, and Ming-Hsuan Yang. Generative face completion. In CVPR, 2017. ",
+        "bbox": [
+            174,
+            166,
+            825,
+            183
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Guosheng Lin, Chunhua Shen, Anton van dan Hengel, and Ian Reid. Efficient piecewise training of deep structured models for semantic segmentation. In CVPR, 2016. ",
+        "bbox": [
+            174,
+            189,
+            823,
+            217
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ziwei Liu, Xiaoxiao Li, Ping Luo, Chen Change Loy, and Xiaoou Tang. Semantic Image Segmentation via Deep Parsing Network. In ICCV, 2015. ",
+        "bbox": [
+            174,
+            224,
+            823,
+            253
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jonathan Long, Evan Shelhamer, and Trevor Darrell. Fully convolutional networks for semantic segmentation. In CVPR, 2015. ",
+        "bbox": [
+            174,
+            260,
+            823,
+            289
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Pauline Luc, Camille Couprie, Soumith Chintala, and Jakob Verbeek. Semantic segmentation using adversarial networks. In NIPS Workshop on Adversarial Training, 2016. ",
+        "bbox": [
+            174,
+            296,
+            821,
+            325
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Andrew L Maas, Awni Y Hannun, and Andrew Y Ng. Rectifier nonlinearities improve neural network acoustic models. In ICML, 2013. ",
+        "bbox": [
+            173,
+            330,
+            821,
+            361
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Xudong Mao, Qing Li, Haoran Xie, Raymond YK Lau, and Zhen Wang. Multi-class generative adversarial networks with the l2 loss function. arXiv preprint arXiv:1611.04076, 2016. ",
+        "bbox": [
+            173,
+            367,
+            823,
+            396
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Roozbeh Mottaghi, Xianjie Chen, Xiaobai Liu, Nam-Gyu Cho, Seong-Whan Lee, Sanja Fidler, Raquel Urtasun, and Alan Yuille. The Role of Context for Object Detection and Semantic Segmentation in the Wild. In CVPR, 2014. ",
+        "bbox": [
+            178,
+            402,
+            823,
+            445
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "George Papandreou, Liang-Chieh Chen, Kevin Murphy, and Alan L Yuille. Weakly-and semisupervised learning of a dcnn for semantic image segmentation. In ICCV, 2015. ",
+        "bbox": [
+            173,
+            452,
+            823,
+            482
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Deepak Pathak, Philipp Krahenbuhl, and Trevor Darrell. Constrained convolutional neural networks for weakly supervised segmentation. In ICCV, 2015a. ",
+        "bbox": [
+            174,
+            488,
+            823,
+            517
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Deepak Pathak, Evan Shelhamer, Jonathan Long, and Trevor Darrell. Fully convolutional multi-class multiple instance learning. In ICLR, 2015b. ",
+        "bbox": [
+            174,
+            523,
+            823,
+            553
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Pedro O Pinheiro and Ronan Collobert. Weakly supervised semantic segmentation with convolutional networks. In CVPR, 2015. ",
+        "bbox": [
+            176,
+            559,
+            823,
+            589
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Xiaojuan Qi, Zhengzhe Liu, Jianping Shi, Hengshuang Zhao, and Jiaya Jia. Augmented feedback in semantic segmentation under image level supervision. In ECCV, 2016. ",
+        "bbox": [
+            174,
+            595,
+            821,
+            625
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alec Radford, Luke Metz, and Soumith Chintala. Unsupervised representation learning with deep convolutional generative adversarial networks. In ICLR, 2016. ",
+        "bbox": [
+            173,
+            631,
+            823,
+            660
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. In ICLR, 2015. ",
+        "bbox": [
+            173,
+            666,
+            823,
+            695
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nasim Souly, Concetto Spampinato, and Mubarak Shah. Semi and weakly supervised semantic segmentation using generative adversarial network. In ICCV, 2017. ",
+        "bbox": [
+            173,
+            703,
+            823,
+            731
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Xiaolong Wang, Abhinav Shrivastava, and Abhinav Gupta. A-fast-rcnn: Hard positive generation via adversary for object detection. In CVPR, 2017. ",
+        "bbox": [
+            176,
+            738,
+            823,
+            767
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Fisher Yu and Vladlen Koltun. Multi-scale context aggregation by dilated convolutions. In ICLR, 2016. ",
+        "bbox": [
+            173,
+            773,
+            823,
+            803
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hengshuang Zhao, Jianping Shi, Xiaojuan Qi, Xiaogang Wang, and Jiaya Jia. Pyramid scene parsing network. In CVPR, 2017. ",
+        "bbox": [
+            173,
+            809,
+            825,
+            839
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Shuai Zheng, Sadeep Jayasumana, Bernardino Romera-Paredes, Vibhav Vineet, Zhizhong Su, Dalong Du, Chang Huang, and Philip HS Torr. Conditional random fields as recurrent neural networks. In ICCV, 2015. ",
+        "bbox": [
+            173,
+            845,
+            823,
+            887
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Bolei Zhou, Hang Zhao, Xavier Puig, Sanja Fidler, Adela Barriuso, and Antonio Torralba. Semantic understanding of scenes through the ade20k dataset. In CVPR, 2017. ",
+        "bbox": [
+            173,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "A OVERVIEW ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            302,
+            117
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "In this appendix, we present additional results of the proposed method. First, we provide the detailed training parameters for both evaluation datasets. Second, we show more qualitative comparisons of our proposed method on both the PASCAL VOC dataset (Everingham et al., 2010) and on the Cityscapes dataset (Cordts et al., 2016). ",
+        "bbox": [
+            174,
+            133,
+            825,
+            189
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "B TRAINING PARAMETERS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            209,
+            413,
+            226
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "table",
+        "img_path": "images/ae76a182041a01d5eb2c8fe63991ea6cecf90e1bdce346c64e3825ed723dd380.jpg",
+        "table_caption": [
+            "Table 7: Training parameters. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Parameter</td><td>Cityscaps</td><td>PASCAL VOC</td></tr><tr><td>Trained iterations</td><td>40,000</td><td>20.000</td></tr><tr><td>Learning rate</td><td>2.5e-4</td><td>2.5e-4</td></tr><tr><td>Learning rate (D)</td><td>1e-4</td><td>1e-4</td></tr><tr><td>Polynomial decay</td><td>0.9</td><td>0.9</td></tr><tr><td>Momentum</td><td>0.9</td><td>0.9</td></tr><tr><td>Optimizer</td><td>SGD</td><td>SGD</td></tr><tr><td>Optimizer (D)</td><td>Adam</td><td>Adam</td></tr><tr><td>Nesterov</td><td>True</td><td>True</td></tr><tr><td>Batch size</td><td>2</td><td>10</td></tr><tr><td>Weight decay</td><td>0.0001</td><td>0.0001</td></tr><tr><td>Crop size</td><td>512x1024</td><td>321x321</td></tr><tr><td>Random scale</td><td>No</td><td>Yes</td></tr></table>",
+        "bbox": [
+            326,
+            271,
+            671,
+            467
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "C ADDITIONAL QUALITATIVE RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            496,
+            519,
+            513
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "In Figure 4-5, we show the additional qualitative comparisons with the models using half training data of the PSCAL VOC dataset. In Figure 6, we also show the additional qualitative comparisons with the models using half training data of the Cityscapes dataset. The results show that both the adversarial learning and the semi-supervised training scheme can improve the performance of the semantic segmentation. ",
+        "bbox": [
+            173,
+            527,
+            825,
+            598
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/cefabd5956e18f6cf7a062db36f055bdf8def3425b8f2cac2fbbcd5bb44a5ce7.jpg",
+        "image_caption": [
+            "Figure 4: Comparisons on the PASCAL VOC dataset using 1/2 training data. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            161,
+            126,
+            823,
+            869
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/baec1e35d25251138549eecd7afc120fdd14b8e429ee7573c0d890f121e7f204.jpg",
+        "image_caption": [
+            "Figure 5: Comparisons on the PASCAL VOC dataset using $1 / 2$ training data. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            160,
+            122,
+            825,
+            873
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/65189e788827896e2bd401a87b6150de7fa2fae8da2729334991e522feac8ac7.jpg",
+        "image_caption": [
+            "Figure 6: Comparisons on the Cityscapes dataset using 1/2 training data. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            158,
+            252,
+            823,
+            744
+        ],
+        "page_idx": 13
+    }
+]

parse/train/SJe5P6EYvS/SJe5P6EYvS.md

@@ -0,0 +1,270 @@
+# MOGRIFIER LSTM
+
+Gábor Melis†, Tomáš Kociskýˇ †, Phil Blunsom†‡   
+{melisgl,tkocisky,pblunsom}@google.com   
+†DeepMind, London, UK   
+‡University of Oxford
+
+# ABSTRACT
+
+Many advances in Natural Language Processing have been based upon more expressive models for how inputs interact with the context in which they occur. Recurrent networks, which have enjoyed a modicum of success, still lack the generalization and systematicity ultimately required for modelling language. In this work, we propose an extension to the venerable Long Short-Term Memory in the form of mutual gating of the current input and the previous output. This mechanism affords the modelling of a richer space of interactions between inputs and their context. Equivalently, our model can be viewed as making the transition function given by the LSTM context-dependent. Experiments demonstrate markedly improved generalization on language modelling in the range of 3–4 perplexity points on Penn Treebank and Wikitext-2, and 0.01–0.05 bpc on four character-based datasets. We establish a new state of the art on all datasets with the exception of Enwik8, where we close a large gap between the LSTM and Transformer models.
+
+# 1 INTRODUCTION
+
+The domination of Natural Language Processing by neural models is hampered only by their limited ability to generalize and questionable sample complexity (Belinkov and Bisk 2017; Jia and Liang 2017; Iyyer et al. 2018; Moosavi and Strube 2017; Agrawal et al. 2016), their poor grasp of grammar (Linzen et al. 2016; Kuncoro et al. 2018), and their inability to chunk input sequences into meaningful units (Wang et al. 2017). While direct attacks on the latter are possible, in this paper, we take a language-agnostic approach to improving Recurrent Neural Networks (RNN, Rumelhart et al. (1988)), which brought about many advances in tasks such as language modelling, semantic parsing, machine translation, with no shortage of non-NLP applications either (Bakker 2002; Mayer et al. 2008). Many neural models are built from RNNs including the sequence-to-sequence family (Sutskever et al. 2014) and its attention-based branch (Bahdanau et al. 2014). Thus, innovations in RNN architecture tend to have a trickle-down effect from language modelling, where evaluation is often the easiest and data the most readily available, to many other tasks, a trend greatly strengthened by ULMFiT (Howard and Ruder 2018), ELMo (Peters et al. 2018) and BERT (Devlin et al. 2018), which promote language models from architectural blueprints to pretrained building blocks.
+
+To improve the generalization ability of language models, we propose an extension to the LSTM (Hochreiter and Schmidhuber 1997), where the LSTM’s input $_ { \textbf { \em x } }$ is gated conditioned on the output of the previous step $h _ { p r e \nu }$ . Next, the gated input is used in a similar manner to gate the output of the previous time step. After a couple of rounds of this mutual gating, the last updated $_ { \textbf { \em x } }$ and $h _ { p r e \nu }$ are fed to an LSTM. By introducing these additional of gating operations, in one sense, our model joins the long list of recurrent architectures with gating structures of varying complexity which followed the invention of Elman Networks (Elman 1990). Examples include the LSTM, the GRU (Chung et al. 2015), and even designs by Neural Architecture Search (Zoph and Le 2016).
+
+Intuitively, in the lowermost layer, the first gating step scales the input embedding (itself a representation of the average context in which the token occurs) depending on the actual context, resulting in a contextualized representation of the input. While intuitive, as Section 4 shows, this interpretation cannot account for all the observed phenomena.
+
+In a more encompassing view, our model can be seen as enriching the mostly additive dynamics of recurrent transitions placing it in the company of the Input Switched Affine Network (Foerster et al.
+
+![](images/03ac0eaf76ca9eebf998b34dc19ba7c3c3b647e303574f64b850206fb20b6bc1.jpg)  
+Figure 1: Mogrifier with 5 rounds of updates. The previous state $\pmb { h } ^ { 0 } = \pmb { h } _ { p r e \nu }$ is transformed linearly (dashed arrows), fed through a sigmoid and gates ${ \pmb x } ^ { - 1 } = { \pmb x }$ in an elementwise manner producing $\mathbf { x } ^ { 1 }$ . Conversely, the linearly transformed $\mathbf { x } ^ { 1 }$ gates $ { \boldsymbol { h } } ^ { 0 }$ and produces $\boldsymbol { h } ^ { 2 }$ . After a number of repetitions of this mutual gating cycle, the last values of $\boldsymbol { h } ^ { * }$ and $\pmb { x } ^ { * }$ sequences are fed to an LSTM cell. The prev subscript of $^ { h }$ is omitted to reduce clutter.
+
+2017) with a separate transition matrix for each possible input, and the Multiplicative RNN (Sutskever et al. 2011), which factorizes the three-way tensor of stacked transition matrices. Also following this line of research are the Multiplicative Integration LSTM (Wu et al. 2016) and – closest to our model in the literature – the Multiplicative LSTM (Krause et al. 2016). The results in Section 3.4 demonstrate the utility of our approach, which consistently improves on the LSTM and establishes a new state of the art on all but the largest dataset, Enwik8, where we match similarly sized transformer models.
+
+# 2 MODEL
+
+To allow for ease of subsequent extension, we present the standard LSTM update (Sak et al. 2014) with input and state of size $m$ and $n$ respectively as the following function:
+
+$$
+\begin{array} { r l } & { \mathrm { L S T M } \colon \mathbb { R } ^ { m } \times \mathbb { R } ^ { n } \times \mathbb { R } ^ { n } \to \mathbb { R } ^ { n } \times \mathbb { R } ^ { n } } \\ & { \quad \mathrm { L S T M } ( \pmb { x } , \pmb { c } _ { p r e \nu } , \pmb { h } _ { p r e \nu } ) = ( \pmb { c } , \pmb { h } ) . } \end{array}
+$$
+
+The updated state $^ c$ and the output $^ { h }$ are computed as follows:
+
+$$
+\begin{array} { r l } & { f = \sigma \big ( \mathbf { W } ^ { f x } \mathbf { x } + \mathbf { W } ^ { f h } h _ { p r e \nu } + b ^ { f } \big ) } \\ & { i = \sigma \big ( \mathbf { W } ^ { i x } \mathbf { x } + \mathbf { W } ^ { i h } h _ { p r e \nu } + b ^ { i } \big ) } \\ & { j = \operatorname { t a n h } ( \mathbf { W } ^ { j x } \mathbf { x } + \mathbf { W } ^ { j h } h _ { p r e \nu } + b ^ { j } ) } \\ & { o = \sigma \big ( \mathbf { W } ^ { o x } \mathbf { x } + \mathbf { W } ^ { o h } h _ { p r e \nu } + b ^ { o } \big ) } \\ & { c = f \odot c _ { p r e \nu } + i \odot j } \\ & { h = o \odot \operatorname { t a n h } ( c ) , } \end{array}
+$$
+
+where $\sigma$ is the logistic sigmoid function, $\odot$ is the elementwise product, $\mathbf { W } ^ { * * }$ and $b ^ { * }$ are weight matrices and biases.
+
+While the LSTM is typically presented as a solution to the vanishing gradients problem, its gate $i$ can also be interpreted as scaling the rows of weight matrices $\mathbf { W } ^ { j * }$ (ignoring the non-linearity in $j )$ . In this sense, the LSTM nudges Elman Networks towards context-dependent transitions and the extreme case of Input Switched Affine Networks. If we took another, larger step towards that extreme, we could end up with Hypernetworks (Ha et al. 2016). Here, instead, we take a more cautious step, and equip the LSTM with gates that scale the columns of all its weight matrices $\mathbf { W } ^ { * * }$ in a context-dependent manner. The scaling of the matrices $\mathbf { W } ^ { * x }$ (those that transform the cell input) makes the input embeddings dependent on the cell state, while the scaling of $\mathbf { W } ^ { * h }$ does the reverse.
+
+The Mogrifier1 LSTM is an LSTM where two inputs $_ { \textbf { \em x } }$ and $h _ { p r e \nu }$ modulate one another in an alternating fashion before the usual LSTM computation takes place (see Fig. 1). That is, Mogrify $( { \bf { x } } , c _ { p r e \nu } , { \bf { h } } _ { p r e \nu } ) = \mathrm { L S T M } ( { \bf { x } } ^ { \uparrow } , c _ { p r e \nu } , { \bf { h } } _ { p r e \nu } ^ { \uparrow } )$ where the modulated inputs $\mathbf { \boldsymbol { x } } ^ { \uparrow }$ and $h _ { p r e \nu } ^ { \dagger }$ are defined as the highest indexed $\mathbf { \Delta } _ { \mathbf { \boldsymbol { x } } ^ { i } }$ and $h _ { p r e \nu } ^ { i }$ , respectively, from the interleaved sequences
+
+$$
+\begin{array} { r } { \pmb { x } ^ { i } = 2 \sigma ( \mathbf { Q } ^ { i } h _ { p r e \nu } ^ { i - 1 } ) \odot \pmb { x } ^ { i - 2 } , \qquad \mathrm { f o r ~ o d d ~ i \in [ 1 \dots { r } ] ~ } } \end{array}
+$$
+
+$$
+\begin{array} { r } { \pmb { h } _ { p r e \nu } ^ { i } = 2 \sigma ( \mathbf { R } ^ { i } \pmb { x } ^ { i - 1 } ) \odot \pmb { h } _ { p r e \nu } ^ { i - 2 } , \qquad \mathrm { f o r ~ e v e n ~ i \in ~ [ 1 \dots { r } ] ~ } } \end{array}
+$$
+
+with ${ \pmb x } ^ { - 1 } = { \pmb x }$ and $h _ { p r e \nu } ^ { 0 } = h _ { p r e \nu }$ . The number of “rounds”, $r \in \mathbb N$ , is a hyperparameter; $r = 0$ recovers the LSTM. Multiplication with the constant 2 ensures that randomly initialized ${ \bf Q } ^ { i } , { \bf R } ^ { i }$ matrices result in transformations close to identity. To reduce the number of additional model parameters, we typically factorize the ${ \bf Q } ^ { i } , { \bf R } ^ { i }$ matrices as products of low-rank matrices: $\mathbf { Q } ^ { i } =$ $\mathbf { \dot { Q } } _ { \mathrm { l e f t } } ^ { i } \mathbf { Q } _ { \mathrm { r i g h t } } ^ { i }$ with $\dot { \mathbf { Q } } ^ { i } \in \mathbb { R } ^ { i n \times n }$ , $\mathbf { Q } _ { \mathrm { l e f t } } ^ { i } \in \mathbb { R } ^ { m \times k }$ , $\mathbf { Q } _ { \mathrm { r i g h t } } ^ { i } \in \mathbb { R } ^ { k \times n }$ , where $k < m i n ( m , n )$ is the rank.
+
+# 3 EXPERIMENTS
+
+# 3.1 THE CASE FOR SMALL-SCALE
+
+Before describing the details of the data, the experimental setup and the results, we take a short detour to motivate work on smaller-scale datasets. A recurring theme in the history of sequence models is that the problem of model design is intermingled with optimizability and scalability. Elman Networks are notoriously difficult to optimize, a property that ultimately gave birth to the idea of the LSTM, but also to more recent models such as the Unitary Evolution RNN (Arjovsky et al. 2016) and fixes like gradient clipping (Pascanu et al. 2013). Still, it is far from clear – if we could optimize these models well – how different their biases would turn out to be. The non-separability of model and optimization is fairly evident in these cases.
+
+Scalability, on the other hand, is often optimized for indirectly. Given the limited ability of current models to generalize, we often compensate by throwing more data at the problem. To fit a larger dataset, model size must be increased. Thus the best performing models are evaluated based on their scalability3. Today, scaling up still yields tangible gains on down-stream tasks, and language modelling data is abundant. However, we believe that simply scaling up will not solve the generalization problem and better models will be needed. Our hope is that by choosing small enough datasets, so that model size is no longer the limiting factor, we get a number of practical advantages:
+
+$\star$ Generalization ability will be more clearly reflected in evaluations even without domain adaptation. $\star$ Turnaround time in experiments will be reduced, and the freed up computational budget can be put to good use by controlling for nuisance factors. $\star$ The transient effects of changing hardware performance characteristics are somewhat lessened.
+
+Thus, we develop, analyse and evaluate models primarily on small datasets. Evaluation on larger datasets is included to learn more about the models’ scaling behaviour and because of its relevance for applications, but it is to be understood that these evaluations come with much larger error bars and provide more limited guidance for further research on better models.
+
+# 3.2 DATASETS
+
+We compare models on both word and character-level language modelling datasets. The two wordlevel datasets we picked are the Penn Treebank (PTB) corpus by Marcus et al. (1993) with preprocessing from Mikolov et al. (2010) and Wikitext-2 by Merity et al. (2016), which is about twice the size of PTB with a larger vocabulary and lighter preprocessing. These datasets are definitely on the small side, but – and because of this – they are suitable for exploring different model biases. Their main shortcoming is the small vocabulary size, only in the tens of thousands, which makes them inappropriate for exploring the behaviour of the long tail. For that, open vocabulary language modelling and byte pair encoding (Sennrich et al. 2015) would be an obvious choice. Still, our primary goal here is the comparison of the LSTM and Mogrifier architectures, thus we instead opt for character-based language modelling tasks, where vocabulary size is not an issue, the long tail is not truncated, and there are no additional hyperparameters as in byte pair encoding that make fair comparison harder. The first character-based corpus is Enwik8 from the Hutter Prize dataset (Hutter 2012). Following common practice, we use the first 90 million characters for training and the remaining 10 million evenly split between validation and test. The character-level task on the
+
+Table 1: Word-level perplexities of near state-of-the-art models, our LSTM baseline and the Mogrifier on PTB and Wikitext-2. Models with Mixture of Softmaxes (Yang et al. 2017) are denoted with MoS, depth N with dN. MC stands for Monte-Carlo dropout evaluation. Previous state-of-the-art results in italics. Note the comfortable margin of 2.8–4.3 perplexity points the Mogrifier enjoys over the LSTM.   
+
+<table><tr><td rowspan="2" colspan="3"></td><td colspan="2">No Dyneval</td><td colspan="2">Dyneval</td></tr><tr><td>Val.</td><td>Test</td><td>Val.</td><td>Test</td></tr><tr><td rowspan="9">B</td><td>FRAGE (d3,MoS15) (Gong et al. 2018)</td><td>22M</td><td>54.1</td><td>52.4</td><td>47.4</td><td>46.5</td></tr><tr><td>AWD-LSTM (d3,MoS15) (Yang et al.2017)</td><td>22M</td><td>56.5</td><td>54.4</td><td>48.3</td><td>47.7</td></tr><tr><td>Transformer-XL (Dai et al. 2019)</td><td>24M</td><td>56.7</td><td>54.5</td><td></td><td></td></tr><tr><td>LSTM (d2)</td><td>24M</td><td>55.8</td><td>54.6</td><td>48.9</td><td>48.4</td></tr><tr><td>Mogrifier (d2)</td><td>24M</td><td>52.1</td><td>51.0</td><td>45.1</td><td>45.0</td></tr><tr><td>LSTM (d2, MC)</td><td>24M</td><td>55.5</td><td>54.1</td><td>48.6</td><td>48.4</td></tr><tr><td>Mogrifier (d2,C)</td><td>24M</td><td>51.4</td><td>50.1</td><td>44.9</td><td>44.8</td></tr><tr><td>FRAGE (d3,MoS15) (Gong et al. 2018)</td><td>35M</td><td>60.3</td><td>58.0</td><td>40.8</td><td>39.1</td></tr><tr><td>AWD-LSTM (d3,MoS15) (Yang et al.2017)</td><td>35M</td><td>63.9</td><td>61.2</td><td>42.4</td><td>40.7</td></tr><tr><td>B LSTM (d2,MoS2)</td><td>35M</td><td>62.6</td><td>60.1</td><td>43.2</td><td>41.5</td></tr><tr><td>Mogrifier (d2,MoS2)</td><td>35M</td><td>58.7</td><td>56.6</td><td>40.6</td><td>39.0</td></tr><tr><td>LSTM (d2, MoS2, MC)</td><td>35M</td><td>61.9</td><td>59.4</td><td>43.2</td><td>41.4</td></tr><tr><td>Mogrifier (d2,MoS2,MC)</td><td>35M</td><td>57.3</td><td>55.1</td><td>40.2</td><td>38.6</td></tr></table>
+
+Mikolov preprocessed PTB corpus (Merity et al. 2018) is unique in that it has the disadvantages of closed vocabulary without the advantages of word-level modelling, but we include it for comparison to previous work. The final character-level dataset is the Multilingual Wikipedia Corpus (MWC, Kawakami et al. (2017)), from which we focus on the English and Finnish language subdatasets in the single text, large setting.
+
+# 3.3 SETUP
+
+We tune hyperparameters following the experimental setup of Melis et al. (2018) using a black-box hyperparameter tuner based on batched Gaussian Process Bandits (Golovin et al. 2017). For the LSTM, the tuned hyperparameters are the same: input_embedding_ratio, learning_rate, l2_penalty, input_dropout, inter_layer_dropout, state_dropout, output_dropout. For the Mogrifier, the number of rounds $r$ and the rank $k$ of the low-rank approximation is also tuned (allowing for full rank, too). For word-level tasks, BPTT (Werbos et al. 1990) window size is set to 70 and batch size to 64. For character-level tasks, BPTT window size is set to 150 and batch size to 128 except for Enwik8 where the window size is 500. Input and output embeddings are tied for word-level tasks following Inan et al. (2016) and Press and Wolf (2016). Optimization is performed with Adam (Kingma and Ba 2014) with $\beta _ { 1 } = 0$ , a setting that resembles RMSProp without momentum. Gradients are clipped (Pascanu et al. 2013) to norm 10. We switch to averaging weights similarly to Merity et al. (2017) after a certain number of checkpoints with no improvement in validation cross-entropy or at $80 \%$ of the training time at the latest. We found no benefit to using two-step finetuning.
+
+Model evaluation is performed with the standard, deterministic dropout approximation or MonteCarlo averaging (Gal and Ghahramani 2016) where explicitly noted (MC). In standard dropout evaluation, dropout is turned off while in MC dropout predictions are averaged over randomly sampled dropout masks (200 in our experiments). Optimal softmax temperature is determined on the validation set, and in the MC case dropout rates are scaled (Melis et al. 2018). Finally, we report results with and without dynamic evaluation (Krause et al. 2017). Hyperparameters for dynamic evaluation are tuned using the same method (see Appendix A for details).
+
+We make the code and the tuner output available at https://github.com/deepmind/lamb.
+
+# 3.4 RESULTS
+
+Table 1 lists our results on word-level datasets. On the PTB and Wikitext-2 datasets, the Mogrifier has lower perplexity than the LSTM by 3–4 perplexity points regardless of whether or not dynamic evaluation (Krause et al. 2017) and Monte-Carlo averaging are used. On both datasets, the state of the art is held by the AWD LSTM (Merity et al. 2017) extended with Mixture of Softmaxes (Yang et al. 2017) and FRAGE (Gong et al. 2018). The Mogrifier improves the state of the art without either of these methods on PTB, and without FRAGE on Wikitext-2.
+
+Table 2: Bits per character on character-based datasets of near state-of-the-art models, our LSTM baseline and the Mogrifier. Previous state-of-the-art results in italics. Depth N is denoted with dN. MC stands for Monte-Carlo dropout evaluation. Once again the Mogrifier strictly dominates the LSTM and sets a new state of the art on all but the Enwik8 dataset where with dynamic evaluation it closes the gap to the Transformer-XL of similar size $^ { \dagger }$ Krause et al. (2019), $^ \ddag$ Ben Krause, personal communications, May 17, 2019). On most datasets, model size was set large enough for underfitting not to be an issue. This was very much not the case with Enwik8, so we grouped models of similar sizes together for ease of comparison. Unfortunately, a couple of dynamic evaluation test runs diverged (NaN) on the test set and some were just too expensive to run (Enwik8, MC).   
+
+<table><tr><td rowspan="2" colspan="2"></td><td rowspan="2"></td><td colspan="2">No Dyneval</td><td colspan="2">Dyneval</td></tr><tr><td>Val.</td><td>Test</td><td>Val.</td><td>Test</td></tr><tr><td rowspan="7">B 图</td><td>Trellis Networks (Bai et al.2018)</td><td>13.4M</td><td></td><td>1.159</td><td></td><td></td></tr><tr><td>AWD-LSTM (d3) (Merity et al.2017)</td><td>13.8M</td><td></td><td>1.175</td><td></td><td></td></tr><tr><td>LSTM (d2)</td><td>24M</td><td>1.163</td><td>1.143</td><td>1.116</td><td>1.103</td></tr><tr><td>Mogrifier (d2)</td><td>24M</td><td>1.149</td><td>1.131</td><td>1.098</td><td>1.088</td></tr><tr><td>LSTM (d2, MC)</td><td>24M</td><td>1.159</td><td>1.139</td><td>1.115</td><td>1.101</td></tr><tr><td>Mogrifier (d2, MC)</td><td>24M</td><td>1.137</td><td>1.120</td><td>1.094</td><td>1.083</td></tr><tr><td>HCLM with Cache (Kawakami et al. 2017)</td><td>8M</td><td>1.591</td><td>1.538</td><td></td><td></td></tr><tr><td rowspan="5">WMW 图</td><td>LSTM (d1) (Kawakami et al.2017)</td><td>8M</td><td>1.793</td><td>1.736</td><td></td><td></td></tr><tr><td>LSTM (d2)</td><td>24M</td><td>1.353</td><td>1.338</td><td>1.239</td><td>1.225</td></tr><tr><td>Mogrifier (d2)</td><td>24M</td><td>1.319</td><td>1.305</td><td>1.202</td><td>1.188</td></tr><tr><td>LSTM (d2, MC)</td><td>24M</td><td>1.346</td><td>1.332</td><td>1.238</td><td>NaN</td></tr><tr><td>Mogrifier (d2, MC)</td><td>24M</td><td>1.312</td><td>1.298</td><td>1.200</td><td>1.187</td></tr><tr><td rowspan="6">JMN H</td><td>HCLM with Cache (Kawakami et al. 2017)</td><td>8M</td><td>1.754</td><td>1.711</td><td></td><td></td></tr><tr><td>LSTM (d1) (Kawakami et al. 2017)</td><td>8M</td><td>1.943</td><td>1.913</td><td></td><td></td></tr><tr><td>LSTM (d2)</td><td>24M</td><td>1.382</td><td>1.367</td><td>1.249</td><td>1.237</td></tr><tr><td>Mogrifier (d2)</td><td>24M</td><td>1.338</td><td>1.326</td><td>1.202</td><td>1.191</td></tr><tr><td>LSTM (d2, MC)</td><td>24M</td><td>1.377</td><td>1.361</td><td>1.247</td><td>1.234</td></tr><tr><td>Mogrifier (d2, MC)</td><td>24M</td><td>1.327</td><td>1.313</td><td>1.198</td><td>NaN</td></tr><tr><td rowspan="19">grirg 图</td><td>Transformer-XL (d24) (Dai et al.2019)</td><td>277M</td><td></td><td>0.993</td><td></td><td>0.940t</td></tr><tr><td>Transformer-XL (d18) (Dai et al.2019)</td><td>88M</td><td></td><td>1.03</td><td></td><td></td></tr><tr><td>LSTM (d4)</td><td>96M</td><td>1.145</td><td>1.155</td><td>1.041</td><td>1.020</td></tr><tr><td>Mogrifier (d4)</td><td>96M</td><td>1.110</td><td>1.122</td><td>1.009</td><td>0.988</td></tr><tr><td>LSTM (d4,MC)</td><td>96M</td><td>1.139</td><td>1.147</td><td></td><td></td></tr><tr><td>Mogrifier (d4, MC)</td><td>96M</td><td>1.104</td><td>1.116</td><td></td><td></td></tr><tr><td>Transformer-XL (d12) (Dai et al.2019)</td><td>41M</td><td></td><td>1.06</td><td></td><td>1.01t</td></tr><tr><td>AWD-LSTM (d3) (Merity et al.2017)</td><td>47M</td><td></td><td>1.232</td><td></td><td></td></tr><tr><td>mLSTM (d1) (Krause et al. 2016)</td><td>46M</td><td></td><td>1.24</td><td></td><td>1.08</td></tr><tr><td>LSTM (d4)</td><td>48M</td><td>1.182</td><td>1.195</td><td>1.073</td><td>1.051</td></tr><tr><td>Mogrifier (d4)</td><td>48M</td><td>1.135</td><td>1.146</td><td>1.035</td><td>1.012</td></tr><tr><td>LSTM (d4, MC)</td><td>48M</td><td>1.176</td><td>1.188</td><td></td><td></td></tr><tr><td>Mogrifier (d4,MC)</td><td>48M</td><td>1.130</td><td>1.140</td><td></td><td></td></tr></table>
+
+Table 2 lists the character-level modelling results. On all datasets, our baseline LSTM results are much better than those previously reported for LSTMs, highlighting the issue of scalability and experimental controls. In some cases, these unexpectedly large gaps may be down to lack of hyperparameter tuning as in the case of Merity et al. (2017), or in others, to using a BPTT window size (50) that is too small for character-level modelling (Melis et al. 2017) in order to fit the model into memory. The Mogrifier further improves on these baselines by a considerable margin. Even the smallest improvement of 0.012 bpc on the highly idiosyncratic, character-based, Mikolov preprocessed PTB task is equivalent to gaining about 3 perplexity points on word-level PTB. MWC, which was built for open-vocabulary language modelling, is a much better smaller-scale character-level dataset. On the English and the Finnish corpora in MWC, the Mogrifier enjoys a gap of 0.033-0.046 bpc. Finally, on the Enwik8 dataset, the gap is 0.029-0.039 bpc in favour of the Mogrifier.
+
+![](images/8e5b3999aec46787fd29a456dd1258eff2770c1e5a461c0cb04ac34807783f39.jpg)  
+Figure 2: “No-zigzag” Mogrifier for the ablation study. Gating is always based on the original inputs.
+
+Table 3: PTB ablation study validation perplexities with 24M parameters.   
+
+<table><tr><td>Mogrifier Full rank Qi, Pi</td><td>54.1 54.6</td></tr><tr><td>No zigzag LSTM</td><td>55.0</td></tr><tr><td>mLSTM</td><td>57.5 57.8</td></tr></table>
+
+![](images/852bf26d28d8cdb3459ace2f5cae5d33d812f1bd074e3b3b79f4281c02334002.jpg)  
+Figure 3: Perplexity vs the rounds $r$ in the PTB ablation study.
+
+Of particular note is the comparison to Transformer-XL (Dai et al. 2019), a state-of-the-art model on larger datasets such as Wikitext-103 and Enwik8. On PTB, without dynamic evaluation, the Transformer-XL is on par with our LSTM baseline which puts it about 3.5 perplexity points behind the Mogrifier. On Enwik8, also without dynamic evaluation, the Transformer-XL has a large, 0.09 bpc advantage at similar parameter budgets, but with dynamic evaluation this gap disappears. However, we did not test the Transformer-XL ourselves, so fair comparison is not possible due to differing experimental setups and the rather sparse result matrix for the Transformer-XL.
+
+# 4 ANALYSIS
+
+# 4.1 ABLATION STUDY
+
+The Mogrifier consistently outperformed the LSTM in our experiments. The optimal settings were similar across all datasets, with $r \in \{ 5 , 6 \}$ and $k \in [ 4 0 \dots 9 0 ]$ (see Appendix B for a discussion of hyperparameter sensitivity). In this section, we explore the effect of these hyperparameters and show that the proposed model is not unnecessarily complicated. To save computation, we tune all models using a shortened schedule with only 145 epochs instead of 964 and a truncated BPTT window size of 35 on the word-level PTB dataset, and evaluate using the standard, deterministic dropout approximation with a tuned softmax temperature.
+
+Fig. 3 shows that the number of rounds $r$ greatly influences the results. Second, we found the low-rank factorization of $\mathbf { Q } ^ { i }$ and $\mathbf { R } ^ { i }$ to help a bit, but the full-rank variant is close behind which is what we observed on other datasets, as well. Finally, to verify that the alternating gating scheme is not overly complicated, we condition all newly introduced gates on the original inputs $_ { \textbf { \em x } }$ and $h _ { p r e \nu }$ (see Fig. 2). That is, instead of Eq. 1 and Eq. 2 the no-zigzag updates are
+
+$$
+\begin{array} { r } { \begin{array} { r l } & { \qquad \mathbf { \Delta } x ^ { i } = 2 \sigma ( \mathbf { Q } ^ { i } h _ { p r e \nu } ) \odot \mathbf { \Delta } x ^ { i - 2 } \qquad } & { \mathrm { ~ f o r ~ o d d ~ i \in [ 1 \dots { } } , } \\ { h _ { p r e \nu } ^ { i } = 2 \sigma ( \mathbf { R } ^ { i } x ) \odot h _ { p r e \nu } ^ { i - 2 } \qquad } & { \mathrm { ~ f o r ~ e v e n ~ i \in [ 1 \dots { } } . . . r ] . } \end{array} } \end{array}
+$$
+
+In our experiments, the no-zigzag variant underperformed the baseline Mogrifier by a small but significant margin, and was on par with the $r = 2$ model in Fig. 3 suggesting that the Mogrifier’s iterative refinement scheme does more than simply widen the range of possible gating values of $_ { \textbf { \em x } }$ and $h _ { p r e \nu }$ to $( 0 , 2 ^ { \lceil r / 2 \rceil } )$ and $( 0 , 2 ^ { \lfloor r / 2 \rfloor } )$ , respectively.
+
+# 4.2 COMPARISON TO THE MLSTM
+
+The Multiplicative LSTM (Krause et al. 2016), or mLSTM for short, is closest to our model in the literature. It is defined as $\mathrm { m L S T M } ( { \pmb x } , { \pmb c } _ { p r e \nu } , { \pmb h } _ { p r e \nu } ) = \mathrm { L S T M } ( { \pmb x } , { \pmb c } _ { p r e \nu } , { \pmb h } _ { p r e \nu } ^ { m } )$ , where $h _ { p r e \nu } ^ { m } =$ $( \mathbf { W } ^ { m x } \pmb { x } ) \odot ( \mathbf { W } ^ { m h } h _ { p r e \nu } )$ . In this formulation, the differences are readily apparent. First, the mLSTM allows for multiplicative interaction between $_ { \textbf { \em x } }$ and $h _ { p r e \nu }$ , but it only overrides $h _ { p r e \nu }$ , while in the Mogrifier the interaction is two-way, which – as the ablation study showed – is important. Second, the mLSTM can change not only the magnitude but also the sign of values in $h _ { p r e \nu }$ , something with which we experimented in the Mogrifier, but could not get to work. Furthermore, in the definition of $\boldsymbol { h } _ { p r e \nu } ^ { m }$ , the unsquashed linearities and their elementwise product make the mLSTM more sensitive to initialization and unstable during optimization.
+
+![](images/40e466949e4d8b242d1379123618e59c3833987134b31ce0cb6c3a6ab2f42f98.jpg)  
+Figure 4: Cross-entropy vs sequence length in the reverse copy task with i.i.d. tokens. Lower is better. The Mogrifier is better than the LSTM even in this synthetic task with no resemblance to natural language.
+
+On the Enwik8 dataset, we greatly improved on the published results of the mLSTM (Krause et al. 2016). In fact, even our LSTM baseline outperformed the mLSTM by 0.03 bpc. We also conducted experiments on PTB based on our reimplementation of the mLSTM following the same methodology as the ablation study and found that the mLSTM did not improve on the LSTM (see Table 3).
+
+Krause et al. (2016) posit and verify the recovery hypothesis which says that having just suffered a large loss, the loss on the next time step will be smaller on average for the mLSTM than for the LSTM. This was found not to be the case for the Mogrifier. Neither did we observe a significant change in the gap between the LSTM and the Mogrifier in the tied and untied embeddings settings, which would be expected if recovery was affected by $_ { \textbf { \em x } }$ and $h _ { p r e \nu }$ being in different domains.
+
+# 4.3 THE REVERSE COPY TASK
+
+Our original motivation for the Mogrifier was to allow the context to amplify salient and attenuate nuisance features in the input embeddings. We conduct a simple experiment to support this point of view. Consider the reverse copy task where the network reads an input sequence of tokens and a marker token after which it has to repeat the input in reverse order. In this simple sequence-tosequence learning (Sutskever et al. 2014) setup, the reversal is intended to avoid the minimal time lag problem (Hochreiter and Schmidhuber 1997), which is not our focus here.
+
+The experimental setup is as follows. For the training set, we generate 500 000 examples by uniformly sampling a given number of tokens from a vocabulary of size 1000. The validation and test sets are constructed similarly, and contain 10 000 examples. The model consists of an independent, unidirectional encoder and a decoder, whose total number of parameters is 10 million. The decoder is initialized from the last state of the encoder. Since overfitting is not an issue here, no dropout is necessary, and we only tune the learning rate, the l2 penalty, and the embedding size for the LSTM. For the Mogrifier, the number of rounds $r$ and the rank $k$ of the low-rank approximation are also tuned.
+
+We compare the case where both the encoder and decoder are LSTMs to where both are Mogrifiers. Fig. 4a shows that, for sequences of length 50 and 100, both models can solve the task perfectly. At higher lengths though, the Mogrifier has a considerable advantage. Examining the best hyperparameter settings found, the embedding/hidden sizes for the LSTM and Mogrifier are 498/787 vs 41/1054 at 150 steps, and 493/790 vs 181/961 at 200 steps. Clearly, the Mogrifier was able to work with a much smaller embedding size than the LSTM, which is in line with our expectations for a model with a more flexible interaction between the input and recurrent state. We also conducted experiments with a larger model and vocabulary size, and found the effect even more pronounced (see Fig. 4b).
+
+# 4.4 WHAT THE MOGRIFIER IS NOT
+
+The results on the reverse copy task support our hypothesis that input embeddings are enriched by the Mogrifier architecture, but that cannot be the full explanation as the results of the ablation study indicate. In the following, we consider a number of hypotheses about where the advantage of the Mogrifier lies and the experiments that provide evidence against them.
+
+E Hypothesis: the benefit is in scaling $_ { \textbf { \em x } }$ and $h _ { p r e \nu }$ . We verified that data dependency is a crucial feature by adding a learnable scaling factor to the LSTM inputs. We observed no improvement. Also, at extremely low-rank (less than 5) settings where the amount of information in its gating is small, the Mogrifier loses its advantage.   
+E Hypothesis: the benefit is in making optimization easier. We performed experiments with different optimizers (SGD, RMSProp), with intra-layer batch normalization and layer normalization on the LSTM gates. While we cannot rule out an effect on optimization difficulty, in all of these experiments the gap between the LSTM and the Mogrifier was the same.   
+E Hypothesis: exact tying of embeddings is too constraining, the benefit is in making this relationship less strict. Experiments conducted with untied embeddings and character-based models demonstrate improvements of similar magnitude.   
+E Hypothesis: the benefit is in the low-rank factorization of ${ \bf Q } ^ { i } , { \bf R } ^ { i }$ implicitly imposing structure on the LSTM weight matrices. We observed that the full-rank Mogrifier also performed better than the plain LSTM. We conducted additional experiments where the LSTM’s gate matrices were factorized and observed no improvement.   
+E Hypothesis: the benefit comes from better performance on rare words. The observed advantage on character-based modelling is harder to explain based on frequency. Also, in the reverse copy experiments, a large number of tokens were sampled uniformly, so there were no rare words at all.   
+E Hypothesis: the benefit is specific to the English language. This is directly contradicted by the Finnish MWC and the reverse copy experiments.   
+E Hypothesis: the benefit is in handling long-range dependencies better. Experiments in the episodic setting (i.e. sentence-level language modelling) exhibited the same gap as the non-episodic ones.   
+E Hypothesis: the scaling up of inputs saturates the downstream LSTM gates. The idea here is that saturated gates may make states more stable over time. We observed the opposite: the means of the standard LSTM gates in the Mogrifier were very close between the two models, but their variance was smaller in the Mogrifier.
+
+# 5 CONCLUSIONS AND FUTURE WORK
+
+We presented the Mogrifier LSTM, an extension to the LSTM, with state-of-the-art results on several language modelling tasks. Our original motivation for this work was that the context-free representation of input tokens may be a bottleneck in language models and by conditioning the input embedding on the recurrent state some benefit was indeed derived. While it may be part of the explanation, this interpretation clearly does not account for the improvements brought by conditioning the recurrent state on the input and especially the applicability to character-level datasets. Positioning our work on the Multiplicative RNN line of research offers a more compelling perspective.
+
+To give more credence to this interpretation, in the analysis we highlighted a number of possible alternative explanations, and ruled them all out to varying degrees. In particular, the connection to the mLSTM is weaker than expected as the Mogrifier does not exhibit improved recovery (see Section 4.2), and on PTB the mLSTM works only as well as the LSTM. At the same time, the evidence against easier optimization is weak, and the Mogrifier establishing some kind of sharing between otherwise independent LSTM weight matrices is a distinct possibility.
+
+Finally, note that as shown by Fig. 1 and Eq. 1-2, the Mogrifier is a series of preprocessing steps composed with the LSTM function, but other architectures, such as Mogrifier GRU or Mogrifier Elman Network are possible. We also leave investigations into other forms of parameterization of context-dependent transitions for future work.
+
+# ACKNOWLEDGMENTS
+
+We would like to thank Ben Krause for the Transformer-XL dynamic evaluation results, Laura Rimell, Aida Nematzadeh, Angeliki Lazaridou, Karl Moritz Hermann, Daniel Fried for helping with experiments, Chris Dyer, Sebastian Ruder and Jack Rae for their valuable feedback.
+
+# REFERENCES
+
+Aishwarya Agrawal, Dhruv Batra, and Devi Parikh. Analyzing the behavior of visual question answering models. arXiv preprint arXiv:1606.07356, 2016.
+
+Martin Arjovsky, Amar Shah, and Yoshua Bengio. Unitary evolution recurrent neural networks. In International Conference on Machine Learning, pages 1120–1128, 2016.
+
+Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. arXiv preprint arXiv:1409.0473, 2014.
+
+Shaojie Bai, J Zico Kolter, and Vladlen Koltun. Trellis networks for sequence modeling. arXiv preprint arXiv:1810.06682, 2018.
+
+Bram Bakker. Reinforcement learning with long short-term memory. In Advances in neural information processing systems, pages 1475–1482, 2002.
+
+Yonatan Belinkov and Yonatan Bisk. Synthetic and natural noise both break neural machine translation. arXiv preprint arXiv:1711.02173, 2017.
+
+Junyoung Chung, Caglar Gulcehre, Kyunghyun Cho, and Yoshua Bengio. Gated feedback recurrent neural networks. In International Conference on Machine Learning, pages 2067–2075, 2015.
+
+Zihang Dai, Zhilin Yang, Yiming Yang, William W Cohen, Jaime Carbonell, Quoc V Le, and Ruslan Salakhutdinov. Transformer-xl: Attentive language models beyond a fixed-length context. arXiv preprint arXiv:1901.02860, 2019.
+
+Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. Bert: Pre-training of deep bidirectional transformers for language understanding. arXiv preprint arXiv:1810.04805, 2018.
+
+Jeffrey L Elman. Finding structure in time. Cognitive science, 14(2):179–211, 1990.
+
+Jakob N Foerster, Justin Gilmer, Jascha Sohl-Dickstein, Jan Chorowski, and David Sussillo. Input switched affine networks: An rnn architecture designed for interpretability. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pages 1136–1145. JMLR. org, 2017.
+
+Yarin Gal and Zoubin Ghahramani. A theoretically grounded application of dropout in recurrent neural networks. In Advances in Neural Information Processing Systems, pages 1019–1027, 2016.
+
+Daniel Golovin, Benjamin Solnik, Subhodeep Moitra, Greg Kochanski, John Karro, and D Sculley. Google vizier: A service for black-box optimization. In Proceedings of the 23rd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, pages 1487–1495. ACM, 2017.
+
+Chengyue Gong, Di He, Xu Tan, Tao Qin, Liwei Wang, and Tie-Yan Liu. Frage: frequency-agnostic word representation. In Advances in Neural Information Processing Systems, pages 1334–1345, 2018.
+
+David Ha, Andrew Dai, and Quoc V Le. Hypernetworks. arXiv preprint arXiv:1609.09106, 2016.
+
+Sepp Hochreiter and Jürgen Schmidhuber. Lstm can solve hard long time lag problems. In Advances in neural information processing systems, pages 473–479, 1997.
+
+Jeremy Howard and Sebastian Ruder. Universal language model fine-tuning for text classification. arXiv preprint arXiv:1801.06146, 2018.
+
+Marcus Hutter. The human knowledge compression contest. URL http://prize. hutter1. net, 6, 2012.
+
+Hakan Inan, Khashayar Khosravi, and Richard Socher. Tying word vectors and word classifiers: A loss framework for language modeling. CoRR, abs/1611.01462, 2016. URL http://arxiv.org/abs/1611.01462.
+
+Mohit Iyyer, John Wieting, Kevin Gimpel, and Luke Zettlemoyer. Adversarial example generation with syntactically controlled paraphrase networks. arXiv preprint arXiv:1804.06059, 2018.
+
+Robin Jia and Percy Liang. Adversarial examples for evaluating reading comprehension systems. arXiv preprint arXiv:1707.07328, 2017.   
+Kazuya Kawakami, Chris Dyer, and Phil Blunsom. Learning to create and reuse words in open-vocabulary neural language modeling. arXiv preprint arXiv:1704.06986, 2017.   
+Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.   
+Ben Krause, Liang Lu, Iain Murray, and Steve Renals. Multiplicative LSTM for sequence modelling. CoRR, abs/1609.07959, 2016. URL http://arxiv.org/abs/1609.07959.   
+Ben Krause, Emmanuel Kahembwe, Iain Murray, and Steve Renals. Dynamic evaluation of neural sequence models. arXiv preprint arXiv:1709.07432, 2017.   
+Ben Krause, Emmanuel Kahembwe, Iain Murray, and Steve Renals. Dynamic evaluation of transformer language models. arXiv preprint arXiv:1904.08378, 2019.   
+Adhiguna Kuncoro, Chris Dyer, John Hale, Dani Yogatama, Stephen Clark, and Phil Blunsom. Lstms can learn syntax-sensitive dependencies well, but modeling structure makes them better. In Proceedings of the 56th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 1426–1436, 2018.   
+Tal Linzen, Emmanuel Dupoux, and Yoav Goldberg. Assessing the ability of lstms to learn syntax-sensitive dependencies. Transactions of the Association for Computational Linguistics, 4:521–535, 2016.   
+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.   
+Hermann Mayer, Faustino Gomez, Daan Wierstra, Istvan Nagy, Alois Knoll, and Jürgen Schmidhuber. A system for robotic heart surgery that learns to tie knots using recurrent neural networks. Advanced Robotics, 22 (13-14):1521–1537, 2008.   
+Gábor Melis, Chris Dyer, and Phil Blunsom. On the state of the art of evaluation in neural language models. arXiv preprint arXiv:1707.05589, 2017.   
+Gábor Melis, Charles Blundell, Tomáš Kocisk ˇ y, Karl Moritz Hermann, Chris Dyer, and Phil Blunsom. Pushing \` the bounds of dropout. arXiv preprint arXiv:1805.09208, 2018.   
+Stephen Merity, Caiming Xiong, James Bradbury, and Richard Socher. Pointer sentinel mixture models. CoRR, abs/1609.07843, 2016. URL http://arxiv.org/abs/1609.07843.   
+Stephen Merity, Nitish Shirish Keskar, and Richard Socher. Regularizing and optimizing lstm language models. arXiv preprint arXiv:1708.02182, 2017.   
+Stephen Merity, Nitish Shirish Keskar, and Richard Socher. An analysis of neural language modeling at multiple scales. arXiv preprint arXiv:1803.08240, 2018.   
+Tomas Mikolov, Martin Karafiát, Lukas Burget, Jan Cernocky, and Sanjeev Khudanpur. Recurrent neural \` network based language model. In Interspeech, volume 2, page 3, 2010.   
+Nafise Sadat Moosavi and Michael Strube. Lexical features in coreference resolution: To be used with caution. arXiv preprint arXiv:1704.06779, 2017.   
+Razvan Pascanu, Tomas Mikolov, and Yoshua Bengio. On the difficulty of training recurrent neural networks. In International conference on machine learning, pages 1310–1318, 2013.   
+Matthew E Peters, Mark Neumann, Mohit Iyyer, Matt Gardner, Christopher Clark, Kenton Lee, and Luke Zettlemoyer. Deep contextualized word representations. arXiv preprint arXiv:1802.05365, 2018.   
+Ofir Press and Lior Wolf. Using the output embedding to improve language models. CoRR, abs/1608.05859, 2016. URL http://arxiv.org/abs/1608.05859.   
+David E Rumelhart, Geoffrey E Hinton, Ronald J Williams, et al. Learning representations by back-propagating errors. Cognitive modeling, 5(3):1, 1988.   
+Hasim Sak, Andrew W. Senior, and Françoise Beaufays. Long short-term memory based recurrent neural network architectures for large vocabulary speech recognition. CoRR, abs/1402.1128, 2014. URL http: //arxiv.org/abs/1402.1128.   
+Rico Sennrich, Barry Haddow, and Alexandra Birch. Neural machine translation of rare words with subword units. arXiv preprint arXiv:1508.07909, 2015.   
+Ilya Sutskever, James Martens, and Geoffrey E Hinton. Generating text with recurrent neural networks. In Proceedings of the 28th International Conference on Machine Learning (ICML-11), pages 1017–1024, 2011.   
+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.   
+Chong Wang, Yining Wang, Po-Sen Huang, Abdelrahman Mohamed, Dengyong Zhou, and Li Deng. Sequence modeling via segmentations. In Proceedings of the 34th International Conference on Machine LearningVolume 70, pages 3674–3683. JMLR. org, 2017.   
+Paul J Werbos et al. Backpropagation through time: what it does and how to do it. Proceedings of the IEEE, 78 (10):1550–1560, 1990.   
+Yuhuai Wu, Saizheng Zhang, Ying Zhang, Yoshua Bengio, and Ruslan R Salakhutdinov. On multiplicative integration with recurrent neural networks. In Advances in neural information processing systems, pages 2856–2864, 2016.   
+Zhilin Yang, Zihang Dai, Ruslan Salakhutdinov, and William W Cohen. Breaking the softmax bottleneck: a high-rank rnn language model. arXiv preprint arXiv:1711.03953, 2017.   
+Barret Zoph and Quoc V. Le. Neural architecture search with reinforcement learning. CoRR, abs/1611.01578, 2016. URL http://arxiv.org/abs/1611.01578.
+
+# APPENDIX A HYPERPARAMETER TUNING RANGES
+
+In all experiments, we tuned hyperparameters using Google Vizier (Golovin et al. 2017). The tuning ranges are listed in Table 4. Obviously, mogrifier_rounds and mogrifier_rank are tuned only for the Mogrifier. If input_embedding_ratio $\geqslant 1$ , then the input/output embedding sizes and the hidden sizes are set to equal and the linear projection from the cell output into the output embeddings space is omitted. Similarly, mogrif ier_rank $\leqslant 0$ is taken to mean full rank $\mathbf { Q } ^ { * }$ , $\mathbf { R } ^ { * }$ without factorization. Since Enwik8 is a much larger dataset, we don’t tune input_embedding_ratio and specify tighter tuning ranges for dropout based on preliminary experiments (see Table 5).
+
+Dynamic evaluation hyperparameters were tuned according to Table 6. The highest possible value for max_time_steps, the BPTT window size, was 20 for word, and 50 for character-level tasks. The batch size for estimating the mean squared gradients over the training data was set to 1024, gradient clipping was turned off, and the l2 penalty was set to zero.
+
+Table 4: Hyperparameter tuning ranges for all tasks except Enwik8.   
+
+<table><tr><td>learning_rate input_embedding_ratio 12_penalty</td><td>Low High 0.001 0.004 0.0 2.0 5e-6 0.0</td><td>Spacing log</td></tr><tr><td>input_dropout</td><td>1e-3 0.9</td><td>log</td></tr><tr><td>inter_layer_dropout</td><td>0.0 0.95</td><td></td></tr><tr><td>state_dropout</td><td>0.0</td><td></td></tr><tr><td></td><td></td><td>0.8</td></tr><tr><td>output_dropout</td><td>0.0</td><td>0.95</td></tr><tr><td>mogrifier_rounds (r)</td><td>0</td><td>6</td></tr><tr><td>mogrifier_rank (k)</td><td>-20</td><td>100</td></tr></table>
+
+Table 5: Hyperparameter tuning ranges for Enwik8.   
+
+<table><tr><td>learning_rate</td><td>High 0.004</td><td>Spacing log</td></tr><tr><td>12_penalty input_dropout</td><td>1e-3 0.2</td><td>log</td></tr><tr><td></td><td></td><td></td></tr><tr><td>inter_layer_dropout</td><td>0.2</td><td></td></tr><tr><td>state_dropout</td><td>0.25</td><td></td></tr><tr><td>output_dropout</td><td>0.0 0.0</td><td>0.25</td></tr><tr><td>mogrifier_rounds (r)</td><td>0</td><td>6</td></tr><tr><td>mogrifier_rank (k)</td><td>-20</td><td>100</td></tr></table>
+
+Table 6: Hyperparameter tuning ranges for dynamic evaluation.   
+
+<table><tr><td>max_time_steps</td><td>Low 1</td><td>High 20/50</td><td>Spacing</td></tr><tr><td>dyneval_learning_rate</td><td>1e-6</td><td>1e-3</td><td>log</td></tr><tr><td>dyneval_decay_rate</td><td>1e-6</td><td>1e-2</td><td>log</td></tr><tr><td>dyneval_epsilon</td><td>1e-8</td><td>1e-2</td><td>log</td></tr></table>
+
+# APPENDIX B HYPERPARAMETER SENSITIVITY
+
+The parallel coordinate plots in Fig. 5 and 6, give a rough idea about hyperparameter sensitivity. The red lines correspond to hyperparameter combinations closest to the best solution found. To find the closest combinations, we restricted the range for each hyperparameter separately to about $15 \%$ of its entire tuning range.
+
+For both the LSTM and the Mogrifier, the results are at most 1.2 perplexity points off the best result, so our results are somewhat insensitive to jitter in the hyperparameters. Still, in this setup, grid search would require orders of magnitude more trials to find comparable solutions.
+
+On the other hand, the tuner does take advantage of the stochasticity of training, and repeated runs with the same parameters may be give slightly worse results. To gauge the extent of this effect, on PTB we estimated the standard deviation in reruns of the LSTM with the best hyperparameters to be about 0.2 perplexity points, but the mean was about 0.7 perplexity points off the result produced with the weights saved in best tuning run.
+
+![](images/afb8079b15a076212114180f4750055a09a47c2eb4a634e19a74869520fc2b85.jpg)  
+Figure 5: Average per-word validation cross-entropies for hyperparameter combinations in the neighbourhood of the best solution for a 2-layer LSTM with 24M weights on the Penn Treebank dataset.
+
+![](images/140b069ba910a4c8e4633dda009b26b47dea4047575f6eb908ca93ab701ae3fe.jpg)  
+Figure 6: Average per-word validation cross-entropies for hyperparameter combinations in the neighbourhood of the best solution for a 2-layer Mogrifier LSTM with 24M weights on the Penn Treebank dataset. feature_mask_rank and feature_mask_rounds are aliases for mogrifier_rank and mogrifier_rounds

parse/train/SJe5P6EYvS/SJe5P6EYvS_content_list.json

@@ -0,0 +1,1240 @@
+[
+    {
+        "type": "text",
+        "text": "MOGRIFIER LSTM ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            401,
+            121
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Gábor Melis†, Tomáš Kociskýˇ †, Phil Blunsom†‡   \n{melisgl,tkocisky,pblunsom}@google.com   \n†DeepMind, London, UK   \n‡University of Oxford ",
+        "bbox": [
+            184,
+            143,
+            558,
+            202
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            239,
+            544,
+            255
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Many advances in Natural Language Processing have been based upon more expressive models for how inputs interact with the context in which they occur. Recurrent networks, which have enjoyed a modicum of success, still lack the generalization and systematicity ultimately required for modelling language. In this work, we propose an extension to the venerable Long Short-Term Memory in the form of mutual gating of the current input and the previous output. This mechanism affords the modelling of a richer space of interactions between inputs and their context. Equivalently, our model can be viewed as making the transition function given by the LSTM context-dependent. Experiments demonstrate markedly improved generalization on language modelling in the range of 3–4 perplexity points on Penn Treebank and Wikitext-2, and 0.01–0.05 bpc on four character-based datasets. We establish a new state of the art on all datasets with the exception of Enwik8, where we close a large gap between the LSTM and Transformer models. ",
+        "bbox": [
+            233,
+            272,
+            766,
+            452
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            481,
+            334,
+            496
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The domination of Natural Language Processing by neural models is hampered only by their limited ability to generalize and questionable sample complexity (Belinkov and Bisk 2017; Jia and Liang 2017; Iyyer et al. 2018; Moosavi and Strube 2017; Agrawal et al. 2016), their poor grasp of grammar (Linzen et al. 2016; Kuncoro et al. 2018), and their inability to chunk input sequences into meaningful units (Wang et al. 2017). While direct attacks on the latter are possible, in this paper, we take a language-agnostic approach to improving Recurrent Neural Networks (RNN, Rumelhart et al. (1988)), which brought about many advances in tasks such as language modelling, semantic parsing, machine translation, with no shortage of non-NLP applications either (Bakker 2002; Mayer et al. 2008). Many neural models are built from RNNs including the sequence-to-sequence family (Sutskever et al. 2014) and its attention-based branch (Bahdanau et al. 2014). Thus, innovations in RNN architecture tend to have a trickle-down effect from language modelling, where evaluation is often the easiest and data the most readily available, to many other tasks, a trend greatly strengthened by ULMFiT (Howard and Ruder 2018), ELMo (Peters et al. 2018) and BERT (Devlin et al. 2018), which promote language models from architectural blueprints to pretrained building blocks. ",
+        "bbox": [
+            174,
+            513,
+            825,
+            707
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "To improve the generalization ability of language models, we propose an extension to the LSTM (Hochreiter and Schmidhuber 1997), where the LSTM’s input $_ { \\textbf { \\em x } }$ is gated conditioned on the output of the previous step $h _ { p r e \\nu }$ . Next, the gated input is used in a similar manner to gate the output of the previous time step. After a couple of rounds of this mutual gating, the last updated $_ { \\textbf { \\em x } }$ and $h _ { p r e \\nu }$ are fed to an LSTM. By introducing these additional of gating operations, in one sense, our model joins the long list of recurrent architectures with gating structures of varying complexity which followed the invention of Elman Networks (Elman 1990). Examples include the LSTM, the GRU (Chung et al. 2015), and even designs by Neural Architecture Search (Zoph and Le 2016). ",
+        "bbox": [
+            174,
+            714,
+            825,
+            825
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Intuitively, in the lowermost layer, the first gating step scales the input embedding (itself a representation of the average context in which the token occurs) depending on the actual context, resulting in a contextualized representation of the input. While intuitive, as Section 4 shows, this interpretation cannot account for all the observed phenomena. ",
+        "bbox": [
+            176,
+            833,
+            825,
+            888
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In a more encompassing view, our model can be seen as enriching the mostly additive dynamics of recurrent transitions placing it in the company of the Input Switched Affine Network (Foerster et al. ",
+        "bbox": [
+            176,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/03ac0eaf76ca9eebf998b34dc19ba7c3c3b647e303574f64b850206fb20b6bc1.jpg",
+        "image_caption": [
+            "Figure 1: Mogrifier with 5 rounds of updates. The previous state $\\pmb { h } ^ { 0 } = \\pmb { h } _ { p r e \\nu }$ is transformed linearly (dashed arrows), fed through a sigmoid and gates ${ \\pmb x } ^ { - 1 } = { \\pmb x }$ in an elementwise manner producing $\\mathbf { x } ^ { 1 }$ . Conversely, the linearly transformed $\\mathbf { x } ^ { 1 }$ gates $ { \\boldsymbol { h } } ^ { 0 }$ and produces $\\boldsymbol { h } ^ { 2 }$ . After a number of repetitions of this mutual gating cycle, the last values of $\\boldsymbol { h } ^ { * }$ and $\\pmb { x } ^ { * }$ sequences are fed to an LSTM cell. The prev subscript of $^ { h }$ is omitted to reduce clutter. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            253,
+            106,
+            740,
+            208
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2017) with a separate transition matrix for each possible input, and the Multiplicative RNN (Sutskever et al. 2011), which factorizes the three-way tensor of stacked transition matrices. Also following this line of research are the Multiplicative Integration LSTM (Wu et al. 2016) and – closest to our model in the literature – the Multiplicative LSTM (Krause et al. 2016). The results in Section 3.4 demonstrate the utility of our approach, which consistently improves on the LSTM and establishes a new state of the art on all but the largest dataset, Enwik8, where we match similarly sized transformer models. ",
+        "bbox": [
+            173,
+            296,
+            826,
+            393
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 MODEL ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            412,
+            269,
+            429
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To allow for ease of subsequent extension, we present the standard LSTM update (Sak et al. 2014) with input and state of size $m$ and $n$ respectively as the following function: ",
+        "bbox": [
+            171,
+            444,
+            821,
+            473
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5af9c0b01f0e00af543b0ecc10d38792baf78cf1dfbc1351f0c267d403b31825.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\mathrm { L S T M } \\colon \\mathbb { R } ^ { m } \\times \\mathbb { R } ^ { n } \\times \\mathbb { R } ^ { n } \\to \\mathbb { R } ^ { n } \\times \\mathbb { R } ^ { n } } \\\\ & { \\quad \\mathrm { L S T M } ( \\pmb { x } , \\pmb { c } _ { p r e \\nu } , \\pmb { h } _ { p r e \\nu } ) = ( \\pmb { c } , \\pmb { h } ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            369,
+            474,
+            625,
+            511
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The updated state $^ c$ and the output $^ { h }$ are computed as follows: ",
+        "bbox": [
+            173,
+            512,
+            581,
+            527
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7c2abfd61f07dcb608cbc167910a45d70c158b1523ceec64db4cd4af524f43a1.jpg",
+        "text": "$$\n\\begin{array} { r l } & { f = \\sigma \\big ( \\mathbf { W } ^ { f x } \\mathbf { x } + \\mathbf { W } ^ { f h } h _ { p r e \\nu } + b ^ { f } \\big ) } \\\\ & { i = \\sigma \\big ( \\mathbf { W } ^ { i x } \\mathbf { x } + \\mathbf { W } ^ { i h } h _ { p r e \\nu } + b ^ { i } \\big ) } \\\\ & { j = \\operatorname { t a n h } ( \\mathbf { W } ^ { j x } \\mathbf { x } + \\mathbf { W } ^ { j h } h _ { p r e \\nu } + b ^ { j } ) } \\\\ & { o = \\sigma \\big ( \\mathbf { W } ^ { o x } \\mathbf { x } + \\mathbf { W } ^ { o h } h _ { p r e \\nu } + b ^ { o } \\big ) } \\\\ & { c = f \\odot c _ { p r e \\nu } + i \\odot j } \\\\ & { h = o \\odot \\operatorname { t a n h } ( c ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            374,
+            530,
+            622,
+            647
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $\\sigma$ is the logistic sigmoid function, $\\odot$ is the elementwise product, $\\mathbf { W } ^ { * * }$ and $b ^ { * }$ are weight matrices and biases. ",
+        "bbox": [
+            174,
+            648,
+            823,
+            676
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "While the LSTM is typically presented as a solution to the vanishing gradients problem, its gate $i$ can also be interpreted as scaling the rows of weight matrices $\\mathbf { W } ^ { j * }$ (ignoring the non-linearity in $j )$ . In this sense, the LSTM nudges Elman Networks towards context-dependent transitions and the extreme case of Input Switched Affine Networks. If we took another, larger step towards that extreme, we could end up with Hypernetworks (Ha et al. 2016). Here, instead, we take a more cautious step, and equip the LSTM with gates that scale the columns of all its weight matrices $\\mathbf { W } ^ { * * }$ in a context-dependent manner. The scaling of the matrices $\\mathbf { W } ^ { * x }$ (those that transform the cell input) makes the input embeddings dependent on the cell state, while the scaling of $\\mathbf { W } ^ { * h }$ does the reverse. ",
+        "bbox": [
+            173,
+            683,
+            825,
+            796
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The Mogrifier1 LSTM is an LSTM where two inputs $_ { \\textbf { \\em x } }$ and $h _ { p r e \\nu }$ modulate one another in an alternating fashion before the usual LSTM computation takes place (see Fig. 1). That is, Mogrify $( { \\bf { x } } , c _ { p r e \\nu } , { \\bf { h } } _ { p r e \\nu } ) = \\mathrm { L S T M } ( { \\bf { x } } ^ { \\uparrow } , c _ { p r e \\nu } , { \\bf { h } } _ { p r e \\nu } ^ { \\uparrow } )$ where the modulated inputs $\\mathbf { \\boldsymbol { x } } ^ { \\uparrow }$ and $h _ { p r e \\nu } ^ { \\dagger }$ are defined as the highest indexed $\\mathbf { \\Delta } _ { \\mathbf { \\boldsymbol { x } } ^ { i } }$ and $h _ { p r e \\nu } ^ { i }$ , respectively, from the interleaved sequences ",
+        "bbox": [
+            173,
+            801,
+            825,
+            864
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/78ea82fdc800a7cb792b35d092f32172fb0ea9a5fe91576f5e4c624f58a586d0.jpg",
+        "text": "$$\n\\begin{array} { r } { \\pmb { x } ^ { i } = 2 \\sigma ( \\mathbf { Q } ^ { i } h _ { p r e \\nu } ^ { i - 1 } ) \\odot \\pmb { x } ^ { i - 2 } , \\qquad \\mathrm { f o r ~ o d d ~ i \\in [ 1 \\dots { r } ] ~ } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            294,
+            868,
+            718,
+            888
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8e096dc937205b75d16f01ff29dc9f725b6aa2944d047da5f26cec6920e02163.jpg",
+        "text": "$$\n\\begin{array} { r } { \\pmb { h } _ { p r e \\nu } ^ { i } = 2 \\sigma ( \\mathbf { R } ^ { i } \\pmb { x } ^ { i - 1 } ) \\odot \\pmb { h } _ { p r e \\nu } ^ { i - 2 } , \\qquad \\mathrm { f o r ~ e v e n ~ i \\in ~ [ 1 \\dots { r } ] ~ } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            279,
+            99,
+            718,
+            122
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "with ${ \\pmb x } ^ { - 1 } = { \\pmb x }$ and $h _ { p r e \\nu } ^ { 0 } = h _ { p r e \\nu }$ . The number of “rounds”, $r \\in \\mathbb N$ , is a hyperparameter; $r = 0$ recovers the LSTM. Multiplication with the constant 2 ensures that randomly initialized ${ \\bf Q } ^ { i } , { \\bf R } ^ { i }$ matrices result in transformations close to identity. To reduce the number of additional model parameters, we typically factorize the ${ \\bf Q } ^ { i } , { \\bf R } ^ { i }$ matrices as products of low-rank matrices: $\\mathbf { Q } ^ { i } =$ $\\mathbf { \\dot { Q } } _ { \\mathrm { l e f t } } ^ { i } \\mathbf { Q } _ { \\mathrm { r i g h t } } ^ { i }$ with $\\dot { \\mathbf { Q } } ^ { i } \\in \\mathbb { R } ^ { i n \\times n }$ , $\\mathbf { Q } _ { \\mathrm { l e f t } } ^ { i } \\in \\mathbb { R } ^ { m \\times k }$ , $\\mathbf { Q } _ { \\mathrm { r i g h t } } ^ { i } \\in \\mathbb { R } ^ { k \\times n }$ , where $k < m i n ( m , n )$ is the rank. ",
+        "bbox": [
+            174,
+            130,
+            825,
+            205
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            224,
+            326,
+            241
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 THE CASE FOR SMALL-SCALE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            256,
+            426,
+            271
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Before describing the details of the data, the experimental setup and the results, we take a short detour to motivate work on smaller-scale datasets. A recurring theme in the history of sequence models is that the problem of model design is intermingled with optimizability and scalability. Elman Networks are notoriously difficult to optimize, a property that ultimately gave birth to the idea of the LSTM, but also to more recent models such as the Unitary Evolution RNN (Arjovsky et al. 2016) and fixes like gradient clipping (Pascanu et al. 2013). Still, it is far from clear – if we could optimize these models well – how different their biases would turn out to be. The non-separability of model and optimization is fairly evident in these cases. ",
+        "bbox": [
+            174,
+            282,
+            825,
+            393
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Scalability, on the other hand, is often optimized for indirectly. Given the limited ability of current models to generalize, we often compensate by throwing more data at the problem. To fit a larger dataset, model size must be increased. Thus the best performing models are evaluated based on their scalability3. Today, scaling up still yields tangible gains on down-stream tasks, and language modelling data is abundant. However, we believe that simply scaling up will not solve the generalization problem and better models will be needed. Our hope is that by choosing small enough datasets, so that model size is no longer the limiting factor, we get a number of practical advantages: ",
+        "bbox": [
+            174,
+            400,
+            825,
+            498
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "$\\star$ Generalization ability will be more clearly reflected in evaluations even without domain adaptation. $\\star$ Turnaround time in experiments will be reduced, and the freed up computational budget can be put to good use by controlling for nuisance factors. $\\star$ The transient effects of changing hardware performance characteristics are somewhat lessened. ",
+        "bbox": [
+            174,
+            511,
+            825,
+            579
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Thus, we develop, analyse and evaluate models primarily on small datasets. Evaluation on larger datasets is included to learn more about the models’ scaling behaviour and because of its relevance for applications, but it is to be understood that these evaluations come with much larger error bars and provide more limited guidance for further research on better models. ",
+        "bbox": [
+            174,
+            590,
+            825,
+            646
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2 DATASETS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            665,
+            287,
+            679
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We compare models on both word and character-level language modelling datasets. The two wordlevel datasets we picked are the Penn Treebank (PTB) corpus by Marcus et al. (1993) with preprocessing from Mikolov et al. (2010) and Wikitext-2 by Merity et al. (2016), which is about twice the size of PTB with a larger vocabulary and lighter preprocessing. These datasets are definitely on the small side, but – and because of this – they are suitable for exploring different model biases. Their main shortcoming is the small vocabulary size, only in the tens of thousands, which makes them inappropriate for exploring the behaviour of the long tail. For that, open vocabulary language modelling and byte pair encoding (Sennrich et al. 2015) would be an obvious choice. Still, our primary goal here is the comparison of the LSTM and Mogrifier architectures, thus we instead opt for character-based language modelling tasks, where vocabulary size is not an issue, the long tail is not truncated, and there are no additional hyperparameters as in byte pair encoding that make fair comparison harder. The first character-based corpus is Enwik8 from the Hutter Prize dataset (Hutter 2012). Following common practice, we use the first 90 million characters for training and the remaining 10 million evenly split between validation and test. The character-level task on the ",
+        "bbox": [
+            174,
+            691,
+            825,
+            886
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "table",
+        "img_path": "images/b3b67b9377c950a7eb733418c5678117c69bfbbfcfed96548e40be8882bbbadd.jpg",
+        "table_caption": [
+            "Table 1: Word-level perplexities of near state-of-the-art models, our LSTM baseline and the Mogrifier on PTB and Wikitext-2. Models with Mixture of Softmaxes (Yang et al. 2017) are denoted with MoS, depth N with dN. MC stands for Monte-Carlo dropout evaluation. Previous state-of-the-art results in italics. Note the comfortable margin of 2.8–4.3 perplexity points the Mogrifier enjoys over the LSTM. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\" colspan=\"3\"></td><td colspan=\"2\">No Dyneval</td><td colspan=\"2\">Dyneval</td></tr><tr><td>Val.</td><td>Test</td><td>Val.</td><td>Test</td></tr><tr><td rowspan=\"9\">B</td><td>FRAGE (d3,MoS15) (Gong et al. 2018)</td><td>22M</td><td>54.1</td><td>52.4</td><td>47.4</td><td>46.5</td></tr><tr><td>AWD-LSTM (d3,MoS15) (Yang et al.2017)</td><td>22M</td><td>56.5</td><td>54.4</td><td>48.3</td><td>47.7</td></tr><tr><td>Transformer-XL (Dai et al. 2019)</td><td>24M</td><td>56.7</td><td>54.5</td><td></td><td></td></tr><tr><td>LSTM (d2)</td><td>24M</td><td>55.8</td><td>54.6</td><td>48.9</td><td>48.4</td></tr><tr><td>Mogrifier (d2)</td><td>24M</td><td>52.1</td><td>51.0</td><td>45.1</td><td>45.0</td></tr><tr><td>LSTM (d2, MC)</td><td>24M</td><td>55.5</td><td>54.1</td><td>48.6</td><td>48.4</td></tr><tr><td>Mogrifier (d2,C)</td><td>24M</td><td>51.4</td><td>50.1</td><td>44.9</td><td>44.8</td></tr><tr><td>FRAGE (d3,MoS15) (Gong et al. 2018)</td><td>35M</td><td>60.3</td><td>58.0</td><td>40.8</td><td>39.1</td></tr><tr><td>AWD-LSTM (d3,MoS15) (Yang et al.2017)</td><td>35M</td><td>63.9</td><td>61.2</td><td>42.4</td><td>40.7</td></tr><tr><td>B LSTM (d2,MoS2)</td><td>35M</td><td>62.6</td><td>60.1</td><td>43.2</td><td>41.5</td></tr><tr><td>Mogrifier (d2,MoS2)</td><td>35M</td><td>58.7</td><td>56.6</td><td>40.6</td><td>39.0</td></tr><tr><td>LSTM (d2, MoS2, MC)</td><td>35M</td><td>61.9</td><td>59.4</td><td>43.2</td><td>41.4</td></tr><tr><td>Mogrifier (d2,MoS2,MC)</td><td>35M</td><td>57.3</td><td>55.1</td><td>40.2</td><td>38.6</td></tr></table>",
+        "bbox": [
+            227,
+            162,
+            771,
+            381
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Mikolov preprocessed PTB corpus (Merity et al. 2018) is unique in that it has the disadvantages of closed vocabulary without the advantages of word-level modelling, but we include it for comparison to previous work. The final character-level dataset is the Multilingual Wikipedia Corpus (MWC, Kawakami et al. (2017)), from which we focus on the English and Finnish language subdatasets in the single text, large setting. ",
+        "bbox": [
+            174,
+            405,
+            825,
+            477
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.3 SETUP ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            492,
+            261,
+            507
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We tune hyperparameters following the experimental setup of Melis et al. (2018) using a black-box hyperparameter tuner based on batched Gaussian Process Bandits (Golovin et al. 2017). For the LSTM, the tuned hyperparameters are the same: input_embedding_ratio, learning_rate, l2_penalty, input_dropout, inter_layer_dropout, state_dropout, output_dropout. For the Mogrifier, the number of rounds $r$ and the rank $k$ of the low-rank approximation is also tuned (allowing for full rank, too). For word-level tasks, BPTT (Werbos et al. 1990) window size is set to 70 and batch size to 64. For character-level tasks, BPTT window size is set to 150 and batch size to 128 except for Enwik8 where the window size is 500. Input and output embeddings are tied for word-level tasks following Inan et al. (2016) and Press and Wolf (2016). Optimization is performed with Adam (Kingma and Ba 2014) with $\\beta _ { 1 } = 0$ , a setting that resembles RMSProp without momentum. Gradients are clipped (Pascanu et al. 2013) to norm 10. We switch to averaging weights similarly to Merity et al. (2017) after a certain number of checkpoints with no improvement in validation cross-entropy or at $80 \\%$ of the training time at the latest. We found no benefit to using two-step finetuning. ",
+        "bbox": [
+            174,
+            518,
+            825,
+            699
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Model evaluation is performed with the standard, deterministic dropout approximation or MonteCarlo averaging (Gal and Ghahramani 2016) where explicitly noted (MC). In standard dropout evaluation, dropout is turned off while in MC dropout predictions are averaged over randomly sampled dropout masks (200 in our experiments). Optimal softmax temperature is determined on the validation set, and in the MC case dropout rates are scaled (Melis et al. 2018). Finally, we report results with and without dynamic evaluation (Krause et al. 2017). Hyperparameters for dynamic evaluation are tuned using the same method (see Appendix A for details). ",
+        "bbox": [
+            174,
+            705,
+            825,
+            804
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We make the code and the tuner output available at https://github.com/deepmind/lamb. ",
+        "bbox": [
+            176,
+            810,
+            738,
+            825
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.4 RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            842,
+            277,
+            856
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Table 1 lists our results on word-level datasets. On the PTB and Wikitext-2 datasets, the Mogrifier has lower perplexity than the LSTM by 3–4 perplexity points regardless of whether or not dynamic evaluation (Krause et al. 2017) and Monte-Carlo averaging are used. On both datasets, the state of the art is held by the AWD LSTM (Merity et al. 2017) extended with Mixture of Softmaxes (Yang et al. 2017) and FRAGE (Gong et al. 2018). The Mogrifier improves the state of the art without either of these methods on PTB, and without FRAGE on Wikitext-2. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/5c6da658f5834dd6dbf7554ea39324cf89df0c8f8d2ef15543a8b449dd9f8f55.jpg",
+        "table_caption": [
+            "Table 2: Bits per character on character-based datasets of near state-of-the-art models, our LSTM baseline and the Mogrifier. Previous state-of-the-art results in italics. Depth N is denoted with dN. MC stands for Monte-Carlo dropout evaluation. Once again the Mogrifier strictly dominates the LSTM and sets a new state of the art on all but the Enwik8 dataset where with dynamic evaluation it closes the gap to the Transformer-XL of similar size $^ { \\dagger }$ Krause et al. (2019), $^ \\ddag$ Ben Krause, personal communications, May 17, 2019). On most datasets, model size was set large enough for underfitting not to be an issue. This was very much not the case with Enwik8, so we grouped models of similar sizes together for ease of comparison. Unfortunately, a couple of dynamic evaluation test runs diverged (NaN) on the test set and some were just too expensive to run (Enwik8, MC). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\" colspan=\"2\"></td><td rowspan=\"2\"></td><td colspan=\"2\">No Dyneval</td><td colspan=\"2\">Dyneval</td></tr><tr><td>Val.</td><td>Test</td><td>Val.</td><td>Test</td></tr><tr><td rowspan=\"7\">B 图</td><td>Trellis Networks (Bai et al.2018)</td><td>13.4M</td><td></td><td>1.159</td><td></td><td></td></tr><tr><td>AWD-LSTM (d3) (Merity et al.2017)</td><td>13.8M</td><td></td><td>1.175</td><td></td><td></td></tr><tr><td>LSTM (d2)</td><td>24M</td><td>1.163</td><td>1.143</td><td>1.116</td><td>1.103</td></tr><tr><td>Mogrifier (d2)</td><td>24M</td><td>1.149</td><td>1.131</td><td>1.098</td><td>1.088</td></tr><tr><td>LSTM (d2, MC)</td><td>24M</td><td>1.159</td><td>1.139</td><td>1.115</td><td>1.101</td></tr><tr><td>Mogrifier (d2, MC)</td><td>24M</td><td>1.137</td><td>1.120</td><td>1.094</td><td>1.083</td></tr><tr><td>HCLM with Cache (Kawakami et al. 2017)</td><td>8M</td><td>1.591</td><td>1.538</td><td></td><td></td></tr><tr><td rowspan=\"5\">WMW 图</td><td>LSTM (d1) (Kawakami et al.2017)</td><td>8M</td><td>1.793</td><td>1.736</td><td></td><td></td></tr><tr><td>LSTM (d2)</td><td>24M</td><td>1.353</td><td>1.338</td><td>1.239</td><td>1.225</td></tr><tr><td>Mogrifier (d2)</td><td>24M</td><td>1.319</td><td>1.305</td><td>1.202</td><td>1.188</td></tr><tr><td>LSTM (d2, MC)</td><td>24M</td><td>1.346</td><td>1.332</td><td>1.238</td><td>NaN</td></tr><tr><td>Mogrifier (d2, MC)</td><td>24M</td><td>1.312</td><td>1.298</td><td>1.200</td><td>1.187</td></tr><tr><td rowspan=\"6\">JMN H</td><td>HCLM with Cache (Kawakami et al. 2017)</td><td>8M</td><td>1.754</td><td>1.711</td><td></td><td></td></tr><tr><td>LSTM (d1) (Kawakami et al. 2017)</td><td>8M</td><td>1.943</td><td>1.913</td><td></td><td></td></tr><tr><td>LSTM (d2)</td><td>24M</td><td>1.382</td><td>1.367</td><td>1.249</td><td>1.237</td></tr><tr><td>Mogrifier (d2)</td><td>24M</td><td>1.338</td><td>1.326</td><td>1.202</td><td>1.191</td></tr><tr><td>LSTM (d2, MC)</td><td>24M</td><td>1.377</td><td>1.361</td><td>1.247</td><td>1.234</td></tr><tr><td>Mogrifier (d2, MC)</td><td>24M</td><td>1.327</td><td>1.313</td><td>1.198</td><td>NaN</td></tr><tr><td rowspan=\"19\">grirg 图</td><td>Transformer-XL (d24) (Dai et al.2019)</td><td>277M</td><td></td><td>0.993</td><td></td><td>0.940t</td></tr><tr><td>Transformer-XL (d18) (Dai et al.2019)</td><td>88M</td><td></td><td>1.03</td><td></td><td></td></tr><tr><td>LSTM (d4)</td><td>96M</td><td>1.145</td><td>1.155</td><td>1.041</td><td>1.020</td></tr><tr><td>Mogrifier (d4)</td><td>96M</td><td>1.110</td><td>1.122</td><td>1.009</td><td>0.988</td></tr><tr><td>LSTM (d4,MC)</td><td>96M</td><td>1.139</td><td>1.147</td><td></td><td></td></tr><tr><td>Mogrifier (d4, MC)</td><td>96M</td><td>1.104</td><td>1.116</td><td></td><td></td></tr><tr><td>Transformer-XL (d12) (Dai et al.2019)</td><td>41M</td><td></td><td>1.06</td><td></td><td>1.01t</td></tr><tr><td>AWD-LSTM (d3) (Merity et al.2017)</td><td>47M</td><td></td><td>1.232</td><td></td><td></td></tr><tr><td>mLSTM (d1) (Krause et al. 2016)</td><td>46M</td><td></td><td>1.24</td><td></td><td>1.08</td></tr><tr><td>LSTM (d4)</td><td>48M</td><td>1.182</td><td>1.195</td><td>1.073</td><td>1.051</td></tr><tr><td>Mogrifier (d4)</td><td>48M</td><td>1.135</td><td>1.146</td><td>1.035</td><td>1.012</td></tr><tr><td>LSTM (d4, MC)</td><td>48M</td><td>1.176</td><td>1.188</td><td></td><td></td></tr><tr><td>Mogrifier (d4,MC)</td><td>48M</td><td>1.130</td><td>1.140</td><td></td><td></td></tr></table>",
+        "bbox": [
+            207,
+            213,
+            789,
+            683
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            734,
+            821,
+            763
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Table 2 lists the character-level modelling results. On all datasets, our baseline LSTM results are much better than those previously reported for LSTMs, highlighting the issue of scalability and experimental controls. In some cases, these unexpectedly large gaps may be down to lack of hyperparameter tuning as in the case of Merity et al. (2017), or in others, to using a BPTT window size (50) that is too small for character-level modelling (Melis et al. 2017) in order to fit the model into memory. The Mogrifier further improves on these baselines by a considerable margin. Even the smallest improvement of 0.012 bpc on the highly idiosyncratic, character-based, Mikolov preprocessed PTB task is equivalent to gaining about 3 perplexity points on word-level PTB. MWC, which was built for open-vocabulary language modelling, is a much better smaller-scale character-level dataset. On the English and the Finnish corpora in MWC, the Mogrifier enjoys a gap of 0.033-0.046 bpc. Finally, on the Enwik8 dataset, the gap is 0.029-0.039 bpc in favour of the Mogrifier. ",
+        "bbox": [
+            174,
+            770,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/8e5b3999aec46787fd29a456dd1258eff2770c1e5a461c0cb04ac34807783f39.jpg",
+        "image_caption": [
+            "Figure 2: “No-zigzag” Mogrifier for the ablation study. Gating is always based on the original inputs. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            253,
+            106,
+            740,
+            208
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/030bb0b3a3f4c2153f332c0f6c146b2bbe4a439cd4bc6c7dd9ff3bbd7abe5fe0.jpg",
+        "table_caption": [
+            "Table 3: PTB ablation study validation perplexities with 24M parameters. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Mogrifier Full rank Qi, Pi</td><td>54.1 54.6</td></tr><tr><td>No zigzag LSTM</td><td>55.0</td></tr><tr><td>mLSTM</td><td>57.5 57.8</td></tr></table>",
+        "bbox": [
+            586,
+            291,
+            823,
+            371
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/852bf26d28d8cdb3459ace2f5cae5d33d812f1bd074e3b3b79f4281c02334002.jpg",
+        "image_caption": [
+            "Figure 3: Perplexity vs the rounds $r$ in the PTB ablation study. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            247,
+            560,
+            352
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Of particular note is the comparison to Transformer-XL (Dai et al. 2019), a state-of-the-art model on larger datasets such as Wikitext-103 and Enwik8. On PTB, without dynamic evaluation, the Transformer-XL is on par with our LSTM baseline which puts it about 3.5 perplexity points behind the Mogrifier. On Enwik8, also without dynamic evaluation, the Transformer-XL has a large, 0.09 bpc advantage at similar parameter budgets, but with dynamic evaluation this gap disappears. However, we did not test the Transformer-XL ourselves, so fair comparison is not possible due to differing experimental setups and the rather sparse result matrix for the Transformer-XL. ",
+        "bbox": [
+            173,
+            401,
+            825,
+            500
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            518,
+            290,
+            535
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 ABLATION STUDY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            549,
+            341,
+            564
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The Mogrifier consistently outperformed the LSTM in our experiments. The optimal settings were similar across all datasets, with $r \\in \\{ 5 , 6 \\}$ and $k \\in [ 4 0 \\dots 9 0 ]$ (see Appendix B for a discussion of hyperparameter sensitivity). In this section, we explore the effect of these hyperparameters and show that the proposed model is not unnecessarily complicated. To save computation, we tune all models using a shortened schedule with only 145 epochs instead of 964 and a truncated BPTT window size of 35 on the word-level PTB dataset, and evaluate using the standard, deterministic dropout approximation with a tuned softmax temperature. ",
+        "bbox": [
+            173,
+            575,
+            825,
+            674
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Fig. 3 shows that the number of rounds $r$ greatly influences the results. Second, we found the low-rank factorization of $\\mathbf { Q } ^ { i }$ and $\\mathbf { R } ^ { i }$ to help a bit, but the full-rank variant is close behind which is what we observed on other datasets, as well. Finally, to verify that the alternating gating scheme is not overly complicated, we condition all newly introduced gates on the original inputs $_ { \\textbf { \\em x } }$ and $h _ { p r e \\nu }$ (see Fig. 2). That is, instead of Eq. 1 and Eq. 2 the no-zigzag updates are ",
+        "bbox": [
+            173,
+            680,
+            826,
+            751
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/389d111f05c2b0954c78c34446c129fa5cbb8c358261f5366b202d0e854246e8.jpg",
+        "text": "$$\n\\begin{array} { r } { \\begin{array} { r l } & { \\qquad \\mathbf { \\Delta } x ^ { i } = 2 \\sigma ( \\mathbf { Q } ^ { i } h _ { p r e \\nu } ) \\odot \\mathbf { \\Delta } x ^ { i - 2 } \\qquad } & { \\mathrm { ~ f o r ~ o d d ~ i \\in [ 1 \\dots { } } , } \\\\ { h _ { p r e \\nu } ^ { i } = 2 \\sigma ( \\mathbf { R } ^ { i } x ) \\odot h _ { p r e \\nu } ^ { i - 2 } \\qquad } & { \\mathrm { ~ f o r ~ e v e n ~ i \\in [ 1 \\dots { } } . . . r ] . } \\end{array} } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            281,
+            751,
+            718,
+            795
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In our experiments, the no-zigzag variant underperformed the baseline Mogrifier by a small but significant margin, and was on par with the $r = 2$ model in Fig. 3 suggesting that the Mogrifier’s iterative refinement scheme does more than simply widen the range of possible gating values of $_ { \\textbf { \\em x } }$ and $h _ { p r e \\nu }$ to $( 0 , 2 ^ { \\lceil r / 2 \\rceil } )$ and $( 0 , 2 ^ { \\lfloor r / 2 \\rfloor } )$ , respectively. ",
+        "bbox": [
+            173,
+            796,
+            825,
+            853
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 COMPARISON TO THE MLSTM ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            869,
+            428,
+            883
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The Multiplicative LSTM (Krause et al. 2016), or mLSTM for short, is closest to our model in the literature. It is defined as $\\mathrm { m L S T M } ( { \\pmb x } , { \\pmb c } _ { p r e \\nu } , { \\pmb h } _ { p r e \\nu } ) = \\mathrm { L S T M } ( { \\pmb x } , { \\pmb c } _ { p r e \\nu } , { \\pmb h } _ { p r e \\nu } ^ { m } )$ , where $h _ { p r e \\nu } ^ { m } =$ $( \\mathbf { W } ^ { m x } \\pmb { x } ) \\odot ( \\mathbf { W } ^ { m h } h _ { p r e \\nu } )$ . In this formulation, the differences are readily apparent. First, the mLSTM allows for multiplicative interaction between $_ { \\textbf { \\em x } }$ and $h _ { p r e \\nu }$ , but it only overrides $h _ { p r e \\nu }$ , while in the Mogrifier the interaction is two-way, which – as the ablation study showed – is important. Second, the mLSTM can change not only the magnitude but also the sign of values in $h _ { p r e \\nu }$ , something with which we experimented in the Mogrifier, but could not get to work. Furthermore, in the definition of $\\boldsymbol { h } _ { p r e \\nu } ^ { m }$ , the unsquashed linearities and their elementwise product make the mLSTM more sensitive to initialization and unstable during optimization. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            925
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/40e466949e4d8b242d1379123618e59c3833987134b31ce0cb6c3a6ab2f42f98.jpg",
+        "image_caption": [
+            "Figure 4: Cross-entropy vs sequence length in the reverse copy task with i.i.d. tokens. Lower is better. The Mogrifier is better than the LSTM even in this synthetic task with no resemblance to natural language. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            98,
+            805,
+            244
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            314,
+            825,
+            411
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "On the Enwik8 dataset, we greatly improved on the published results of the mLSTM (Krause et al. 2016). In fact, even our LSTM baseline outperformed the mLSTM by 0.03 bpc. We also conducted experiments on PTB based on our reimplementation of the mLSTM following the same methodology as the ablation study and found that the mLSTM did not improve on the LSTM (see Table 3). ",
+        "bbox": [
+            174,
+            419,
+            825,
+            474
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Krause et al. (2016) posit and verify the recovery hypothesis which says that having just suffered a large loss, the loss on the next time step will be smaller on average for the mLSTM than for the LSTM. This was found not to be the case for the Mogrifier. Neither did we observe a significant change in the gap between the LSTM and the Mogrifier in the tied and untied embeddings settings, which would be expected if recovery was affected by $_ { \\textbf { \\em x } }$ and $h _ { p r e \\nu }$ being in different domains. ",
+        "bbox": [
+            174,
+            481,
+            825,
+            551
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.3 THE REVERSE COPY TASK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            574,
+            400,
+            589
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Our original motivation for the Mogrifier was to allow the context to amplify salient and attenuate nuisance features in the input embeddings. We conduct a simple experiment to support this point of view. Consider the reverse copy task where the network reads an input sequence of tokens and a marker token after which it has to repeat the input in reverse order. In this simple sequence-tosequence learning (Sutskever et al. 2014) setup, the reversal is intended to avoid the minimal time lag problem (Hochreiter and Schmidhuber 1997), which is not our focus here. ",
+        "bbox": [
+            174,
+            603,
+            825,
+            686
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The experimental setup is as follows. For the training set, we generate 500 000 examples by uniformly sampling a given number of tokens from a vocabulary of size 1000. The validation and test sets are constructed similarly, and contain 10 000 examples. The model consists of an independent, unidirectional encoder and a decoder, whose total number of parameters is 10 million. The decoder is initialized from the last state of the encoder. Since overfitting is not an issue here, no dropout is necessary, and we only tune the learning rate, the l2 penalty, and the embedding size for the LSTM. For the Mogrifier, the number of rounds $r$ and the rank $k$ of the low-rank approximation are also tuned. ",
+        "bbox": [
+            174,
+            694,
+            825,
+            805
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We compare the case where both the encoder and decoder are LSTMs to where both are Mogrifiers. Fig. 4a shows that, for sequences of length 50 and 100, both models can solve the task perfectly. At higher lengths though, the Mogrifier has a considerable advantage. Examining the best hyperparameter settings found, the embedding/hidden sizes for the LSTM and Mogrifier are 498/787 vs 41/1054 at 150 steps, and 493/790 vs 181/961 at 200 steps. Clearly, the Mogrifier was able to work with a much smaller embedding size than the LSTM, which is in line with our expectations for a model with a more flexible interaction between the input and recurrent state. We also conducted experiments with a larger model and vocabulary size, and found the effect even more pronounced (see Fig. 4b). ",
+        "bbox": [
+            174,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.4 WHAT THE MOGRIFIER IS NOT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            426,
+            117
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The results on the reverse copy task support our hypothesis that input embeddings are enriched by the Mogrifier architecture, but that cannot be the full explanation as the results of the ablation study indicate. In the following, we consider a number of hypotheses about where the advantage of the Mogrifier lies and the experiments that provide evidence against them. ",
+        "bbox": [
+            174,
+            131,
+            825,
+            186
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "E Hypothesis: the benefit is in scaling $_ { \\textbf { \\em x } }$ and $h _ { p r e \\nu }$ . We verified that data dependency is a crucial feature by adding a learnable scaling factor to the LSTM inputs. We observed no improvement. Also, at extremely low-rank (less than 5) settings where the amount of information in its gating is small, the Mogrifier loses its advantage.   \nE Hypothesis: the benefit is in making optimization easier. We performed experiments with different optimizers (SGD, RMSProp), with intra-layer batch normalization and layer normalization on the LSTM gates. While we cannot rule out an effect on optimization difficulty, in all of these experiments the gap between the LSTM and the Mogrifier was the same.   \nE Hypothesis: exact tying of embeddings is too constraining, the benefit is in making this relationship less strict. Experiments conducted with untied embeddings and character-based models demonstrate improvements of similar magnitude.   \nE Hypothesis: the benefit is in the low-rank factorization of ${ \\bf Q } ^ { i } , { \\bf R } ^ { i }$ implicitly imposing structure on the LSTM weight matrices. We observed that the full-rank Mogrifier also performed better than the plain LSTM. We conducted additional experiments where the LSTM’s gate matrices were factorized and observed no improvement.   \nE Hypothesis: the benefit comes from better performance on rare words. The observed advantage on character-based modelling is harder to explain based on frequency. Also, in the reverse copy experiments, a large number of tokens were sampled uniformly, so there were no rare words at all.   \nE Hypothesis: the benefit is specific to the English language. This is directly contradicted by the Finnish MWC and the reverse copy experiments.   \nE Hypothesis: the benefit is in handling long-range dependencies better. Experiments in the episodic setting (i.e. sentence-level language modelling) exhibited the same gap as the non-episodic ones.   \nE Hypothesis: the scaling up of inputs saturates the downstream LSTM gates. The idea here is that saturated gates may make states more stable over time. We observed the opposite: the means of the standard LSTM gates in the Mogrifier were very close between the two models, but their variance was smaller in the Mogrifier. ",
+        "bbox": [
+            176,
+            199,
+            826,
+            617
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSIONS AND FUTURE WORK ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            638,
+            504,
+            655
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We presented the Mogrifier LSTM, an extension to the LSTM, with state-of-the-art results on several language modelling tasks. Our original motivation for this work was that the context-free representation of input tokens may be a bottleneck in language models and by conditioning the input embedding on the recurrent state some benefit was indeed derived. While it may be part of the explanation, this interpretation clearly does not account for the improvements brought by conditioning the recurrent state on the input and especially the applicability to character-level datasets. Positioning our work on the Multiplicative RNN line of research offers a more compelling perspective. ",
+        "bbox": [
+            174,
+            672,
+            825,
+            770
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "To give more credence to this interpretation, in the analysis we highlighted a number of possible alternative explanations, and ruled them all out to varying degrees. In particular, the connection to the mLSTM is weaker than expected as the Mogrifier does not exhibit improved recovery (see Section 4.2), and on PTB the mLSTM works only as well as the LSTM. At the same time, the evidence against easier optimization is weak, and the Mogrifier establishing some kind of sharing between otherwise independent LSTM weight matrices is a distinct possibility. ",
+        "bbox": [
+            174,
+            777,
+            825,
+            861
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Finally, note that as shown by Fig. 1 and Eq. 1-2, the Mogrifier is a series of preprocessing steps composed with the LSTM function, but other architectures, such as Mogrifier GRU or Mogrifier Elman Network are possible. We also leave investigations into other forms of parameterization of context-dependent transitions for future work. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            922
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            104,
+            326,
+            117
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We would like to thank Ben Krause for the Transformer-XL dynamic evaluation results, Laura Rimell, Aida Nematzadeh, Angeliki Lazaridou, Karl Moritz Hermann, Daniel Fried for helping with experiments, Chris Dyer, Sebastian Ruder and Jack Rae for their valuable feedback. ",
+        "bbox": [
+            174,
+            128,
+            821,
+            170
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            190,
+            285,
+            205
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Aishwarya Agrawal, Dhruv Batra, and Devi Parikh. Analyzing the behavior of visual question answering models. arXiv preprint arXiv:1606.07356, 2016. ",
+        "bbox": [
+            174,
+            213,
+            823,
+            239
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Martin Arjovsky, Amar Shah, and Yoshua Bengio. Unitary evolution recurrent neural networks. In International Conference on Machine Learning, pages 1120–1128, 2016. ",
+        "bbox": [
+            176,
+            248,
+            821,
+            275
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. arXiv preprint arXiv:1409.0473, 2014. ",
+        "bbox": [
+            174,
+            284,
+            821,
+            311
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Shaojie Bai, J Zico Kolter, and Vladlen Koltun. Trellis networks for sequence modeling. arXiv preprint arXiv:1810.06682, 2018. ",
+        "bbox": [
+            173,
+            320,
+            823,
+            348
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Bram Bakker. Reinforcement learning with long short-term memory. In Advances in neural information processing systems, pages 1475–1482, 2002. ",
+        "bbox": [
+            173,
+            356,
+            823,
+            383
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yonatan Belinkov and Yonatan Bisk. Synthetic and natural noise both break neural machine translation. arXiv preprint arXiv:1711.02173, 2017. ",
+        "bbox": [
+            173,
+            392,
+            823,
+            420
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Junyoung Chung, Caglar Gulcehre, Kyunghyun Cho, and Yoshua Bengio. Gated feedback recurrent neural networks. In International Conference on Machine Learning, pages 2067–2075, 2015. ",
+        "bbox": [
+            169,
+            428,
+            821,
+            457
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Zihang Dai, Zhilin Yang, Yiming Yang, William W Cohen, Jaime Carbonell, Quoc V Le, and Ruslan Salakhutdinov. Transformer-xl: Attentive language models beyond a fixed-length context. arXiv preprint arXiv:1901.02860, 2019. ",
+        "bbox": [
+            173,
+            464,
+            823,
+            503
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. Bert: Pre-training of deep bidirectional transformers for language understanding. arXiv preprint arXiv:1810.04805, 2018. ",
+        "bbox": [
+            173,
+            512,
+            823,
+            540
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jeffrey L Elman. Finding structure in time. Cognitive science, 14(2):179–211, 1990. ",
+        "bbox": [
+            173,
+            549,
+            674,
+            564
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jakob N Foerster, Justin Gilmer, Jascha Sohl-Dickstein, Jan Chorowski, and David Sussillo. Input switched affine networks: An rnn architecture designed for interpretability. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pages 1136–1145. JMLR. org, 2017. ",
+        "bbox": [
+            173,
+            571,
+            825,
+            613
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yarin Gal and Zoubin Ghahramani. A theoretically grounded application of dropout in recurrent neural networks. In Advances in Neural Information Processing Systems, pages 1019–1027, 2016. ",
+        "bbox": [
+            173,
+            621,
+            825,
+            648
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Daniel Golovin, Benjamin Solnik, Subhodeep Moitra, Greg Kochanski, John Karro, and D Sculley. Google vizier: A service for black-box optimization. In Proceedings of the 23rd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, pages 1487–1495. ACM, 2017. ",
+        "bbox": [
+            174,
+            656,
+            823,
+            696
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Chengyue Gong, Di He, Xu Tan, Tao Qin, Liwei Wang, and Tie-Yan Liu. Frage: frequency-agnostic word representation. In Advances in Neural Information Processing Systems, pages 1334–1345, 2018. ",
+        "bbox": [
+            173,
+            705,
+            825,
+            733
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "David Ha, Andrew Dai, and Quoc V Le. Hypernetworks. arXiv preprint arXiv:1609.09106, 2016. ",
+        "bbox": [
+            171,
+            742,
+            754,
+            757
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sepp Hochreiter and Jürgen Schmidhuber. Lstm can solve hard long time lag problems. In Advances in neural information processing systems, pages 473–479, 1997. ",
+        "bbox": [
+            173,
+            765,
+            823,
+            792
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jeremy Howard and Sebastian Ruder. Universal language model fine-tuning for text classification. arXiv preprint arXiv:1801.06146, 2018. ",
+        "bbox": [
+            171,
+            801,
+            825,
+            828
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Marcus Hutter. The human knowledge compression contest. URL http://prize. hutter1. net, 6, 2012. ",
+        "bbox": [
+            176,
+            838,
+            764,
+            852
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Hakan Inan, Khashayar Khosravi, and Richard Socher. Tying word vectors and word classifiers: A loss framework for language modeling. CoRR, abs/1611.01462, 2016. URL http://arxiv.org/abs/1611.01462. ",
+        "bbox": [
+            174,
+            861,
+            825,
+            888
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Mohit Iyyer, John Wieting, Kevin Gimpel, and Luke Zettlemoyer. Adversarial example generation with syntactically controlled paraphrase networks. arXiv preprint arXiv:1804.06059, 2018. ",
+        "bbox": [
+            173,
+            897,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Robin Jia and Percy Liang. Adversarial examples for evaluating reading comprehension systems. arXiv preprint arXiv:1707.07328, 2017.   \nKazuya Kawakami, Chris Dyer, and Phil Blunsom. Learning to create and reuse words in open-vocabulary neural language modeling. arXiv preprint arXiv:1704.06986, 2017.   \nDiederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.   \nBen Krause, Liang Lu, Iain Murray, and Steve Renals. Multiplicative LSTM for sequence modelling. CoRR, abs/1609.07959, 2016. URL http://arxiv.org/abs/1609.07959.   \nBen Krause, Emmanuel Kahembwe, Iain Murray, and Steve Renals. Dynamic evaluation of neural sequence models. arXiv preprint arXiv:1709.07432, 2017.   \nBen Krause, Emmanuel Kahembwe, Iain Murray, and Steve Renals. Dynamic evaluation of transformer language models. arXiv preprint arXiv:1904.08378, 2019.   \nAdhiguna Kuncoro, Chris Dyer, John Hale, Dani Yogatama, Stephen Clark, and Phil Blunsom. Lstms can learn syntax-sensitive dependencies well, but modeling structure makes them better. In Proceedings of the 56th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 1426–1436, 2018.   \nTal Linzen, Emmanuel Dupoux, and Yoav Goldberg. Assessing the ability of lstms to learn syntax-sensitive dependencies. Transactions of the Association for Computational Linguistics, 4:521–535, 2016.   \nMitchell 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.   \nHermann Mayer, Faustino Gomez, Daan Wierstra, Istvan Nagy, Alois Knoll, and Jürgen Schmidhuber. A system for robotic heart surgery that learns to tie knots using recurrent neural networks. Advanced Robotics, 22 (13-14):1521–1537, 2008.   \nGábor Melis, Chris Dyer, and Phil Blunsom. On the state of the art of evaluation in neural language models. arXiv preprint arXiv:1707.05589, 2017.   \nGábor Melis, Charles Blundell, Tomáš Kocisk ˇ y, Karl Moritz Hermann, Chris Dyer, and Phil Blunsom. Pushing \\` the bounds of dropout. arXiv preprint arXiv:1805.09208, 2018.   \nStephen Merity, Caiming Xiong, James Bradbury, and Richard Socher. Pointer sentinel mixture models. CoRR, abs/1609.07843, 2016. URL http://arxiv.org/abs/1609.07843.   \nStephen Merity, Nitish Shirish Keskar, and Richard Socher. Regularizing and optimizing lstm language models. arXiv preprint arXiv:1708.02182, 2017.   \nStephen Merity, Nitish Shirish Keskar, and Richard Socher. An analysis of neural language modeling at multiple scales. arXiv preprint arXiv:1803.08240, 2018.   \nTomas Mikolov, Martin Karafiát, Lukas Burget, Jan Cernocky, and Sanjeev Khudanpur. Recurrent neural \\` network based language model. In Interspeech, volume 2, page 3, 2010.   \nNafise Sadat Moosavi and Michael Strube. Lexical features in coreference resolution: To be used with caution. arXiv preprint arXiv:1704.06779, 2017.   \nRazvan Pascanu, Tomas Mikolov, and Yoshua Bengio. On the difficulty of training recurrent neural networks. In International conference on machine learning, pages 1310–1318, 2013.   \nMatthew E Peters, Mark Neumann, Mohit Iyyer, Matt Gardner, Christopher Clark, Kenton Lee, and Luke Zettlemoyer. Deep contextualized word representations. arXiv preprint arXiv:1802.05365, 2018.   \nOfir Press and Lior Wolf. Using the output embedding to improve language models. CoRR, abs/1608.05859, 2016. URL http://arxiv.org/abs/1608.05859.   \nDavid E Rumelhart, Geoffrey E Hinton, Ronald J Williams, et al. Learning representations by back-propagating errors. Cognitive modeling, 5(3):1, 1988.   \nHasim Sak, Andrew W. Senior, and Françoise Beaufays. Long short-term memory based recurrent neural network architectures for large vocabulary speech recognition. CoRR, abs/1402.1128, 2014. URL http: //arxiv.org/abs/1402.1128.   \nRico Sennrich, Barry Haddow, and Alexandra Birch. Neural machine translation of rare words with subword units. arXiv preprint arXiv:1508.07909, 2015.   \nIlya Sutskever, James Martens, and Geoffrey E Hinton. Generating text with recurrent neural networks. In Proceedings of the 28th International Conference on Machine Learning (ICML-11), pages 1017–1024, 2011.   \nIlya 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.   \nChong Wang, Yining Wang, Po-Sen Huang, Abdelrahman Mohamed, Dengyong Zhou, and Li Deng. Sequence modeling via segmentations. In Proceedings of the 34th International Conference on Machine LearningVolume 70, pages 3674–3683. JMLR. org, 2017.   \nPaul J Werbos et al. Backpropagation through time: what it does and how to do it. Proceedings of the IEEE, 78 (10):1550–1560, 1990.   \nYuhuai Wu, Saizheng Zhang, Ying Zhang, Yoshua Bengio, and Ruslan R Salakhutdinov. On multiplicative integration with recurrent neural networks. In Advances in neural information processing systems, pages 2856–2864, 2016.   \nZhilin Yang, Zihang Dai, Ruslan Salakhutdinov, and William W Cohen. Breaking the softmax bottleneck: a high-rank rnn language model. arXiv preprint arXiv:1711.03953, 2017.   \nBarret Zoph and Quoc V. Le. Neural architecture search with reinforcement learning. CoRR, abs/1611.01578, 2016. URL http://arxiv.org/abs/1611.01578. ",
+        "bbox": [
+            169,
+            71,
+            828,
+            926
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            828,
+            404
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX A HYPERPARAMETER TUNING RANGES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            612,
+            118
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "In all experiments, we tuned hyperparameters using Google Vizier (Golovin et al. 2017). The tuning ranges are listed in Table 4. Obviously, mogrifier_rounds and mogrifier_rank are tuned only for the Mogrifier. If input_embedding_ratio $\\geqslant 1$ , then the input/output embedding sizes and the hidden sizes are set to equal and the linear projection from the cell output into the output embeddings space is omitted. Similarly, mogrif ier_rank $\\leqslant 0$ is taken to mean full rank $\\mathbf { Q } ^ { * }$ , $\\mathbf { R } ^ { * }$ without factorization. Since Enwik8 is a much larger dataset, we don’t tune input_embedding_ratio and specify tighter tuning ranges for dropout based on preliminary experiments (see Table 5). ",
+        "bbox": [
+            174,
+            133,
+            825,
+            231
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Dynamic evaluation hyperparameters were tuned according to Table 6. The highest possible value for max_time_steps, the BPTT window size, was 20 for word, and 50 for character-level tasks. The batch size for estimating the mean squared gradients over the training data was set to 1024, gradient clipping was turned off, and the l2 penalty was set to zero. ",
+        "bbox": [
+            176,
+            238,
+            825,
+            294
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/cea9deac5c7e48f225a673e03b6f3216f912b7f77e4bbc5725419f9bee237af4.jpg",
+        "table_caption": [
+            "Table 4: Hyperparameter tuning ranges for all tasks except Enwik8. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>learning_rate input_embedding_ratio 12_penalty</td><td>Low High 0.001 0.004 0.0 2.0 5e-6 0.0</td><td>Spacing log</td></tr><tr><td>input_dropout</td><td>1e-3 0.9</td><td>log</td></tr><tr><td>inter_layer_dropout</td><td>0.0 0.95</td><td></td></tr><tr><td>state_dropout</td><td>0.0</td><td></td></tr><tr><td></td><td></td><td>0.8</td></tr><tr><td>output_dropout</td><td>0.0</td><td>0.95</td></tr><tr><td>mogrifier_rounds (r)</td><td>0</td><td>6</td></tr><tr><td>mogrifier_rank (k)</td><td>-20</td><td>100</td></tr></table>",
+        "bbox": [
+            338,
+            332,
+            656,
+            468
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/9cb5cdad6ea227e723dd16e480f6b10f4a102b52c933772ad03e63bf692e9ab6.jpg",
+        "table_caption": [
+            "Table 5: Hyperparameter tuning ranges for Enwik8. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>learning_rate</td><td>High 0.004</td><td>Spacing log</td></tr><tr><td>12_penalty input_dropout</td><td>1e-3 0.2</td><td>log</td></tr><tr><td></td><td></td><td></td></tr><tr><td>inter_layer_dropout</td><td>0.2</td><td></td></tr><tr><td>state_dropout</td><td>0.25</td><td></td></tr><tr><td>output_dropout</td><td>0.0 0.0</td><td>0.25</td></tr><tr><td>mogrifier_rounds (r)</td><td>0</td><td>6</td></tr><tr><td>mogrifier_rank (k)</td><td>-20</td><td>100</td></tr></table>",
+        "bbox": [
+            344,
+            513,
+            651,
+            637
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/9bc2d3190ecba18f3f89e052d885b101e248d503e61886fa556d28761207a2d4.jpg",
+        "table_caption": [
+            "Table 6: Hyperparameter tuning ranges for dynamic evaluation. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>max_time_steps</td><td>Low 1</td><td>High 20/50</td><td>Spacing</td></tr><tr><td>dyneval_learning_rate</td><td>1e-6</td><td>1e-3</td><td>log</td></tr><tr><td>dyneval_decay_rate</td><td>1e-6</td><td>1e-2</td><td>log</td></tr><tr><td>dyneval_epsilon</td><td>1e-8</td><td>1e-2</td><td>log</td></tr></table>",
+        "bbox": [
+            343,
+            681,
+            653,
+            755
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX B HYPERPARAMETER SENSITIVITY ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            575,
+            118
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The parallel coordinate plots in Fig. 5 and 6, give a rough idea about hyperparameter sensitivity. The red lines correspond to hyperparameter combinations closest to the best solution found. To find the closest combinations, we restricted the range for each hyperparameter separately to about $15 \\%$ of its entire tuning range. ",
+        "bbox": [
+            174,
+            133,
+            825,
+            189
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "For both the LSTM and the Mogrifier, the results are at most 1.2 perplexity points off the best result, so our results are somewhat insensitive to jitter in the hyperparameters. Still, in this setup, grid search would require orders of magnitude more trials to find comparable solutions. ",
+        "bbox": [
+            174,
+            196,
+            825,
+            238
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "On the other hand, the tuner does take advantage of the stochasticity of training, and repeated runs with the same parameters may be give slightly worse results. To gauge the extent of this effect, on PTB we estimated the standard deviation in reruns of the LSTM with the best hyperparameters to be about 0.2 perplexity points, but the mean was about 0.7 perplexity points off the result produced with the weights saved in best tuning run. ",
+        "bbox": [
+            174,
+            246,
+            825,
+            315
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/afb8079b15a076212114180f4750055a09a47c2eb4a634e19a74869520fc2b85.jpg",
+        "image_caption": [
+            "Figure 5: Average per-word validation cross-entropies for hyperparameter combinations in the neighbourhood of the best solution for a 2-layer LSTM with 24M weights on the Penn Treebank dataset. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            204,
+            334,
+            879,
+            558
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/140b069ba910a4c8e4633dda009b26b47dea4047575f6eb908ca93ab701ae3fe.jpg",
+        "image_caption": [
+            "Figure 6: Average per-word validation cross-entropies for hyperparameter combinations in the neighbourhood of the best solution for a 2-layer Mogrifier LSTM with 24M weights on the Penn Treebank dataset. feature_mask_rank and feature_mask_rounds are aliases for mogrifier_rank and mogrifier_rounds "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            192,
+            625,
+            885,
+            851
+        ],
+        "page_idx": 12
+    }
+]

parse/train/rkl03ySYDH/rkl03ySYDH.md

@@ -0,0 +1,352 @@
+# SPACE: UNSUPERVISED OBJECT-ORIENTED SCENE REPRESENTATION VIA SPATIAL ATTENTION AND DECOMPOSITION
+
+{Zhixuan $\mathbf { L i n ^ { 1 , 2 } }$ ∗, Yi-Fu $\mathbf { W } \mathbf { u } ^ { 1 }$ , Skand Vishwanath Peri1,} Weihao $\mathbf { S u n ^ { 1 } }$ , Gautam Singh1, Fei Deng1, Jindong Jiang1, Sungjin Ahn1
+
+1Rutgers University & 2Zhejiang University
+
+# ABSTRACT
+
+The ability to decompose complex multi-object scenes into meaningful abstractions like objects is fundamental to achieve higher-level cognition. Previous approaches for unsupervised object-oriented scene representation learning are either based on spatial-attention or scene-mixture approaches and limited in scalability which is a main obstacle towards modeling real-world scenes. In this paper, we propose a generative latent variable model, called SPACE, that provides a unified probabilistic modeling framework that combines the best of spatial-attention and scene-mixture approaches. SPACE can explicitly provide factorized object representations for foreground objects while also decomposing background segments of complex morphology. Previous models are good at either of these, but not both. SPACE also resolves the scalability problems of previous methods by incorporating parallel spatial-attention and thus is applicable to scenes with a large number of objects without performance degradations. We show through experiments on Atari and 3D-Rooms that SPACE achieves the above properties consistently in comparison to SPAIR, IODINE, and GENESIS. Results of our experiments can be found on our project website: https://sites.google.com/view/space-project-page
+
+# 1 INTRODUCTION
+
+One of the unsolved key challenges in machine learning is unsupervised learning of structured representation for a visual scene containing many objects with occlusion, partial observability, and complex background. When properly decomposed into meaningful abstract entities such as objects and spaces, this structured representation brings many advantages of abstract (symbolic) representation to areas where contemporary deep learning approaches with a global continuous vector representation of a scene have not been successful. For example, a structured representation may improve sample efficiency for downstream tasks such as a deep reinforcement learning agent (Mnih et al., 2013). It may also enable visual variable binding (Sun, 1992) for reasoning and causal inference over the relationships between the objects and agents in a scene. Structured representations also provide composability and transferability for better generalization.
+
+Recent approaches to this problem of unsupervised object-oriented scene representation can be categorized into two types of models: scene-mixture models and spatial-attention models. In scenemixture models (Greff et al., 2017; 2019; Burgess et al., 2019; Engelcke et al., 2019), a visual scene is explained by a mixture of a finite number of component images. This type of representation provides flexible segmentation maps that can handle objects and background segments of complex morphology. However, since each component corresponds to a full-scale image, important physical features of objects like position and scale are only implicitly encoded in the scale of a full image and further disentanglement is required to extract these useful features. Also, since it does not explicitly reflect useful inductive biases like the locality of an object in the Gestalt principles (Koffka, 2013), the resulting component representation is not necessarily a representation of a local area. Moreover, to obtain a complete scene, a component needs to refer to other components, and thus inference is inherently performed sequentially, resulting in limitations in scaling to scenes with many objects.
+
+In contrast, spatial-attention models (Eslami et al., 2016; Crawford & Pineau, 2019) can explicitly obtain the fully disentangled geometric representation of objects such as position and scale. Such features are grounded on the semantics of physics and should be useful in many ways (e.g., sample efficiency, interpretability, geometric reasoning and inference, transferability). However, these models cannot represent complex objects and background segments that have too flexible morphology to be captured by spatial attention (i.e. based on rectangular bounding boxes). Similar to scene-mixture models, previous models in this class show scalability issues as objects are processed sequentially.
+
+In this paper, we propose a method, called Spatially Parallel Attention and Component Extraction (SPACE), that combines the best of both approaches. SPACE learns to process foreground objects, which can be captured efficiently by bounding boxes, by using parallel spatial-attention while decomposing the remaining area that includes both morphologically complex objects and background segments by using component mixtures. Thus, SPACE provides an object-wise disentangled representation of foreground objects along with explicit properties like position and scale per object while also providing decomposed representations of complex background components. Furthermore, by fully parallelizing the foreground object processing, we resolve the scalability issue of existing spatial attention methods. In experiments on 3D-room scenes and Atari game scenes, we quantitatively and qualitatively compare the representation of SPACE to other models and show that SPACE combines the benefits of both approaches in addition to significant speed-ups due to the parallel foreground processing.
+
+The contributions of the paper are as follows. First, we introduce a model that unifies the benefits of spatial-attention and scene-mixture approaches in a principled framework of probabilistic latent variable modeling. Second, we introduce a spatially parallel multi-object processing module and demonstrate that it can significantly mitigate the scalability problems of previous methods. Lastly, we provide an extensive comparison with previous models where we illustrate the capabilities and limitations of each method.
+
+# 2 THE PROPOSED MODEL: SPACE
+
+In this section, we describe our proposed model, Spatially Parallel Attention and Component Extraction (SPACE). The main idea of SPACE, presented in Figure 1, is to propose a unified probabilistic generative model that combines the benefits of the spatial-attention and scene-mixture models.
+
+# 2.1 GENERATIVE PROCESS
+
+SPACE assumes that a scene $\mathbf { x }$ is decomposed into two independent latents: foreground $\mathbf { z } ^ { \mathrm { f g } }$ and background $\mathbf { z } ^ { \mathrm { { b g } } }$ . The foreground is further decomposed into a set of independent foreground objects ${ \bf z } ^ { \mathrm { f g } } = \{ { \bf z } _ { i } ^ { \mathrm { f g } } \}$ and the background is also decomposed further into a sequence of background segments zbg = zbg1:K . While our choice of modeling the foreground and background independently worked well empirically, for better generation, it may also be possible to condition one on the other. The image distributions of the foreground objects and the background components are combined together with a pixel-wise mixture model to produce the complete image distribution:
+
+$$
+p ( \mathbf { x } | \mathbf { z } ^ { \mathrm { { f g } } } , \mathbf { z } ^ { \mathrm { { b g } } } ) = \alpha \underbrace { p ( \mathbf { x } | \mathbf { z } ^ { \mathrm { { f g } } } ) } _ { \mathrm { F o r e g r o u n d } } + ( 1 - \alpha ) \sum _ { k = 1 } ^ { K } \pi _ { k } \underbrace { p ( \mathbf { x } | \mathbf { z } _ { k } ^ { \mathrm { { b g } } } ) } _ { \mathrm { B a c k g r o u n d } } .
+$$
+
+Here, the foreground mixing probability $\alpha$ is computed as $\alpha = f _ { \alpha } ( { \mathbf { z } } ^ { \mathrm { f g } } )$ . This way, the foreground is given precedence in assigning its own mixing weight and the remaining is apportioned to the background. The mixing weight assigned to the background is further sub-divided among the $K$ background components. These weights are computed as $\pi _ { k } = f _ { \pi _ { k } } ( \mathbf { z } _ { 1 : k } ^ { \mathrm { b g } } )$ and $\textstyle \sum _ { k } \pi _ { k } = 1$ . With these notations, the complete generative model can be described as follows.
+
+$$
+p ( { \bf x } ) = \iint p ( { \bf x } | { \bf z } ^ { \mathrm { f g } } , { \bf z } ^ { \mathrm { b g } } ) p ( { \bf z } ^ { \mathrm { b g } } ) p ( { \bf z } ^ { \mathrm { f g } } ) d { \bf z } ^ { \mathrm { f g } } d { \bf z } ^ { \mathrm { b g } }
+$$
+
+![](images/d492475fa2250037e9a55b7bb08fad7626b1ed05019bd0248eaec35ce772d62f.jpg)  
+Figure 1: Illustration of the SPACE model. SPACE consists of a foreground module and a background module. In the foreground module, the input image is divided into a grid of $H \times W$ cells $( 4 \times 4$ in the figure). An image encoder is used to compute the $z ^ { \mathrm { { \bar { w h e r e } } } }$ , $z ^ { \mathrm { d e p t h } }$ , and $z ^ { \mathrm { p r e s } }$ for each cell in parallel. $z ^ { \mathrm { w h e r e } }$ is used to identify proposal bounding boxes and a spatial transformer is used to attend to each bounding box in parallel, computing a $z ^ { \mathrm { w h a t } }$ encoding for each cell. The model selects patches using the bounding boxes and reconstructs them using a VAE from all the foreground latents $z ^ { \mathrm { f g } }$ . The background module segments the scene into $K$ components (4 in the figure) using a pixel-wise mixture model. Each component consists of a set of latents $z ^ { \mathrm { b g } } = ( z ^ { m } , z ^ { c } )$ where z m models the mixing probability of the component and $z ^ { c }$ models the RGB distribution of the component. The components are combined to reconstruct the background using a VAE. The reconstructed background and foreground are then combined using a pixel-wise mixture model to generate the full reconstructed image.
+
+We now describe the foreground and background models in more detail.
+
+Foreground. SPACE implements $\mathbf { z } ^ { \mathrm { f g } }$ as a structured latent. In this structure, an image is treated as if it were divided into $H \times W$ cells and each cell is tasked with modeling at most one (nearby) object in the scene. This type of structuring has been used in (Redmon et al., 2016; Santoro et al., 2017; Crawford & Pineau, 2019). Similar to SPAIR, in order to model an object, each cell $i$ is associated with a set of latents $( \mathbf { z } _ { i } ^ { \mathrm { p r e s } } , \mathbf { z } _ { i } ^ { \mathrm { w h e r e } } , \mathbf { z } _ { i } ^ { \mathrm { d e p t h } } , \mathbf { z } _ { i } ^ { \mathrm { w h a t } } )$ . In this notation, $\mathbf { z } ^ { \mathrm { p r e s } }$ is a binary random variable denoting if the cell models any object or not, $\mathbf { z } ^ { \mathrm { w h e r e } }$ denotes the size of the object and its location relative to the cell, $\mathbf { z } ^ { \mathrm { d e p t h } }$ denotes the depth of the object to resolve occlusions and $\mathbf { z } ^ { \mathrm { w h a t } }$ models the object appearance and its mask. These latents may then be used to compute the foreground image component $p ( \mathbf { x } | \mathbf { z } ^ { \mathrm { f g } } )$ which is modeled as a Gaussian distribution $\mathcal { N } ( \mu ^ { \mathrm { f g } } , \sigma _ { \mathrm { f g } } ^ { 2 } )$ . In practice, we treat $\sigma _ { \mathrm { f g } } ^ { 2 }$ as a hyperparameter and decode only the mean image $\mu ^ { \mathrm { f g } }$ . In this process, SPACE reconstructs the objects associated to each cell having $\mathbf { z } _ { i } ^ { \mathrm { p r e s } } = 1$ . For each such cell, the model uses the $\mathbf { z } _ { i } ^ { \mathrm { w h a t } }$ to decode the object glimpse and its mask and the glimpse is then positioned on a full-resolution canvas using $\mathbf { z } _ { i } ^ { \mathrm { w h e r e } }$ via the Spatial Transformer (Jaderberg et al., 2015). Using the object masks and $\mathbf { z } _ { i } ^ { \mathrm { { d e p t h } } }$ , all the foreground objects are combined into a single foreground mean-image $\mu ^ { \mathrm { f g } }$ and the foreground mask $\alpha$ (See Appendix $\mathrm { D }$ for more details).
+
+SPACE imposes a prior distribution on these latents as follows:
+
+$$
+p ( \mathbf { z } ^ { \mathrm { { f g } } } ) = \prod _ { i = 1 } ^ { H \times W } p ( \mathbf { z } _ { i } ^ { \mathrm { { p r e s } } } ) \left( p ( \mathbf { z } _ { i } ^ { \mathrm { { w h e r e } } } ) p ( \mathbf { z } _ { i } ^ { \mathrm { { d e p t h } } } ) p ( \mathbf { z } _ { i } ^ { \mathrm { { w h a t } } } ) \right) ^ { \mathbf { z } _ { i } ^ { \mathrm { { p r e s } } } }
+$$
+
+Here, only ${ \bf z } _ { i } ^ { \mathrm { p r e s } }$ is modeled using a Bernoulli distribution while the remaining are modeled as Gaussian.
+
+Background. To model the background, SPACE implements $\mathbf { z } _ { k } ^ { \mathrm { { b g } } }$ , similar to GENESIS, as $( \mathbf { z } _ { k } ^ { m } , \mathbf { z } _ { k } ^ { c } )$ whetion $\mathbf { z } _ { k } ^ { m }$ odels th of the ixing probabilities background compo $\pi _ { k }$ of the component as a Gaussian $\mathbf { z } _ { k } ^ { c }$ odels the RGB distribu-. The following prior is $p ( \mathbf { x } | \mathbf { z } _ { k } ^ { \mathrm { b g } } )$ $k ^ { \mathrm { { t h } } }$ $\mathcal { N } ( \mu _ { i } ^ { \mathrm { b g } } , \sigma _ { \mathrm { b g } } ^ { 2 } )$
+
+imposed upon these latents.
+
+$$
+p ( \mathbf { z } ^ { \mathsf { b g } } ) = \prod _ { k = 1 } ^ { K } p ( \mathbf { z } _ { k } ^ { c } | \mathbf { z } _ { k } ^ { m } ) p ( \mathbf { z } _ { k } ^ { m } | \mathbf { z } _ { < k } ^ { m } )
+$$
+
+# 2.2 INFERENCE AND TRAINING
+
+Since we cannot analytically evaluate the integrals in equation 2 due to the continuous latents $\mathbf { z } ^ { \mathrm { f g } }$ and $\mathbf { z } _ { 1 : K } ^ { \mathrm { b g } }$ , we train the model using a variational approximation. The true posterior on these variables is approximated as follows.
+
+$$
+p ( \mathbf { z } _ { 1 : K } ^ { \mathrm { b g } } , \mathbf { z } ^ { \mathrm { f g } } | \mathbf { x } ) \approx q ( \mathbf { z } ^ { \mathrm { f g } } | \mathbf { x } ) \prod _ { k = 1 } ^ { K } q ( \mathbf { z } _ { k } ^ { \mathrm { b g } } | \mathbf { z } _ { < k } ^ { \mathrm { b g } } , \mathbf { x } )
+$$
+
+This is used to derive the following ELBO to train the model using the reparameterization trick and SGD (Kingma & Welling, 2013).
+
+$$
+\begin{array} { l } { { \displaystyle { \mathcal { L } } ( { \bf x } ) = { \mathbb { E } } _ { q ( { \bf z } ^ { { \sf f } \oplus } , { \bf z } ^ { { \sf b } \oplus } | { \bf x } ) } \left[ \log p ( { \bf x } | { \bf z } ^ { { \sf f } \oplus } , { \bf z } ^ { { \sf b } \oplus } ) - \sum _ { k = 1 } ^ { K } D _ { { \mathrm { K L } } } ( q ( { \bf z } _ { k } ^ { { \sf b } \oplus } | { \bf z } _ { < k } ^ { { \sf b } \oplus } , { \bf x } ) \parallel p ( { \bf z } _ { k } ^ { { \sf b } \oplus } | { \bf z } _ { < k } ^ { { \sf b } \mathrm { g } } ) ) \right. } } \\ { { \displaystyle ~ \left. - \sum _ { i = 1 } ^ { H \times W } D _ { { \mathrm { K L } } } ( q ( { \bf z } _ { i } ^ { { \sf f } \mathrm { g } } | { \bf x } ) \parallel p ( { \bf z } _ { i } ^ { { \sf f } \mathrm { g } } ) ) \right] } } \end{array}
+$$
+
+See Appendix B for the detailed decomposition of the ELBO and the related details.
+
+Parallel Ilatents, so ${ \bf z } _ { i } ^ { \mathrm { f g } } = ( { \bf z } _ { i } ^ { \mathrm { p r e s } } , { \bf z } _ { i } ^ { \mathrm { w h e r e } } , { \bf z } _ { i } ^ { \mathrm { d e p t h } } , { \bf z } _ { i } ^ { \mathrm { w h a t } } )$ E uses mean-field approximation when inferring the cell for each cell does not depend on other cells.
+
+$$
+q ( \mathbf { z } ^ { \mathrm { { f g } } } | \mathbf { x } ) = \prod _ { i = 1 } ^ { H \times W } q ( \mathbf { z } _ { i } ^ { \mathrm { { p r e s } } } | \mathbf { x } ) \left( q ( \mathbf { z } _ { i } ^ { \mathrm { w h e r e } } | \mathbf { x } ) q ( \mathbf { z } _ { i } ^ { \mathrm { { d e p t h } } } | \mathbf { x } ) q ( \mathbf { z } _ { i } ^ { \mathrm { { w h a t } } } | \mathbf { z } _ { i } ^ { \mathrm { { w h e r e } } } , \mathbf { x } ) \right) ^ { \mathbf { z } _ { i } ^ { \mathrm { { p r e s } } } }
+$$
+
+As shown in Figure 1, this allows each cell to act as an independent object detector, spatially attending to its own local region in parallel. This is in contrast to inference in SPAIR, where each cell’s latents auto-regressively depend on some or all of the previously traversed cells in a row-major order i.e., practice $\begin{array} { r } { q ( \mathbf { z } ^ { \mathrm { { f g } } } | \mathbf { \bar { x } } ) = \prod _ { i = 1 } ^ { \bar { H } W } q ( \mathbf { z } _ { i } ^ { \mathrm { { f g } } } | \mathbf { z } _ { < i } ^ { \mathrm { { f g } } } , \mathbf { x } ) } \end{array}$ . However, this method becomes prohibitively expensive ines. While Crawford & Pineau (2019) claim that these lateral connections are crucial for performance since they model dependencies between objects and thus prevent duplicate detections, we challenge this assertion by observing that 1) due to the bottom-up encoding conditioning on the input image, each cell should have information about its nearby area without explicitly communicating with other cells, and 2) in (physical) spatial space, two objects cannot exist at the same position. Thus, the relation and interference between objects should not be severe and the mean-field approximation is a good choice in our model. In our experiments, we verify empirically that this is indeed the case and observe that SPACE shows comparable detection performance to SPAIR while having significant gains in training speeds and efficiently scaling to scenes with many objects.
+
+Preventing Box-Splitting. If the prior for the bounding box size is set to be too small, then the model could split a large object by multiple bounding boxes and when the size prior is too large, the model may not capture small objects in the scene, resulting in a trade-off between the prior values of the bounding box size. To alleviate this problem, we found it sometimes helpful to introduce an auxiliary loss which we call the boundary loss. In the boundary loss, we construct a boundary of thickness $b$ pixels along the borders of each glimpse. Then, we restrict an object to be inside this boundary and penalize the model if an object’s mask overlaps with the boundary area. Thus, the model is penalized if it tries to split a large object by multiple smaller bounding boxes. A detailed implementation of the boundary loss is mentioned in Appendix C.
+
+# 3 RELATED WORKS
+
+Our proposed model is inspired by several recent works in unsupervised object-oriented scene decomposition. The Attend-Infer-Repeat (AIR) (Eslami et al., 2016) framework uses a recurrent neural network to attend to different objects in a scene and each object is sequentially processed one at a time. An object-oriented latent representation is prescribed that consists of ‘what’, ‘where’, and ‘presence’ variables. The ‘what’ variable stores the appearance information of the object, the ‘where’ variable represents the location of the object in the image, and the ‘presence’ variable controls how many steps the recurrent network runs and acts as an interruption variable when the model decides that all objects have been processed.
+
+Since the number of steps AIR runs scales with the number of objects it attends to, it does not scale well to images with many objects. Spatially Invariant Attend, Infer, Repeat (SPAIR) (Crawford & Pineau, 2019) attempts to address this issue by replacing the recurrent network with a convolutional network. Similar to YOLO (Redmon et al., 2016), the locations of objects are specified relative to local grid cells rather than the entire image, which allow for spatially invariant computations. In the encoder network, a convolutional neural network is first used to map the image to a feature volume with dimensions equal to a pre-specified grid size. Then, each cell of the grid is processed sequentially to produce objects. This is done sequentially because the processing of each cell takes as input feature vectors and sampled objects of nearby cells that have already been processed. SPAIR therefore scales with the pre-defined grid size which also represents the maximum number of objects that can be detected. Our model uses an approach similar to SPAIR to detect foreground objects, but importantly we make the foreground object processing fully parallel to scale to large number of objects without performance degradation. Works based on Neural Expectation Maximization (Van Steenkiste et al., 2018; Greff et al., 2017) do achieve unsupervised object detection but do not explicitly model the presence, appearance, and location of objects. These methods also suffer from the problem of scaling to images with a large number of objects. In a related line of research, AIR has also recently been extended to track objects in a sequence of images (Kosiorek et al., 2018; Crawford & Pineau, 2020; Jiang et al., 2020).
+
+For unsupervised scene-mixture models, several recent models have shown promising results. MONet (Burgess et al., 2019) leverages a deterministic recurrent attention network that outputs pixel-wise masks for the scene components. A variational autoencoder (VAE) (Kingma & Welling, 2013) is then used to model each component. IODINE (Greff et al., 2019) approaches the problem from a spatial mixture model perspective and uses amortized iterative refinement of latent object representations within the variational framework. GENESIS (Engelcke et al., 2019) also uses a spatial mixture model which is encoded by component-wise latent variables. Relationships between these components are captured with an autoregressive prior, allowing complete images to be modeled by a collection of components.
+
+# 4 EVALUATION
+
+We evaluate our model on two datasets: 1) an Atari (Bellemare et al., 2013) dataset that consists of random images from a pretrained agent playing the games, and 2) a generated 3D-room dataset that consists of images of a walled enclosure with a random number of objects on the floor. In order to test the scalability of our model, we use both a small 3D-room dataset that has 4-8 objects and a large 3D-room dataset that has 18-24 objects. Each image is taken from a random camera angle and the colors of the objects, walls, floor, and sky are also chosen at random. Additional details of the datasets can be found in the Appendix E.
+
+Baselines. We compare our model against two scene-mixture models (IODINE and GENESIS) and one spatial-attention model (SPAIR). Since SPAIR does not have an explicit background component, we add an additional VAE for processing the background. Additionally, we test against two implementations of SPAIR: one where we train on the entire image using a $1 6 \times 1 6$ grid and another where we train on random $3 2 \times 3 2$ pixel patches using a $4 \times 4$ grid. We denote the former model as SPAIR and the latter as SPAIR-P. SPAIR-P is consistent with the SPAIR’s alternative training regime on Space Invaders demonstrated in Crawford & Pineau (2019) to address the slow training of SPAIR on the full grid size because of its sequential inference. Lastly, for performance reasons, unlike the original SPAIR implementation, we use parallel processing for rendering the objects from their respective latents onto the canvas1 for both SPAIR and SPAIR-P. Thus, because of these improvements, our SPAIR implementation can be seen as a stronger baseline than the original SPAIR. More details of the baselines are given in Appendix D.
+
+![](images/7d6abcc16b2cb98f8b5f7d1f566c410eb2d38f82598a3080b90c9fd570273467.jpg)  
+Figure 2: Qualitative comparison between SPACE , SPAIR, SPAIR-P, IODINE and GENESIS for the 3DRoom dataset.
+
+# 4.1 QUALITATIVE COMPARISON OF INFERRED REPRESENTATIONS
+
+In this section, we provide a qualitative analysis of the generated representations of the different models. For each model, we performed a hyperparameter search and present the results for the best settings of hyperparameters for each environment. Figure 2 shows sample scene decompositions of our baselines from the 3D-Room dataset and Figure 3 shows the results on Atari. Note that SPAIR does not use component masks and IODINE and GENESIS do not separate foreground from background, hence the corresponding cells are left empty. Additionally, we only show a few representative components for IODINE and GENESIS since we ran those experiments with larger $K$ than can be displayed. More qualitative results of SPACE can be found in Appendix A.
+
+IODINE & GENESIS. In the 3D-Room environment, IODINE is able to segment the objects and the background into separate components. However, it occasionally does not properly decompose objects (in the Large 3D-room results, the orange sphere on the right is not reconstructed) and may generate blurry objects. GENESIS is able to segment the background walls, floor, and sky into multiple components. It is able to capture blurry foreground objects in the Small 3D-Room, but is not able to cleanly capture foreground objects with the larger number of objects in the Large 3DRoom. In Atari, both IODINE and GENESIS fail to capture the foreground properly or try to encode all objects in a single component. We believe this is because the objects in Atari games are smaller, less regular and lack the obvious latent factors like color and shape as in the 3D dataset, and thus detection-based approaches are more appropriate in this case.
+
+SPAIR & SPAIR-P. SPAIR is able to detect tight bounding boxes in both 3D-Rooms and the two Atari games. SPAIR-P, however, often fails to detect the foreground objects in proper bounding boxes, frequently uses multiple bounding boxes for one object and redundantly detects parts of the background as foreground objects. This is a limitation of the patch training as the receptive field of each patch is limited to a $3 2 \times 3 2$ glimpse, prohibiting it from detecting larger objects and making it difficult to distinguish the background from foreground. These two properties are illustrated well in Space Invaders, where it is able to detect the small aliens, but it detects the long piece of background ground on the bottom of the image as foreground objects.
+
+![](images/a52e6c8b9623f124601870dc3627eaf6afc5bcbaab0b9459a30a45fa4b49c5ae.jpg)  
+Figure 3: Qualitative comparison between SPACE , SPAIR, IODINE and GENESIS for Space Invaders, Air Raid, and River Raid.
+
+![](images/242c99df663fd0c6071250fb5395f2fb449c9b4d092eb3c2cbc5fcb4a6eea84c.jpg)  
+Figure 4: Qualitative demonstration of SPACE trained jointly on a selection of 10 Atari games. We show 6 games with complex background here.
+
+SPACE. In both 3D-Room, SPACE is able to accurately detect almost all objects despite the large variations in object positions, colors, and shapes, while producing a clean segmentation of the background walls, ground, and sky. This is in contrast to the SPAIR model, while being able to provide similar foreground detection quality, encodes the whole background into a single component, which makes the representation less disentangled. Notably, in River Raid where the background is constantly changing, SPACE is able to perfectly segment the blue river while accurately detecting all foreground objects, while SPAIR often cannot properly separate foreground and background.
+
+Joint Training. Figure 4 shows the results of training SPACE jointly across 10 Atari games. We see that even in this setting, SPACE is able to correctly detect foreground objects and cleanly segment the background.
+
+Foreground vs Background. Typically, foreground is the dynamic local part of the scene that we are interested in, and background is the relatively static and global part. This definition, though intuitive, is ambiguous. Some objects, such as the red shields in Space Invaders and the key in Montezuma’s Revenge (Figure 6) are static but important to detect as foreground objects. We found that SPACE tends to detect these as foreground objects while SPAIR considers it background. Similar behavior is observed in Atlantis (Figure 4), where SPACE tends to detect some foreground objects from the middle base that is above the water. One reason for this behavior is because we limit the capacity of the background module by using a spatial broadcast decoder (Watters et al., 2019) which is much weaker when compared to other decoders like sub-pixel convolutional nets (Shi et al. (2016)). This would favor modeling static objects as foreground rather than background.
+
+# 4.2 QUANTITATIVE COMPARISON
+
+In this section we compare SPACE with the baselines in several quantitative metrics2. We first note that each of the baseline models has a different decomposition capacity $( \mathcal { C } )$ , which we define as the capability of the model to decompose the scene into its semantic constituents such as the foreground objects and the background segmented components. For SPACE, the decomposition capacity is equal to the number of grid cells $H \times W$ (which is the maximum number of foreground objects that can be detected) plus the number of background components $K$ . For SPAIR, the decomposition capacity is equal to the number of grid cells $H \times W$ plus 1 for background. For IODINE and GENESIS, it is equal to the number of components $K$ .
+
+For each experiment, we compare the metrics for each model with similar decomposition capacities. This way, each model can decompose the image into the same number of components. For a setting in SPACE with a grid size of $H \times W$ with $K _ { \mathrm { S P A C E } }$ components, the equivalent settings in IODINE and GENESIS would be with $\mathcal { C } = ( H \times W ) + K _ { \mathrm { S P A C E } }$ . The equivalent setting in SPAIR would be a grid size of $H \times W$ .
+
+Table 1: Comparison of SPACE the SPAIR baseline with respect to the quality of the bounding boxes in the 3D-Room setting. Results are averaged over 5 best random seeds and standard deviations are given.   
+
+<table><tr><td>Model</td><td>Dataset</td><td>Avg.Precision IoU Threshold = 0.5</td><td>Avg.Precision IoU Threshold ∈ [0.5 : 0.05 :0.95]</td><td>Object Count Error Rate</td></tr><tr><td>SPACE(16 ×16)</td><td>3D-Room Large</td><td>0.8927 ±0.0027</td><td>0.4445 ± 0.0075</td><td>0.0446± 0.0026</td></tr><tr><td>SPAIR (16 × 16)</td><td>3D-Room Large</td><td>0.9072 ± 0.0003</td><td>0.4364 ± 0.0179</td><td>0.0360± 0.0072</td></tr><tr><td>SPACE (8 ×8)</td><td>3D-Room Small</td><td>0.9027± 0.0009</td><td>0.5069 ± 0.0030</td><td>0.0397± 0.0026</td></tr><tr><td>SPAIR (8 ×8)</td><td>3D-Room Small</td><td>0.9081 ± 0.0004</td><td>0.5068 ± 0.0081</td><td>0.0209 ±0.0039</td></tr></table>
+
+Gradient Step Latency. The leftmost chart of Figure 5 shows the time taken to complete one gradient step (forward and backward propagation) for different decomposition capacities for each of the models. We see that SPAIR’s latency grows with the number of cells because of the sequential nature of its latent inference step. Similarly GENESIS and IODINE’s latency grows with the number of components $K$ because each component is processed sequentially in both the models. IODINE is the slowest overall with its computationally expensive iterative inference procedure. Furthermore, both IODINE and GENESIS require storing data for each of the $K$ components, so we were unable to run our experiments on 256 components or greater before running out of memory on our 22GB GPU. On the other hand, SPACE employs parallel processing for the foreground which makes it scalable to large grid sizes, allowing it to detect a large number of foreground objects without any significant performance degradation. Although this data was collected for gradient step latency, this comparison implies a similar relationship exists with inference time which is a main component in the gradient step.
+
+![](images/9e7ae228af95b99cdaf2e70b9af1ff014c518605a45a9971dc60cf9035aadb87.jpg)  
+Figure 5: Quantitative performance comparison between SPACE , SPAIR, IODINE and GENESIS in terms of batch-processing time during training, training convergence and converged pixel MSE. Convergence plots showing pixel-MSE were computed on a held-out set during training.
+
+Time for Convergence. The remaining three charts in Figure 5 show the amount of time each model takes to converge in different experimental settings. We use the pixel-wise mean squared error (MSE) as a measurement of how close a model is to convergence. In all settings, SPAIR and SPACE converge much faster than IODINE and GENESIS. In the $4 \times 4$ and $8 \times 8$ setting, SPAIR and SPACE converge equally fast. But as we scale up to $1 6 \times 1 6$ , SPAIR becomes much slower than SPACE .
+
+Average Precision and Error Rate. In order to assess the quality of our bounding box predictions, we measure the Average Precision and Object Count Error Rate of our predictions. Our results are shown in Table 1. We only report these metrics for 3D-Room since we have access to the ground truth bounding boxes for each of the objects in the scene. Both models have very similar average precision and error rate. Despite being parallel in its inference, SPACE has a comparable count error rate to that of SPAIR.
+
+From our experiments, we can assert that SPACE can produce similar quality bounding boxes as SPAIR while 1) having orders of magnitude faster inference and gradient step time, 2) scaling to a large number of objects without significant performance degradation, and 3) providing complex background segmentation.
+
+# 5 CONCLUSION
+
+We propose SPACE, a unified probabilistic model that combines the benefits of the object representation models based on spatial attention and the scene decomposition models based on component mixture. SPACE can explicitly provide factorized object representation per foreground object while also decomposing complex background segments. SPACE also achieves a significant speed-up and thus makes the model applicable to scenes with a much larger number of objects without performance degradation. Besides, the detected objects in SPACE are also more intuitive than other methods. We show the above properties of SPACE on Atari and 3D-Rooms. Interesting future directions are to replace the sequential processing of background by a parallel one and to improve the model for natural images. Our next plan is to apply SPACE for object-oriented model-based reinforcement learning.
+
+# ACKNOWLEDGMENTS
+
+SA thanks to Kakao Brain and Center for Super Intelligence (CSI) for their support. ZL thanks to the ZJU-3DV group for its support. The authors would also like to thank Chang Chen and Zhuo Zhi for their insightful discussions and help in generating the 3D-Room dataset.
+
+# REFERENCES
+
+Jonathan T. Barron. Continuously differentiable exponential linear units. ArXiv, abs/1704.07483, 2017.
+
+M. G. Bellemare, Y. Naddaf, J. Veness, and M. Bowling. The arcade learning environment: An evaluation platform for general agents. Journal of Artificial Intelligence Research, 47:253–279, jun 2013.
+
+Christopher P Burgess, Loic Matthey, Nicholas Watters, Rishabh Kabra, Irina Higgins, Matt Botvinick, and Alexander Lerchner. Monet: Unsupervised scene decomposition and representation. arXiv preprint arXiv:1901.11390, 2019.
+
+Djork-Arne Clevert, Thomas Unterthiner, and Sepp Hochreiter. Fast and accurate deep network ´ learning by exponential linear units (elus). In ICLR, 2016.
+
+Eric Crawford and Joelle Pineau. Spatially invariant unsupervised object detection with convolutional neural networks. In Proceedings of AAAI, 2019.
+
+Eric Crawford and Joelle Pineau. Exploiting spatial invariance for scalable unsupervised object tracking. In Proceedings of AAAI, 2020.
+
+Martin Engelcke, Adam R. Kosiorek, Oiwi Parker Jones, and Ingmar Posner. Genesis: Generative scene inference and sampling with object-centric latent representations, 2019.
+
+SM Ali Eslami, Nicolas Heess, Theophane Weber, Yuval Tassa, David Szepesvari, and Geoffrey E Hinton. Attend, infer, repeat: Fast scene understanding with generative models. In Advances in Neural Information Processing Systems, pp. 3225–3233, 2016.
+
+Klaus Greff, Sjoerd van Steenkiste, and Jurgen Schmidhuber. Neural expectation maximization. In ¨ Advances in Neural Information Processing Systems, pp. 6691–6701, 2017.
+
+Klaus Greff, Raphael Lopez Kaufmann, Rishab Kabra, Nick Watters, Chris Burgess, Daniel Zoran, ¨ Loic Matthey, Matthew Botvinick, and Alexander Lerchner. Multi-object representation learning with iterative variational inference. arXiv preprint arXiv:1903.00450, 2019.
+
+Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In Proceedings of the 32nd International Conference on Machine Learning, 2015.
+
+Max Jaderberg, Karen Simonyan, Andrew Zisserman, and Koray Kavukcuoglu. Spatial transformer networks. In Advances in neural information processing systems, pp. 2017–2025, 2015.
+
+Eric Jang, Shixiang Gu, and Ben Poole. Categorical reparameterization with gumbel-softmax. arXiv preprint arXiv:1611.01144, 2016.
+
+Jindong Jiang, Sepehr Janghorbani, Gerard De Melo, and Sungjin Ahn. Scalor: Scalable objectoriented sequential generative models. In International Conference on Learning Representations, 2020.
+
+Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization, 2014.
+
+Diederik P Kingma and Max Welling. Auto-encoding variational bayes. arXiv preprint arXiv:1312.6114, 2013.
+
+Kurt Koffka. Principles of Gestalt psychology. Routledge, 2013.
+
+Adam Kosiorek, Hyunjik Kim, Yee Whye Teh, and Ingmar Posner. Sequential attend, infer, repeat: Generative modelling of moving objects. In Advances in Neural Information Processing Systems, pp. 8606–8616, 2018.
+
+Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Alex Graves, Ioannis Antonoglou, Daan Wierstra, and Martin A. Riedmiller. Playing atari with deep reinforcement learning. ArXiv, abs/1312.5602, 2013.
+
+Joseph Redmon, Santosh Divvala, Ross Girshick, and Ali Farhadi. You only look once: Unified, real-time object detection. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 779–788, 2016.
+
+Adam Santoro, David Raposo, David G Barrett, Mateusz Malinowski, Razvan Pascanu, Peter Battaglia, and Timothy Lillicrap. A simple neural network module for relational reasoning. In Advances in neural information processing systems, pp. 4967–4976, 2017.
+
+Wenzhe Shi, Jose Caballero, Ferenc Huszar, Johannes Totz, Andrew P. Aitken, Rob Bishop, Daniel Rueckert, and Zehan Wang. Real-time single image and video super-resolution using an efficient sub-pixel convolutional neural network. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2016.
+
+Ron Sun. On variable binding in connectionist networks. Connection Science, 4(2):93–124, 1992.
+
+Tijmen Tieleman and Geoffrey Hinton. Lecture 6.5-rmsprop, neural networks for machine learning. Tech Report, 2012. URL https://www.cs.toronto.edu/˜tijmen/csc321/ slides/lecture_slides_lec6.pdf.
+
+Emanuel Todorov, Tom Erez, and Yuval Tassa. Mujoco: A physics engine for model-based control. In 2012 IEEE/RSJ International Conference on Intelligent Robots and Systems, pp. 5026–5033. IEEE, 2012.
+
+Sjoerd Van Steenkiste, Michael Chang, Klaus Greff, and Jurgen Schmidhuber. Relational neural ex- ¨ pectation maximization: Unsupervised discovery of objects and their interactions. arXiv preprint arXiv:1802.10353, 2018.
+
+Nicholas Watters, Lo¨ıc Matthey, Christopher P. Burgess, and Alexander Lerchner. Spatial broadcast decoder: A simple architecture for learning disentangled representations in vaes. ArXiv, abs/1901.07017, 2019.
+
+Yuxin Wu and Kaiming He. Group normalization. In The European Conference on Computer Vision (ECCV), September 2018.
+
+Yuxin Wu et al. Tensorpack. https://github.com/tensorpack/, 2016.
+
+# A ADDITIONAL RESULTS OF SPACE
+
+![](images/0bfbd1d19be0964e5eeeefc62d1eabfe52296f36f09ac8f78cc71821114d2b2a.jpg)  
+Figure 6: Case illustration of Montezuma’s Revenge comparing object-detection behaviour in SPACE and SPAIR.
+
+![](images/a8897e8580459b01ed0a7bb6266574688bade8ea25f0a06f4484536b8517da80.jpg)  
+Figure 7: Qualitative demonstration of SPACE trained on the jointly on a selection of 10 ATARI games.
+
+![](images/5fafae0fdcf340e48322dddddf2a1a621588906bde37c8a2b4f3f3d0aa06a93d.jpg)  
+Figure 8: Object detection and background segmentation using SPACE on 3D-Room data set with small number of objects. Each row corresponds to one input image.
+
+![](images/daece06829976bd6870f79432499c8ded14b1ecee8fbec0bbff5b30203eae24a.jpg)  
+Figure 9: Object detection and background segmentation using SPACE on 3D-Room data set with large number of objects.
+
+# B ELBO DERIVATIONS
+
+In this section, we derive the ELBO for the log-likelihood $\log p ( \mathbf { x } )$ .
+
+$$
+\begin{array} { l } { { \displaystyle \log p ( { \bf x } ) \geq \mathbb { E } _ { q ( { \bf z } ^ { \sharp } , { \bf z } ^ { \mathtt { b } } \mid { \bf x } ) } \left[ p ( { \bf x } \mid { \bf z } ^ { \sharp } , { \bf z } ^ { \mathtt { b } \sharp } ) \right] - D _ { \mathrm { K L } } ( q ( { \bf z } ^ { \sharp } \mid { \bf x } ) \parallel p ( { \bf z } ^ { \mathtt { b } \sharp } ) ) - D _ { \mathrm { K L } } ( q ( { \bf z } ^ { \mathtt { b } \sharp } \mid { \bf x } ) \parallel p ( { \bf z } ^ { \mathtt { b } \sharp } ) ) } \ } \ ~  \\ { { \displaystyle = \mathbb { E } _ { q ( { \bf z } ^ { \sharp } , { \bf z } ^ { \mathtt { b } } \mid { \bf x } ) } \left[ p ( { \bf x } \mid { \bf z } ^ { \mathtt { b } \sharp } , { \bf z } ^ { \mathtt { b } \sharp } ) - D _ { \mathrm { K L } } ( q ( { \bf z } ^ { \mathtt { b } \sharp } \mid { \bf x } ) \parallel p ( { \bf z } ^ { \mathtt { f } \sharp } ) ) - D _ { \mathrm { K L } } ( q ( { \bf z } ^ { \mathtt { b } \sharp } \mid { \bf x } ) \parallel p ( { \bf z } ^ { \mathtt { b } \sharp } ) ) \right] } \ ~ } \\ { { \displaystyle = \mathbb { E } _ { q ( { \bf z } ^ { \sharp } , { \bf z } ^ { \mathtt { b } } \mid { \bf x } ) } \Big [ p ( { \bf x } \mid { \bf z } ^ { \sharp } , { \bf z } ^ { \mathtt { b } \sharp } ) - \displaystyle \sum _ { k = 1 } ^ { K } D _ { \mathrm { K L } } ( q ( { \bf z } _ { k } ^ { \mathtt { b } \sharp } \mid { \bf x } , { \bf z } _ { < k } ^ { \mathtt { b } \sharp } ) \parallel p ( { \bf z } ^ { \mathtt { b } \sharp } \mid { \bf z } _ { < k } ^ { \mathtt { b } \sharp } ) ) - } \ ~ } \\ { { \displaystyle ~ \overset { H \times W } { \sum _ { i = 1 } ^ { H } } } \ D _ { \mathrm { K L } } ( q ( { \bf z } _ { i } ^ { \mathtt { f } \sharp } \mid { \bf x } ) \parallel p ( { \bf z } _ { i } ^ { \mathtt { f } \sharp } ) ) \Big ] } \end{array}
+$$
+
+KL Divergence for the Foreground Latents Under the SPACE ’s approximate inference, the $D _ { \mathrm { K L } } ( q ( \mathbf { z } _ { i } ^ { \mathrm { f g } } | \mathbf { x } ) \parallel p ( \mathbf { z } _ { i } ^ { \mathrm { f g } } ) )$ inside the expectation can be evaluated as follows.
+
+$$
+\begin{array} { r l } & { \mathbb { E } _ { q ( z ^ { k } , z ^ { k } | \mathbf { x } ) } [ D _ { \mathrm { K L } } ( q ( z _ { i } ^ { \mathrm { g l e m } } | \mathbf { x } ) \parallel p ( z _ { i } ^ { \mathrm { g l e m } } ) ) ] } \\ & { \quad = \mathbb { E } _ { q ( \mathbf { z } ^ { k } , \mathbf { z } ^ { k } | \mathbf { x } ) } [ D _ { \mathrm { K L } } ( q ( z _ { i } ^ { \mathrm { g l e m } } | \mathbf { x } ) \parallel p ( z _ { i } ^ { \mathrm { g l e m } } ) ) + \mathbb { E } _ { q ( \mathbf { z } ^ { k } | \mathbf { x } ) | \mathbf { z } } ] ^ { \mathrm { H r S } } [ D _ { \mathrm { K L } } ( q ( z _ { i } ^ { \mathrm { g l e m } } | \mathbf { x } ) \parallel p ( z _ { i } ^ { \mathrm { g l e m } } ) )  } \\ & { \quad \quad +  \mathbb { E } _ { q ( z _ { i } ^ { \mathrm { g l e m } } | \mathbf { x } ) } D _ { \mathrm { K L } } ( q ( z _ { i } ^ { \mathrm { g l e m } } | \mathbf { x } , z _ { i } ^ { \mathrm { g l e m } } ) \parallel p ( z _ { i } ^ { \mathrm { g l e m } } ) ) + D _ { \mathrm { K L } } ( q ( z _ { i } ^ { \mathrm { g l e m } } | \mathbf { x } ) \parallel p ( z _ { i } ^ { \mathrm { g l e m } } ) ) ] ] } \\ & { \quad = \mathbb { E } _ { q ( \mathbf { z } ^ { k } , \mathbf { z } ^ { k } | \mathbf { x } ) } [ D _ { \mathrm { K L } } ( q ( z _ { i } ^ { \mathrm { g l e m } } | \mathbf { x } ) \parallel p ( z _ { i } ^ { \mathrm { g l e m } } ) ) + \mathbf { z } _ { i } ^ { \mathrm { H e m } } [ D _ { \mathrm { K L } } ( q ( z _ { i } ^ { \mathrm { g l e m } } | \mathbf { x } ) \parallel p ( z _ { i } ^ { \mathrm { g l e m } } ) )  } \\ &  \quad \quad  + D _ { \mathrm { K L } } ( q ( z _ { i } ^ { \mathrm { g l e m } } | \mathbf { x } , z _ { i } ^ { \mathrm { g l e m } } ) \parallel p ( z _ { i } ^ { \mathrm { g l e m } } ) ) + D _ { \mathrm { K L } } ( q ( z _ { i } ^ { \mathrm { g l e m } } | \mathbf { x } ) \parallel p ( z _ { i } ^  \mathrm { g l e m }  \end{array}
+$$
+
+KL Divergence for the Background Latents Under our GENESIS-like modeling of inference for the background latents, the KL term inside the expectation for the background is evaluated as follows.
+
+$$
+\begin{array} { r l } & { \overset { \ ? } { \underset { q } { \geq } } _ { q \leq \varepsilon , \mathbf { z } ^ { \mathrm { s g } } | \mathbf { x } } \left[ D _ { \mathrm { K L } } ( q ( \mathbf { z } _ { k } ^ { \mathsf { b g } } | \mathbf { z } _ { < k } ^ { \mathsf { b g } } , \mathbf { x } ) \parallel p ( \mathbf { z } _ { k } ^ { \mathsf { b g } } | \mathbf { z } _ { < k } ^ { \mathsf { b g } } ) ) \right] } \\ & { \quad = \mathbb { E } _ { q ( \mathbf { z } ^ { \mathrm { s g } } , \mathbf { z } ^ { \mathrm { b g } } | \mathbf { x } ) } \left[ D _ { \mathrm { K L } } ( q ( \mathbf { z } _ { k } ^ { m } | \mathbf { z } _ { < k } ^ { m } , \mathbf { x } ) \parallel p ( \mathbf { z } _ { k } ^ { m } | \mathbf { z } _ { < k } ^ { m } ) ) + \mathbb { E } _ { q ( \mathbf { z } _ { k } ^ { m } | \mathbf { z } _ { < k } ^ { m } , \mathbf { x } ) } D _ { \mathrm { K L } } ( q ( \mathbf { z } _ { k } ^ { c } | \mathbf { z } _ { k } ^ { m } , \mathbf { x } ) \parallel p ( \mathbf { z } _ { k } ^ { c } | \mathbf { z } _ { k } ^ { m } ) ) \right] } \\ & { \quad = \mathbb { E } _ { q ( \mathbf { z } ^ { \mathrm { s g } } , \mathbf { z } ^ { \mathrm { b g } } | \mathbf { x } ) } \left[ D _ { \mathrm { K L } } ( q ( \mathbf { z } _ { k } ^ { m } | \mathbf { z } _ { < k } ^ { m } , \mathbf { x } ) \parallel p ( \mathbf { z } _ { k } ^ { m } | \mathbf { z } _ { < k } ^ { m } ) ) + D _ { \mathrm { K L } } ( q ( \mathbf { z } _ { k } ^ { c } | \mathbf { z } _ { k } ^ { m } , \mathbf { x } ) \parallel p ( \mathbf { z } _ { k } ^ { c } | \mathbf { z } _ { k } ^ { m } ) ) \right] } \end{array}
+$$
+
+Relaxed treatment of $\mathbf { z } ^ { \mathbf { p r e s } }$ In our implementation, we model the Bernoulli random variable ${ \bf z } _ { i } ^ { \mathrm { p r e s } }$ using the Gumbel-Softmax distribution (Jang et al., 2016). We use the relaxed value of $\mathbf { z } ^ { \mathrm { p r e s } }$ in the entire training and use hard samples only for the visualizations.
+
+# C BOUNDARY LOSS
+
+In this section we elaborate on the implementation details of the boundary loss. We construct a kernel of the size of the glimpse, $g s \times g s$ (we use $g s = 3 2$ ) with a boundary gap of $b = 6$ having negative uniform weights inside the boundary and a zero weight in the region between the boundary and the glimpse. This ensures that the model is penalized when the object is outside the boundary. This kernel is first mapped onto the global space via STN Jaderberg et al. (2015) to obtain the global kernel. This is then multiplied element-wise with global object mask $\alpha$ to obtain the boundary loss map. The objective of the loss is to minimize the mean of this boundary loss map. In addition to the ELBO, this loss is also back-propagated via RMSProp (Tieleman & Hinton. (2012)). This loss, due to the boundary constraint, enforces the bounding boxes to be less tight and results in lower average precision, so we disable the loss and optimize only the ELBO after the model has converged well.
+
+# D IMPLEMENTATION DETAILS
+
+# D.1 ALGORITHMS
+
+Algorithm 1 and Algorithm 3 present SPACE’s inference for foreground and background. Algorithm 2 describe the details of rescale $_ i i$ function in Algorithm 1 that transforms local shift $\mathbf { z } _ { i } ^ { \mathrm { s h i f f } }$ to global shift $\hat { \mathbf { z } } _ { i } ^ { \mathrm { s h i f t } }$ .Algorithm 4 show the details of the generation process of the background module. For foreground generation, we simply sample the latent variables from the priors instead of conditioning on the input. Note that, for convenience the algorithms for the foreground module and background module are presented with for loops, but inference for all variables of the foreground module are implemented as parallel convolution operations and most operations of the background module (barring the LSTM module) are parallel as well.
+
+# Algorithm 1: Foreground Inference
+
+Input: image $_ { \textbf { \em x } }$   
+Output: foreground mask $\alpha$ , appearance $\mu ^ { \mathrm { f g } }$ , grid height $H$ and width $W$   
+$\hat { e } ^ { \mathrm { i m g } } =$ ImageEncoderFg(x)   
+$r ^ { \mathrm { i m g } } =$ ResidualConnection $\left( \hat { e } ^ { \mathrm { i m g } } \right)$   
+$e ^ { \mathrm { i m g } } =$ ResidualEncoder $\left[ \hat { e } ^ { \mathrm { i m g } } , r ^ { \mathrm { i m g } } \right] )$   
+for $i \gets 1$ to $H W$ do $/ \star$ The following is performed in parallel \*/ $\pmb { \rho } _ { i } = Z \mathrm { P r e s N e t } ( e _ { i } ^ { \mathrm { i m g } } )$ $[ \mu _ { i } ^ { \mathrm { d e p t h } } , \sigma _ { i } ^ { \mathrm { d e p t h } } ] = \mathrm { Z D e p t h N e t } ( e _ { i } ^ { \mathrm { i m g } } )$ [µsi $[ \pmb { \mu } _ { i } ^ { \mathrm { s c a l e } } , \pmb { \sigma } _ { i } ^ { \mathrm { s c a l e } } ] = \mathrm { Z S c a l e N e t } ( e _ { i } ^ { \mathrm { i m g } } )$ cale, σscalei ] = $[ \pmb { \mu } _ { i } ^ { \mathrm { s h i f t } } , \pmb { \sigma } _ { i } ^ { \mathrm { s h i f t } } ] = \mathrm { Z S h i f t N e t } ( e _ { i } ^ { \mathrm { i m g } } )$ zpresi ∼ $\mathbf { z } _ { i } ^ { \mathrm { p r e s } } \sim \mathrm { B e r n } ( \rho _ { i } )$ $\mathbf { z } _ { i } ^ { \mathrm { { d e p t h } } } \sim \mathcal { N } ( \mu _ { i } ^ { \mathrm { { d e p t h } } } , \sigma _ { i } ^ { \mathrm { { d e p t h , 2 } } } )$ $\mathbf { z } _ { i } ^ { \mathrm { { s c a l e } } } \sim \mathcal { N } ( \mu _ { i } ^ { \mathrm { { s c a l e } } } , \sigma _ { i } ^ { \mathrm { { s c a l e } , 2 } } )$ $\mathbf { z } _ { i } ^ { \mathrm { { s h i f t } } } \sim \mathcal { N } ( \mu _ { i } ^ { \mathrm { { s h i f t } } } , \pmb { \sigma } _ { i } ^ { \mathrm { { s h i f t } , 2 } } )$ hift , σ shift , 2i ) $/ \star$ Rescale local shift to global shift as in SPAIR \*/ $\hat { \mathbf { z } } _ { i } ^ { \mathrm { s c a l e } } = \sigma ( \mathbf { z } _ { i } ^ { \mathrm { s c a l e } } )$ $\hat { \mathbf { z } } _ { i } ^ { \mathrm { s h i f t } } = \operatorname { r e s c a l e } _ { i } ( \mathbf { z } _ { i } ^ { \mathrm { s h i f t } } )$ $\mathbf { z } _ { i } ^ { \mathrm { w h e r e } } = [ \hat { \mathbf { z } } _ { i } ^ { \mathrm { s c a l e } } , \hat { \mathbf { z } } _ { i } ^ { \mathrm { s h i f t } } ]$ $/ \star$ Extract glimpses with a Spatial Transformer \*/ $\hat { \pmb { x } } _ { i } = \mathrm { S T } ( \pmb { x } , \mathbf { z } _ { i } ^ { \mathrm { w h e r e } } )$ [µwhati , σwhati ] =GlimpseEncoder $( \hat { \pmb x } _ { i } )$ zwhati ∼ N (µwhati , σwi Foreground mask and appearance of glimpse size \*/ [αatti , oatti ] = GlimpseDecoder $( \mathbf { z } _ { i } ^ { \mathrm { w h a t } } )$ $\hat { \pmb { \alpha } } _ { i } ^ { \mathrm { a t t } } = { \pmb { \alpha } } _ { i } ^ { \mathrm { a t t } } \odot { \bf z } _ { i } ^ { \mathrm { p r e s } }$ zpresi yati i t = αˆ atti o atti $/ \star$ Transform both to canvas size \*/ $\hat { \pmb { \alpha } } _ { i } ^ { \mathrm { a t t } } = \mathrm { S T } ^ { - 1 } ( \hat { \pmb { \alpha } } _ { i } ^ { \mathrm { a t t } } , \mathbf { z } _ { i } ^ { \mathrm { w h e r e } } )$ ${ \pmb y } _ { i } ^ { \mathrm { a t t } } = { \bf S } { \bf T } ^ { - 1 } ( { \pmb y } _ { i } ^ { \mathrm { a t t } } , { \pmb z } _ { i } ^ { \mathrm { w h e r e } } )$   
+end   
+$/ \star$ Compute weights for each component \*/   
+${ \pmb w } = \mathrm { s o f t m a x } ( - 1 0 0 \cdot \sigma ( { \bf z } ^ { \mathrm { d e p t h } } ) \odot \hat { \alpha } ^ { \mathrm { a t t } } )$   
+$/ \star$ Compute global weighted mask and foreground appearance \*/   
+$\begin{array} { l } { { \alpha = \operatorname { s u m } ( { \pmb w } \odot \hat { \alpha } ^ { \mathrm { a t t } } ) } } \\ { { \mu ^ { \mathrm { f g } } = \operatorname { s u m } ( { \pmb w } \odot { \pmb y } ^ { \mathrm { a t t } } ) } } \end{array}$
+
+# Algorithm 2: Rescale zshifti
+
+Input: Shift latent $\mathbf { z } _ { i } ^ { \mathrm { s h i f t } }$ , cell index $i$ , grid height $H$ and width W   
+Output: Rescaled shift latent $\hat { \mathbf { z } } _ { i } ^ { \mathrm { s h i f t } }$   
+$/ \star$ Get width and heigh index of cell i \*/   
+$[ k , j ] = [ i \% H , i \div H ]$   
+$/ \star$ Center of this cell \*/   
+$\mathbf { c } _ { i } = [ k + 0 . 5 , j + 0 . 5 ]$   
+$/ \star$ Get global shift \*/   
+$\widetilde { \mathbf { z } } _ { i } ^ { \mathrm { s h i f t } } = \mathbf { c } _ { i } + \operatorname { t a n h } ( \mathbf { z } _ { i } ^ { \mathrm { s h i f t } } )$   
+$/ \star$ Normalize to range (-1, 1) \*/   
+$\hat { \mathbf { z } } _ { i } ^ { \mathrm { s h i f t } } = 2 \cdot \tilde { \mathbf { z } } _ { i } ^ { \mathrm { s h i f t } } / [ W , H ] - 1$   
+Input: image $_ { \textbf { \em x } }$ , initial LSTM states $h _ { 0 } , c _ { 0 }$ , initial dummy mask $\mathbf { z } _ { 0 } ^ { m }$   
+Output: background masks $\pi _ { k }$ , appearance $\mu _ { k } ^ { \mathrm { { b g } } }$ , for $k = 1 , \ldots , K$ 0   
+$e ^ { \mathrm { i m g } } =$ ImageEncoderBg(x)   
+for $k \gets 1$ to $K$ do $h _ { k } , c _ { k } = \mathrm { L S T M } ( [ \mathbf { z } _ { k - 1 } ^ { m } , e ^ { \mathrm { i m g } } ] , c _ { k - 1 } , h _ { k - 1 } )$ $\left[ \pmb { \mu } _ { k } ^ { m } , \pmb { \sigma } _ { k } ^ { m } \right] = \mathrm { P r e d i c t M a s k } ( \pmb { h } _ { k } )$ $\mathbf { z } ^ { m } \sim \mathcal { N } ( \pmb { \mu } _ { k } ^ { m } , \pmb { \sigma } _ { k } ^ { m , 2 } )$ coded in parallel $/ \star$ \*/ $\hat { \pi } _ { k } = \mathrm { M a s k D e c o d e r } ( \mathbf { z } _ { k } ^ { m } )$ $/ \star$ Stick breaking process as described in GENESIS \*/ $\pi _ { k } = \mathrm { S B P } ( \hat { \pi } _ { 1 : k } )$ $[ { \pmb \mu } _ { k } ^ { c } , { \pmb \sigma } _ { k } ^ { c } ] = { \bf C } \mathrm { o m p E n c o d e r } ( [ { \boldsymbol \pi } _ { k } , { \pmb x } ] )$ z c ∼ N ( µ ck , σ c, 2k )   
+end µbgk =CompDecoder(zck)   
+Input: initial LSTM states $h _ { 0 } , c _ { 0 }$ , initial dummy mask $\mathbf { z } _ { 0 } ^ { m }$   
+Output: background masks $\pi _ { k }$ , appearance $\mu _ { k } ^ { \mathrm { { b g } } }$ , for $k = 1 , \ldots , K$   
+for $k \gets 1$ to $K$ do $\begin{array} { r l } & { { \boldsymbol { h } } _ { k } , { \boldsymbol { c } } _ { k } = \mathrm { L S T M } ( \mathbf z _ { k - 1 } ^ { m } , { \boldsymbol { c } } _ { k - 1 } , { \boldsymbol { h } } _ { k - 1 } ) } \\ & { [ { \boldsymbol { \mu } } _ { k } ^ { m } , \pmb { \sigma } _ { k } ^ { m } ] = \mathrm { P r e d i c t M a s k P r i o r } ( { \boldsymbol { h } } _ { k } ) } \\ & { \mathbf z ^ { m } \sim \mathcal N ( { \boldsymbol { \mu } } _ { k } ^ { m } , \pmb { \sigma } _ { k } ^ { m , 2 } ) } \end{array}$ $/ \star$ Actually decoded in parallel \*/ $\hat { \pi } _ { k } = \mathrm { M a s k D e c o d e r } ( \mathbf { z } _ { k } ^ { m } )$ /\* Stick breaking process as described in GENESIS \*/ $\pi _ { k } = \mathrm { S B P } ( \hat { \pi } _ { 1 : k } )$ [µck, σck] = PredictComp(zmk ) z ck ∼ N ( µ ck , σ c, 2k ) µbk =CompDecoder(zck)   
+end
+
+Algorithm 4: Background Generation   
+
+<table><tr><td>Algorithm3:Background Inference</td></tr></table>
+
+# D.2 TRAINING REGIME AND HYPERPARAMETERS
+
+For all experiments we use an image size of $1 2 8 \times 1 2 8$ and a batch size of 12 to 16 depending on memory usage. For the foreground module, we use the RMSProp (Tieleman & Hinton. (2012)) optimizer with a learning rate of $1 \times 1 0 ^ { - 5 }$ except for Figure 5, for which we use a learning rate of $1 \times 1 0 ^ { - 4 }$ as SPAIR. For the background module, we use the Adam (Kingma & Ba (2014)) optimizer with a learning rate of $1 \times 1 0 ^ { - \bar { 3 } }$ . We use gradient clipping with a maximum norm of 1.0. For quantitative results, SPACE is trained up to 160000 steps. For Atari games, we find it beneficial to set $\alpha$ to be fixed for the first several thousand steps, and vary the actual value and number of steps for different games. This allows both the foreground as well as the background module to learn in the early stage of training.
+
+We list out our hyperparameters for 3D large dataset and joint training for 10 static Atari games below. Hyperparameters for other experiments are similar, but are finetuned for each dataset individually. In the tables below, $( m \to n ) : ( p \to q )$ denotes annealing the hyperparameter value from $m$ to $n$ , starting from step $p$ until step $q$ .
+
+3D Room Large   
+
+<table><tr><td>Name</td><td>Symbol</td><td>Value</td></tr><tr><td>zpres prior prob</td><td>p</td><td>(0.1→ 0.01) : (4000 →→ 10000)</td></tr><tr><td>zscale prior mean</td><td>μscale</td><td>(-1.0 → -2.0) : (10000 -→ 20000)</td></tr><tr><td>zscale prior stdev</td><td>gscale</td><td>0.1</td></tr><tr><td>zshift prior</td><td>μshift, ,gshift</td><td>N(0,1)</td></tr><tr><td>zdepth prior</td><td>μdepth ,gdepth</td><td>N(0,1)</td></tr><tr><td>zwhat prior</td><td>μwhat, gWhat</td><td>N(0,1)</td></tr><tr><td>foreground stdev</td><td>gfg</td><td>0.15</td></tr><tr><td>background stdev</td><td>gg</td><td>0.15</td></tr><tr><td>component number</td><td>K</td><td>5</td></tr><tr><td>gumbel-softmax temperature</td><td>T</td><td>(2.5 → 0.5) : (0 -→ 20000)</td></tr><tr><td>#steps to fix α</td><td></td><td>N/A</td></tr><tr><td>fixed α value</td><td></td><td>N/A</td></tr><tr><td>boundary loss</td><td></td><td>Yes</td></tr><tr><td>turn off boundary loss at step</td><td></td><td>100000</td></tr></table>
+
+Joint Training on 10 Atari Games   
+
+<table><tr><td>Name</td><td>Symbol</td><td>Value</td></tr><tr><td>zpres prior prob</td><td>p</td><td>1×10-10</td></tr><tr><td>zscale prior mean</td><td>μscale</td><td>-2.5</td></tr><tr><td>zscale prior stdev</td><td>gscale</td><td>0.1</td></tr><tr><td>zshift prior</td><td>μshift ,gshift 7</td><td>N(0,1)</td></tr><tr><td>zdepth prior</td><td>μdepth ,gdepth</td><td>N(0,1)</td></tr><tr><td>zwhat prior</td><td>μwhat ,g what</td><td>N(0,1)</td></tr><tr><td>foreground stdev</td><td>gfg</td><td>0.20</td></tr><tr><td>background stdev</td><td>gbg</td><td>0.10</td></tr><tr><td>component number</td><td>K</td><td>3</td></tr><tr><td> gumbel-softmax temperature</td><td>T</td><td>(2.5→1.0) : (0 →10000)</td></tr><tr><td>#steps to fix α</td><td></td><td>4000</td></tr><tr><td>fixed α value</td><td></td><td>0.1</td></tr><tr><td>boundary loss</td><td></td><td>No</td></tr><tr><td>turn off boundary loss at step</td><td></td><td>N/A</td></tr></table>
+
+# D.3 MODEL ARCHITECTURE
+
+Here we describe the architecture of our $1 6 \times 1 6$ SPACE model. The model for $8 \times 8$ grid cells is the same but with a stride-2 convolution for the last layer of the image encoder.
+
+All modules that output distribution parameters are implemented with either one single fully connected layer or convolution layer, with the appropriate output size. Image encoders are fully convolutional networks that output a feature map of shape $H \times W$ , and the glimpse encoder comprises of convolutional layers followed by a final linear layer that computes the parameters of a Gaussian distribution. For the glimpse decoder of the foreground module and the mask decoder of the background module we use the sub-pixel convolution layer (Shi et al. (2016)). On the lines of GENESIS (Engelcke et al. (2019)) and IODINE (Greff et al. (2019)), we adopt Spatial Broadcast Network (Watters et al. (2019)) as the component decoder to decode $\mathbf { z } _ { k } ^ { c }$ into background components.
+
+For inference and generation of the background module, the dependence of $\mathbf { z } _ { k } ^ { m }$ on $\mathbf { z } _ { 1 : k - 1 } ^ { m }$ is implemented with LSTMs, with hidden sizes of 64. Dependence of $\mathbf { z } _ { k } ^ { c }$ on $\mathbf { z } _ { k } ^ { m }$ is implemented with a MLP with two hidden layers with 64 units per layer. We apply softplus when computing standard deviations for all Gaussian distributions, and apply sigmoid when computing reconstruction and masks. We use either Group Normalization (GN) (Wu & He (2018)) and CELU (Barron (2017)) or Batch Normalization (BN) (Ioffe & Szegedy (2015)) and ELU (Clevert et al. (2016)) depending on the module type.
+
+The rest of the architecture details are described below. In the following tables, ConvSub(n) denotes a sub-pixel convolution layer implemented as a stride-1 convolution and a PyTorch PixelShuffle $( n )$ layer, and $\operatorname { G N } ( n )$ denotes Group Normalization with $n$ groups.
+
+<table><tr><td>Name zdepth dim</td><td>Value 1</td><td>Comment</td></tr><tr><td>zscale dim zshift dim zwhat dim zm dim z dim glimpse shape</td><td>2 2 32 32 32 (32,32)</td><td>for x and y axis for x and y axis</td></tr><tr><td colspan="3">Foreground Image Encoder</td></tr><tr><td colspan="3">Layer Size/Ch. 3</td></tr><tr><td>Input Conv 4 × 4</td><td>16</td><td>GN(4)/CELU</td></tr><tr><td>Conv 4× 4 32</td><td>２２2</td><td>GN(8)/CELU</td></tr><tr><td>Conv 4 × 4 64</td><td>1</td><td>GN(8)/CELU</td></tr><tr><td>Conv 3 × 3</td><td>128</td><td>GN(16)/CELU</td></tr><tr><td>Conv 3 × 3</td><td>256</td><td>GN(32)/CELU</td></tr><tr><td>Conv 1 ×1</td><td>128</td><td>GN(16)/CELU</td></tr><tr><td></td><td></td><td></td></tr><tr><td colspan="3">Residual Connection</td></tr><tr><td>Layer</td><td>Size/Ch.</td><td>Stride Norm./Act.</td></tr><tr><td>Input</td><td>128 1</td><td></td></tr><tr><td>Conv 3 ×3 Conv 3 × 3</td><td>128 128</td><td>GN(16)/CELU GN(16)/CELU</td></tr><tr><td></td><td>1</td><td></td></tr><tr><td colspan="3">Residual Encoder</td></tr><tr><td>Layer</td><td>Size/Ch.</td><td>Stride Norm./Act.</td></tr><tr><td>Input</td><td>128 + 128</td><td></td></tr><tr><td colspan="3">128</td></tr><tr><td>Conv 3 × 3</td><td>1</td><td>GN(16)/CELU</td></tr></table>
+
+<table><tr><td colspan="4">Glimpse Encoder</td></tr><tr><td>Layer</td><td>Size/Ch.</td><td>Stride</td><td>Norm./Act.</td></tr><tr><td>Input</td><td>3</td><td></td><td></td></tr><tr><td>Conv 3 × 3</td><td>16</td><td>1</td><td>GN(4)/CELU</td></tr><tr><td>Conv 4 × 4</td><td>32</td><td>2</td><td>GN(8)/CELU</td></tr><tr><td>Conv 3 × 3</td><td>32</td><td>1</td><td>GN(4)/CELU</td></tr><tr><td>Conv 4 × 4</td><td>64</td><td>2</td><td>GN(8)/CELU</td></tr><tr><td>Conv 4 × 4</td><td>128</td><td>2</td><td>GN(8)/CELU</td></tr><tr><td>Conv 4× 4</td><td>256 32 +32</td><td>1</td><td>GN(16)/CELU</td></tr><tr><td>Linear</td><td></td><td></td><td></td></tr><tr><td colspan="4">Glimpse Decoder</td></tr><tr><td>Layer</td><td>Size/Ch.</td><td>Stride</td><td>Norm./Act.</td></tr><tr><td>Input</td><td>32</td><td></td><td></td></tr><tr><td>Conv 1 × 1</td><td>256</td><td>1</td><td>GN(16)/CELU</td></tr><tr><td>ConvSub(2)</td><td>128</td><td>1</td><td>GN(16)/CELU</td></tr><tr><td>Conv 3 × 3</td><td>128</td><td>1</td><td>GN(16)/CELU</td></tr><tr><td>ConvSub(2)</td><td>128</td><td>1</td><td>GN(16)/CELU</td></tr><tr><td>Conv 3×3</td><td>128</td><td>1</td><td>GN(16)/CELU</td></tr><tr><td>ConvSub(2)</td><td>64</td><td>1</td><td>GN(8)/CELU</td></tr><tr><td>Conv 3 × 3</td><td>64</td><td>1</td><td>GN(8)/CELU</td></tr><tr><td>ConvSub(2)</td><td>32</td><td>1</td><td>GN(8)/CELU</td></tr><tr><td>Conv 3 × 3</td><td>32</td><td>1</td><td>GN(8)/CELU</td></tr><tr><td>ConvSub(2)</td><td>16</td><td>1</td><td>GN(4)/CELU</td></tr><tr><td>Conv 3 × 3</td><td>16</td><td>1</td><td>GN(4)/CELU</td></tr><tr><td colspan="4">Background Image Encoder</td></tr><tr><td>Layer</td><td>Size/Ch.</td><td>Stride</td><td>Norm./Act.</td></tr><tr><td>Input</td><td>3</td><td></td><td></td></tr><tr><td>Conv 3 × 3</td><td>64</td><td>2</td><td>BN/ELU</td></tr><tr><td>Conv 3 × 3</td><td>64</td><td>2</td><td>BN/ELU</td></tr><tr><td>Conv 3 × 3</td><td>64</td><td>2</td><td>BN/ELU</td></tr><tr><td>Conv 3 × 3</td><td>64</td><td>2</td><td>BN/ELU</td></tr><tr><td>Flatten</td><td></td><td></td><td></td></tr><tr><td>Linear</td><td>64</td><td></td><td>ELU</td></tr><tr><td colspan="4">Mask Decoder</td></tr><tr><td>Layer</td><td>Size/Ch.</td><td>Stride</td><td>Norm./Act.</td></tr><tr><td></td><td>32</td><td></td><td></td></tr><tr><td>Input Conv 1 ×1</td><td>256</td><td>1</td><td>GN(16)/CELU</td></tr><tr><td>ConvSub(4)</td><td>256</td><td>1</td><td>GN(16)/CELU</td></tr><tr><td>Conv 3×3</td><td>256</td><td>1</td><td>GN(16)/CELU</td></tr><tr><td>ConvSub(2)</td><td>128</td><td>1</td><td>GN(16)/CELU</td></tr><tr><td>Conv 3 × 3</td><td>128</td><td>1</td><td>GN(16)/CELU</td></tr><tr><td>ConvSub(4)</td><td>64</td><td>1</td><td>GN(8)/CELU</td></tr><tr><td>Conv 3 × 3</td><td>64</td><td>1</td><td>GN(8)/CELU</td></tr><tr><td>ConvSub(4)</td><td>16</td><td>1</td><td>GN(4)/CELU</td></tr><tr><td>Conv 3 × 3</td><td>16</td><td>1</td><td>GN(4)/CELU</td></tr><tr><td>Conv 3 × 3</td><td>16</td><td>1</td><td>GN(4)/CELU</td></tr><tr><td>Conv 3 × 3</td><td>1</td><td>1</td><td></td></tr></table>
+
+Component Encoder   
+
+<table><tr><td colspan="2">Layer Size/Ch.</td><td>Stride</td><td>Norm./Act.</td></tr><tr><td>Input</td><td>3+1 (RGB+mask)</td><td></td><td></td></tr><tr><td>Conv 3 × 3</td><td>32</td><td></td><td>BN/ELU</td></tr><tr><td>Conv 3 × 3</td><td>32</td><td></td><td>BN/ELU</td></tr><tr><td>Conv 3 × 3</td><td>64</td><td>２２２２</td><td>BN/ELU</td></tr><tr><td>Conv 3 × 3</td><td>64</td><td></td><td>BN/ELU</td></tr><tr><td>Flatten Linear</td><td>32+32</td><td></td><td></td></tr><tr><td colspan="4">Component Decoder</td></tr><tr><td>Layer</td><td>Size/Ch.</td><td>Stride</td><td>Norm./Act.</td></tr><tr><td>Input</td><td>32 (1d)</td><td></td><td></td></tr><tr><td>Spatial Broadcast</td><td>32+2 (3d)</td><td></td><td></td></tr><tr><td>Conv 3 × 3</td><td>32</td><td>1</td><td>BN/ELU</td></tr><tr><td>Conv 3 × 3</td><td>32</td><td>1</td><td>BN/ELU</td></tr><tr><td>Conv 3 × 3</td><td>32</td><td>1</td><td>BN/ELU</td></tr><tr><td>Conv 3 × 3</td><td>3</td><td>1</td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr></table>
+
+# D.4 BASELINES
+
+Here we give out the details of the background decoder in training of SPAIR (both full image as well as patch-wise training). The foreground and background image encoder is same as that of SPACE with the only difference that the inferred latents are conditioned on previous cells’ latents as described in Section 2.2. For the background image encoder, we add an additional linear layer so that the encoded background latent is one dimensional.
+
+<table><tr><td colspan="4">SPAIR Background Decoder</td></tr><tr><td>Layer</td><td>Size/Ch.</td><td>Stride</td><td>Norm./Act.</td></tr><tr><td>Input</td><td>32</td><td></td><td></td></tr><tr><td>Conv 1 × 1</td><td>256</td><td>1</td><td>GN(16)/CELU</td></tr><tr><td>ConvSub(4)</td><td>256</td><td>1</td><td>GN(16)/CELU</td></tr><tr><td>Conv 3 × 3</td><td>256</td><td>1</td><td>GN(16)/CELU</td></tr><tr><td>ConvSub(4)</td><td>128</td><td>1</td><td>GN(16)/CELU</td></tr><tr><td>Conv 3 × 3</td><td>128</td><td>1</td><td>GN(16)/CELU</td></tr><tr><td>ConvSub(2)</td><td>64</td><td>1</td><td>GN(8)/CELU</td></tr><tr><td>Conv 3 × 3</td><td>64</td><td>1</td><td>GN(8)/CELU</td></tr><tr><td>ConvSub(4)</td><td>16</td><td>1</td><td>GN(4)/CELU</td></tr><tr><td>Conv 3 × 3</td><td>16</td><td>1</td><td>GN(4)/CELU</td></tr><tr><td>Conv 3 × 3</td><td>16</td><td>1</td><td>GN(4)/CELU</td></tr><tr><td>Conv 3 × 3</td><td>3</td><td>1</td><td></td></tr><tr><td colspan="4">SPAIR Background Encoder For Patch Training</td></tr><tr><td>Layer</td><td>Size/Ch.</td><td>Stride</td><td>Norm./Act.</td></tr><tr><td>Input</td><td>3</td><td></td><td></td></tr><tr><td>Conv 2 × 2</td><td>16</td><td></td><td>GN(4)/CELU</td></tr><tr><td>Conv 2 × 2</td><td>32</td><td>２2</td><td>GN(8)/CELU</td></tr><tr><td>Conv 2 × 2</td><td>64</td><td>2</td><td>GN(8)/CELU</td></tr><tr><td>Conv 2 × 2</td><td>128</td><td>2</td><td>GN(16)/CELU</td></tr><tr><td>Conv 2 × 2</td><td>32</td><td>2</td><td>GN(4)/CELU</td></tr></table>
+
+SPAIR Background Decoder For Patch Training   
+
+<table><tr><td>Layer</td><td>Size/Ch.</td><td>Stride</td><td>Norm./Act.</td></tr><tr><td>Input</td><td>16</td><td></td><td></td></tr><tr><td>Conv 1 ×1</td><td>256</td><td>1</td><td>GN(16)/CELU</td></tr><tr><td>Conv 1 × 1</td><td>2048</td><td>1</td><td></td></tr><tr><td>ConvSub(4)</td><td>128</td><td>1</td><td>GN(16)/CELU</td></tr><tr><td>Conv 3 × 3</td><td>128</td><td>1</td><td>GN(16)/CELU</td></tr><tr><td>Conv 1 ×1</td><td>256</td><td>1</td><td></td></tr><tr><td>ConvSub(2)</td><td>64</td><td>1</td><td>GN(8)/CELU</td></tr><tr><td>Conv 3 × 3</td><td>64</td><td>1</td><td>GN(8)/CELU</td></tr><tr><td>Conv 1 ×1</td><td>256</td><td>1</td><td></td></tr><tr><td>ConvSub(4)</td><td>16</td><td>1</td><td>GN(4)/CELU</td></tr><tr><td>Conv 3 × 3</td><td>16</td><td>1</td><td>GN(4)/CELU</td></tr><tr><td>Conv 3 × 3</td><td>16</td><td>1</td><td>GN(4)/CELU</td></tr><tr><td>Conv 3 × 3</td><td>3</td><td>1</td><td></td></tr></table>
+
+For IODINE, we use our own implementation following the details as described in (Greff et al., 2019). For GENESIS, we also use our own implementation following the same architecture as in (Engelcke et al., 2019), but the details of individual networks are similar to SPACE’s background module.
+
+# E DATASET DETAILS
+
+Atari. For each game, we sample 60,000 random images from a pretrained agent (Wu et al., 2016). We split the images into 50,000 for the training set, 5,000 for the validation set, and 5,000 for the testing set. Each image is preprocessed into a size of $1 2 8 \times 1 2 8$ pixels with BGR color channels. We present the results for the following games: Space Invaders, Air Raid, River Raid, Montezuma’s Revenge.
+
+We also train our model on a dataset of 10 games jointly, where we have 8,000 training images, 1,000 validation images, and 1,000 testing images for each game. We use the following games: Asterix, Atlantis, Carnival, Double Dunk, Kangaroo, Montezuma Revenge, Pacman, Pooyan, Qbert, Space Invaders.
+
+Room 3D. We use MuJoCo (Todorov et al., 2012) to generate this dataset. Each image consists of a walled enclosure with a random number of objects on the floor. The possible objects are randomly sized spheres, cubes, and cylinders. The small 3D-Room dataset has 4-8 objects and the large 3DRoom dataset has 18-24 objects. The color of the objects are randomly chosen from 8 different colors and the colors of the background (wall, ground, sky) are chosen randomly from 5 different colors. The angle of the camera is also selected randomly. We use a training set of 63,000 images, a validation set of 7,000 images, and a test set of 7,000 images. We use a 2-D projection from the camera to determine the ground truth bounding boxes of the objects so that we can report the average precision of the different models.