Add files using upload-large-folder tool

parse/train/0oabwyZbOu/0oabwyZbOu.md

@@ -0,0 +1,341 @@
+# MASTERING ATARI WITH DISCRETE WORLD MODELS
+
+Danijar Hafner ∗ Google Research
+
+Timothy Lillicrap DeepMind
+
+Mohammad Norouzi Google Research
+
+Jimmy Ba University of Toronto
+
+# ABSTRACT
+
+Intelligent agents need to generalize from past experience to achieve goals in complex environments. World models facilitate such generalization and allow learning behaviors from imagined outcomes to increase sample-efficiency. While learning world models from image inputs has recently become feasible for some tasks, modeling Atari games accurately enough to derive successful behaviors has remained an open challenge for many years. We introduce DreamerV2, a reinforcement learning agent that learns behaviors purely from predictions in the compact latent space of a powerful world model. The world model uses discrete representations and is trained separately from the policy. DreamerV2 constitutes the first agent that achieves human-level performance on the Atari benchmark of 55 tasks by learning behaviors inside a separately trained world model. With the same computational budget and wall-clock time, Dreamer V2 reaches 200M frames and surpasses the final performance of the top single-GPU agents IQN and Rainbow. DreamerV2 is also applicable to tasks with continuous actions, where it learns an accurate world model of a complex humanoid robot and solves stand-up and walking from only pixel inputs.
+
+# 1 INTRODUCTION
+
+To successfully operate in unknown environments, reinforcement learning agents need to learn about their environments over time. World models are an explicit way to represent an agent’s knowledge about its environment. Compared to model-free reinforcement learning that learns through trial and error, world models facilitate generalization and can predict the outcomes of potential actions to enable planning (Sutton, 1991). Capturing general aspects of the environment, world models have been shown to be effective for transfer to novel tasks (Byravan et al., 2019), directed exploration (Sekar et al., 2020), and generalization from offline datasets (Yu et al., 2020). When the inputs are high-dimensional images, latent dynamics models predict ahead in an abstract latent space (Watter et al., 2015; Ha and Schmidhuber, 2018; Hafner et al., 2018; Zhang et al., 2019). Predicting compact representations instead of images has been hypothesized to reduce accumulating errors and their small memory footprint enables thousands of parallel predictions on a single GPU (Hafner et al., 2018; 2019). Leveraging this approach, the recent Dreamer agent (Hafner et al., 2019) has solved a wide range of continuous control tasks from image inputs.
+
+Despite their intriguing properties, world models have so far not been accurate enough to compete with the stateof-the-art model-free algorithms on the most competitive benchmarks. The well-established Atari benchmark (Bellemare et al., 2013) historically required model-free algorithms to achieve human-level performance, such as DQN (Mnih et al., 2015), A3C (Mnih et al., 2016), or Rainbow (Hessel et al., 2018). Several attempts at learning accurate world models of Atari games have been made, without achieving competitive performance (Oh et al., 2015; Chiappa et al., 2017; Kaiser et al., 2019). On the other hand, the recently proposed MuZero agent (Schrittwieser et al., 2019) shows that planning can achieve impressive performance on board games and deterministic Atari games given extensive engineering effort and a vast computational budget. However, its implementation is not available to the public and it would require over 2 months of computation to train even one agent on a GPU, rendering it impractical for most research groups.
+
+![](images/5f701f096c04ee2c7aeae32384ce0edf4485cc7d50cdc51ba2bb18d7dc904d22.jpg)  
+Figure 1: Gamer normalized median score on the Atari benchmark of 55 games with sticky actions at 200M steps. DreamerV2 is the first agent that learns purely within a world model to achieve human-level Atari performance, demonstrating the high accuracy of its learned world model. DreamerV2 further outperforms the top single-GPU agents Rainbow and IQN, whose scores are provided by Dopamine (Castro et al., 2018). According to its authors, SimPLe (Kaiser et al., 2019) was only evaluated on an easier subset of 36 games and trained for fewer steps and additional training does not further increase its performance.
+
+In this paper, we introduce DreamerV2, the first reinforcement learning agent that achieves humanlevel performance on the Atari benchmark by learning behaviors purely within a separately trained world model, as shown in Figure 1. Learning successful behaviors purely within the world model demonstrates that the world model learns to accurately represent the environment. To achieve this, we apply small modifications to the Dreamer agent (Hafner et al., 2019), such as using discrete latents and balancing terms within the KL loss. Using a single GPU and a single environment instance, DreamerV2 outperforms top single-GPU Atari agents Rainbow (Hessel et al., 2018) and IQN (Dabney et al., 2018), which rest upon years of model-free reinforcement learning research (Van Hasselt et al., 2015; Schaul et al., 2015; Wang et al., 2016; Bellemare et al., 2017; Fortunato et al., 2017). Moreover, aspects of these algorithms are complementary to our world model and could be integrated into the Dreamer framework in the future. To rigorously compare the algorithms, we report scores normalized by both a human gamer (Mnih et al., 2015) and the human world record (Toromanoff et al., 2019) and make a suggestion for reporting scores going forward.
+
+# 2 DREAMERV2
+
+We present DreamerV2, an evolution of the Dreamer agent (Hafner et al., 2019). We refer to the original Dreamer agent as DreamerV1 throughout this paper. This section describes the complete DreamerV2 algorithm, consisting of the three typical components of a model-based agent (Sutton, 1991). We learn the world model from a dataset of past experience, learn an actor and critic from imagined sequences of compact model states, and execute the actor in the environment to grow the experience dataset. In Appendix C, we include a list of changes that we applied to DreamerV1 and which of them we found to increase empirical performance.
+
+# 2.1 WORLD MODEL LEARNING
+
+World models summarize an agent’s experience into a predictive model that can be used in place of the environment to learn behaviors. When inputs are high-dimensional images, it is beneficial to learn compact state representations of the inputs to predict ahead in this learned latent space (Watter et al., 2015; Karl et al., 2016; Ha and Schmidhuber, 2018). These models are called latent dynamics models. Predicting ahead in latent space not only facilitates long-term predictions, it also allows to efficiently predict thousands of compact state sequences in parallel in a single batch, without having to generate images. DreamerV2 builds upon the world model that was introduced by PlaNet (Hafner et al., 2018) and used in DreamerV1, by replacing its Gaussian latents with categorical variables.
+
+Experience dataset The world model is trained from the agent’s growing dataset of past experience that contains sequences of images $x _ { 1 : T }$ , actions $a _ { 1 : T }$ , rewards $r _ { 1 : T }$ , and discount factors $\gamma _ { 1 : T }$ . The discount factors equal a fixed hyper parameter $\gamma = 0 . 9 9 9$ for time steps within an episode and are set to zero for terminal time steps. For training, we use batches of $B = 5 0$ sequences of fixed length $L = 5 0$ that are sampled randomly within the stored episodes. To observe enough episode ends during training, we sample the start index of each training sequence uniformly within the episode and then clip it to not exceed the episode length minus the training sequence length.
+
+Model components The world model consists of an image encoder, a Recurrent State-Space Model (RSSM; Hafner et al., 2018) to learn the dynamics, and predictors for the image, reward, and discount factor. The world model is summarized in Figure 2. The RSSM uses a sequence of deterministic recurrent states $h _ { t }$ , from which it computes two distributions over stochastic states at each step. The posterior state $z _ { t }$ incorporates information about the current image $x _ { t }$ , while the prior state $\hat { z } _ { t }$ aims to predict the posterior without access to the current image. The concatenation of deterministic and stochastic states forms the compact model state. From the posterior model state, we reconstruct the current image $x _ { t }$ and predict the reward $r _ { t }$ and discount factor $\gamma _ { t }$ . The model components are:
+
+![](images/ec4c3eb25c02808098897026bc569eaa929806513fc94aec9e86a7f3e30285e2.jpg)  
+Figure 2: World Model Learning. The training sequence of images $x _ { t }$ is encoded using the CNN. The RSSM uses a sequence of deterministic recurrent states $h _ { t }$ . At each step, it computes a posterior stochastic state $z _ { t }$ that incorporates information about the current image $x _ { t }$ , as well as a prior stochastic state $\hat { z } _ { t }$ that tries to predict the posterior without access to the current image. Unlike in PlaNet and DreamerV1, the stochastic state of DreamerV2 is a vector of multiple categorical variables. The learned prior is used for imagination, as shown in Figure 3. The KL loss both trains the prior and regularizes how much information the posterior incorporates from the image. The regularization increases robustness to novel inputs. It also encourages reusing existing information from past steps to predict rewards and reconstruct images, thus learning long-term dependencies.
+
+Recurrent model: $\begin{array} { l } { h _ { t } = f _ { \phi } ( h _ { t - 1 } , z _ { t - 1 } , a _ { t - 1 } ) } \\ { z _ { t } \sim q _ { \phi } ( z _ { t } \mid h _ { t } , x _ { t } ) } \\ { \hat { z } _ { t } \sim p _ { \phi } ( \hat { z } _ { t } \mid h _ { t } ) } \\ { \hat { x } _ { t } \sim p _ { \phi } ( \hat { x } _ { t } \mid h _ { t } , z _ { t } ) } \\ { \hat { r } _ { t } \sim p _ { \phi } ( \hat { r } _ { t } \mid h _ { t } , z _ { t } ) } \\ { \hat { \gamma } _ { t } \sim p _ { \phi } ( \hat { \gamma } _ { t } \mid h _ { t } , z _ { t } ) . } \end{array}$ RSSM Representation model: Transition predictor: Image predictor: Reward predictor: Discount predictor:
+
+All components are implemented as neural networks and $\phi$ describes their combined parameter vector. The transition predictor guesses the next model state only from the current model state and the action but without using the next image, so that we can later learn behaviors by predicting sequences of model states without having to observe or generate images. The discount predictor lets us estimate the probability of an episode ending when learning behaviors from model predictions.
+
+Neural networks The representation model is implemented as a Convolutional Neural Network (CNN; LeCun et al., 1989) followed by a Multi-Layer Perceptron (MLP) that receives the image embedding and the deterministic recurrent state. The RSSM uses a Gated Recurrent Unit (GRU; Cho et al., 2014) to compute the deterministic recurrent states. The model state is the concatenation of deterministic GRU state and a sample of the stochastic state. The image predictor is a transposed CNN and the transition, reward, and discount predictors are MLPs. We down-scale the $8 4 \times 8 4$ grayscale images to $6 4 \times 6 4$ pixels so that we can apply the convolutional architecture of DreamerV1.
+
+<table><tr><td colspan="3">Algorithm 1: Straight-Through Gradients with Automatic Differentiation</td></tr><tr><td>sample = one_hot(draw(logits))</td><td></td><td># sample has no gradient</td></tr><tr><td>probs = softmax(logits)</td><td></td><td> # want gradient of this</td></tr><tr><td>sample = sample + probs - stop_grad(probs)</td><td></td><td>）# has gradient of probs</td></tr></table>
+
+We use the ELU activation function for all components of the model (Clevert et al., 2015). The world model uses a total of 20M trainable parameters.
+
+Distributions The image predictor outputs the mean of a diagonal Gaussian likelihood with unit variance, the reward predictor outputs a univariate Gaussian with unit variance, and the discount predictor outputs a Bernoulli likelihood. In prior work, the latent variable in the model state was a diagonal Gaussian that used reparameterization gradients during backpropagation (Kingma and Welling, 2013; Rezende et al., 2014). In DreamerV2, we instead use a vector of several categorical variables and optimize them using straight-through gradients (Bengio et al., 2013), which are easy to implement using automatic differentiation as shown in Algorithm 1. We discuss possible benefits of categorical over Gaussian latents in the experiments section.
+
+Loss function All components of the world model are optimized jointly. The distributions produced by the image predictor, reward predictor, discount predictor, and transition predictor are trained to maximize the log-likelihood of their corresponding targets. The representation model is trained to produce model states that facilitates these prediction tasks, through the expectation below. Moreover, it is regularized to produce model states with high entropy, such that the model becomes robust to many different model states during training. The loss function for learning the world model is:
+
+$$
+\begin{array} { r } { \mathcal { L } ( \phi ) \doteq \mathrm { E } _ { q _ { \phi } ( z _ { 1 : T } \mid a _ { 1 : T } , x _ { 1 : T } ) } \Big [ \sum _ { t = 1 } ^ { T } \underbrace { - \ln p _ { \phi } ( x _ { t } \mid h _ { t } , z _ { t } ) } _ { \mathrm { i n a g e l o g l o s s } } \frac { - \ln p _ { \phi } ( r _ { t } \mid h _ { t } , z _ { t } ) } { \mathrm { r e w a r d l o g l o s s } } \frac { - \ln p _ { \phi } ( \gamma _ { t } \mid h _ { t } , z _ { t } ) } { \mathrm { d i s c o u n t l o g l o s s } } } \\ { \underbrace { + \beta \operatorname { K L } \big [ q _ { \phi } ( z _ { t } \mid h _ { t } , x _ { t } ) \big \rvert \big \lvert p _ { \phi } ( z _ { t } \mid h _ { t } ) \big ] \Big ] } _ { \mathrm { K L I o s s } } . } \end{array}
+$$
+
+We jointly minimize the loss function with respect to the vector $\phi$ that contains all parameters of the world model using the Adam optimizer (Kingma and Ba, 2014). We scale the KL loss by $\beta = 0 . 1$ for Atari and by $\beta = 1 . 0$ for continuous control (Higgins et al., 2016).
+
+KL balancing The world model loss function in Equation 2 is the ELBO or variational free energy of a hidden Markov model that is conditioned on the action sequence. The world model can thus be interpreted as a sequential VAE, where the representation model is the approximate posterior and the transition predictor is the temporal prior. In the ELBO objective, the KL loss serves two purposes: it trains the prior toward the representations, and it regularizes the representations toward the prior. However, learning the transition function is difficult and we want to avoid regularizing the representations toward a poorly trained prior. To solve this problem, we minimize the KL loss faster with respect to the prior than the representations by using different learning rates, $\alpha = 0 . 8$ for the prior and $1 - \alpha$ for the approximate posterior. We implement this technique as shown in Algorithm 2 and refer to it as KL balancing. KL balancing encourages learning an accurate prior over increasing posterior entropy, so that the prior better approximates the aggregate posterior. KL balancing is different from and orthogonal to beta-VAEs (Higgins et al., 2016).
+
+# 2.2 BEHAVIOR LEARNING
+
+DreamerV2 learns long-horizon behaviors purely within its world model using an actor and a critic. The actor chooses actions for predicting imagined sequences of compact model states. The critic accumulates the future predicted rewards to take into account rewards beyond the planning horizon. Both the actor and critic operate on top of the learned model states and thus benefit from the representations learned by the world model. The world model is fixed during behavior learning, so the actor and value gradients do not affect its representations. Not predicting images during behavior learning lets us efficiently simulate 2500 latent trajectories in parallel on a single GPU.
+
+Imagination MDP To learn behaviors within the latent space of the world model, we define the imagination MPD as follows. The distribution of initial states $\hat { z } _ { 0 }$ in the imagination MDP is the distribution of compact model states encountered during world model training. From there, the transition predictor $\hat { p } _ { \phi } ( \hat { z } _ { t } \mid \hat { z } _ { t - 1 } , \hat { a } _ { t - 1 } )$ outputs sequences $\hat { z } _ { 1 : H }$ of compact model states up to the imagination horizon $H = 1 5$ . The mean of the reward predictor $p _ { \phi } ( \hat { \boldsymbol { r } } _ { t } \mid \hat { \boldsymbol { z } } _ { t } )$ is used as reward sequence $\hat { r } _ { 1 : H }$ . The discount predictor $p _ { \phi } ( \hat { \gamma } _ { t } \mid \hat { z } _ { t } )$ outputs the discount sequence $\hat { \gamma } _ { 1 : H }$ that is used to down-weight rewards. Moreover, we weigh the loss terms of the actor and critic by the cumulative predicted discount factors to softly account for the possibility of episode ends.
+
+<table><tr><td colspan="4">Algorithm 2: KL Balancing with Automatic Differentiation</td></tr><tr><td></td><td></td><td></td><td>kl_loss = alpha * compute_kl(stop_grad(approx_posterior)， prior)</td></tr><tr><td></td><td></td><td></td><td> + (l - alpha) * compute_kl(approx_posterior， stop_grad(prior))</td></tr></table>
+
+![](images/e6d11abeab0d4119ebf62d594df7d6c73ef556f7ecab9414b852dd4fdd8b4a4e.jpg)  
+Figure 3: Actor Critic Learning. The world model learned in Figure 2 is used for learning a policy from trajectories imagined in the compact latent space. The trajectories start from posterior states computed during model training and predict forward by sampling actions from the actor network. The critic network predicts the expected sum of future rewards for each state. The critic uses temporal difference learning on the imagined rewards. The actor is trained to maximize the critic prediction, via reinforce gradients, straight-through gradients of the world model, or a combination of them.
+
+Model components To learn long-horizon behaviors in the imagination MDP, we leverage a stochastic actor that chooses actions and a deterministic critic. The actor and critic are trained cooperatively, where the actor aims to output actions that lead to states that maximize the critic output, while the critic aims to accurately estimate the sum of future rewards achieved by the actor from each imagined state. The actor and critic use the parameter vectors $\psi$ and $\xi$ , respectively:
+
+$$
+\begin{array} { r l } { \mathrm { A c t o r : } \quad } & { \hat { a } _ { t } \sim p _ { \psi } ( \hat { a } _ { t } \mid \hat { z } _ { t } ) } \\ { \mathrm { C r i t i c : } \quad } & { v _ { \xi } ( \hat { z } _ { t } ) \approx \mathrm { E } _ { p _ { \phi } , p _ { \psi } } \Big [ \sum _ { \tau \geq t } \hat { \gamma } ^ { \tau - t } \hat { r } _ { \tau } \Big ] . } \end{array}
+$$
+
+In contrast to the actual environment, the latent state sequence is Markovian, so that there is no need for the actor and critic to condition on more than the current model state. The actor and critic are both MLPs with ELU activations (Clevert et al., 2015) and use 1M trainable parameters each. The actor outputs a categorical distribution over actions and the critic has a deterministic output. The two components are trained from the same imagined trajectories but optimize separate loss functions.
+
+Critic loss function The critic aims to predict the discounted sum of future rewards that the actor achieves in a given model state, known as the state value. For this, we leverage temporal-difference learning, where the critic is trained toward a value target that is constructed from intermediate rewards and critic outputs for later states. A common choice is the 1-step target that sums the current reward and the critic output for the following state. However, the imagination MDP lets us generate on-policy trajectories of multiple steps, suggesting the use of n-step targets that incorporate reward information into the critic more quickly. We follow DreamerV1 in using the more general $\lambda$ -target (Sutton and Barto, 2018; Schulman et al., 2015) that is defined recursively as follows:
+
+$$
+V _ { t } ^ { \lambda } \doteq \hat { r } _ { t } + \hat { \gamma } _ { t } \left\{ { ( 1 - \lambda ) v _ { \xi } ( \hat { z } _ { t + 1 } ) + \lambda V _ { t + 1 } ^ { \lambda } \quad \mathrm { i f } \quad t < H } , \right. \kern - delimiterspace  \chi _ { t } \in \ c U ,
+$$
+
+Intuitively, the $\lambda$ -target is a weighted average of n-step returns for different horizons, where longer horizons are weighted exponentially less. We set $\lambda = 0 . 9 5$ in practice, to focus more on long horizon
+
+targets than on short horizon targets. Given a trajectory of model states, rewards, and discount factors, we train the critic to regress the $\lambda$ -return using a squared loss:
+
+$$
+\begin{array} { r } { \mathcal { L } ( \xi ) \doteq \mathrm { E } _ { p _ { \phi } , p _ { \psi } } \left[ \sum _ { t = 1 } ^ { H - 1 } \frac { 1 } { 2 } \big ( v _ { \xi } \big ( \hat { z } _ { t } \big ) - \mathrm { s g } ( V _ { t } ^ { \lambda } ) \big ) ^ { 2 } \right] . } \end{array}
+$$
+
+We optimize the critic loss with respect to the critic parameters $\xi$ using the Adam optimizer. There is no loss term for the last time step because the target equals the critic at that step. We stop the gradients around the targets, denoted by the $\operatorname { s g } ( \cdot )$ function, as typical in the literature. We stabilize value learning using a target network (Mnih et al., 2015), namely, we compute the targets using a copy of the critic that is updated every 100 gradient steps.
+
+Actor loss function The actor aims to output actions that maximize the prediction of long-term future rewards made by the critic. To incorporate intermediate rewards more directly, we train the actor to maximize the same $\lambda$ -return that was computed for training the critic. There are different gradient estimators for maximizing the targets with respect to the actor parameters. DreamerV2 combines unbiased but high-variance Reinforce gradients with biased but low-variance straightthrough gradients. Moreover, we regularize the entropy of the actor to encourage exploration where feasible while allowing the actor to choose precise actions when necessary.
+
+Learning by Reinforce (Williams, 1992) maximizes the actor’s probability of its own sampled actions weighted by the values of those actions. The variance of this estimator can be reduced by subtracting the state value as baseline, which does not depend on the current action. Intuitively, subtracting the baseline centers the weights and leads to faster learning. The benefit of Reinforce is that it produced unbiased gradients and the downside is that it can have high variance, even with baseline.
+
+DreamerV1 relied entirely on reparameterization gradients (Kingma and Welling, 2013; Rezende et al., 2014) to train the actor directly by backpropagating value gradients through the sequence of sampled model states and actions. DreamerV2 uses both discrete latents and discrete actions. To backpropagate through the sampled actions and state sequences, we leverage straight-through gradients (Bengio et al., 2013). This results in a biased gradient estimate with low variance. The combined actor loss function is:
+
+$$
+\begin{array} { r } { \mathcal { L } ( \psi ) \doteq \mathrm { E } _ { p _ { \phi } , p _ { \psi } } \left[ \sum _ { t = 1 } ^ { H - 1 } \big ( \underbrace { - \rho \ln p _ { \psi } ( \hat { a } _ { t } \mid \hat { z } _ { t } ) \mathrm { s g } ( V _ { t } ^ { \lambda } - v _ { \xi } ( \hat { z } _ { t } ) ) } _ { \mathrm { r e i n f o r c e } } \underbrace { - ( 1 - \rho ) V _ { t } ^ { \lambda } } _ { \mathrm { d y n a m i c s } } \underbrace { - \eta \mathrm { H } [ a _ { t } | \hat { z } _ { t } ] } _ { \mathrm { e n t r o p y ~ r e g u l a r i z e r } } \big ) \right] . } \end{array}
+$$
+
+We optimize the actor loss with respect to the actor parameters $\psi$ using the Adam optimizer. We consider both Reinforce gradients and straight-through gradients, which backpropagate directly through the learned dynamics. Intuitively, the low-variance but biased dynamics backpropagation could learn faster initially and the unbiased but high-variance could to converge to a better solution. For Atari, we find Reinforce gradients to work substantially better and use $\rho = 1$ and $\eta = 1 0 ^ { - 3 }$ . For continuous control, we find dynamics backpropagation to work substantially better and use $\rho = 0$ and $\eta = 1 0 ^ { - 4 }$ . Annealing these hyper parameters can improve performance slightly but to avoid the added complexity we report the scores without annealing.
+
+# 3 EXPERIMENTS
+
+We evaluate DreamerV2 on the well-established Atari benchmark with sticky actions, comparing to four strong model-free algorithms. DreamerV2 outperforms the four model-free algorithms in all scenarios. For an extensive comparison, we report four scores according to four aggregation protocols and give a recommendation for meaningfully aggregating scores across games going forward. We also ablate the importance of discrete representations in the world model. Our implementation of DreamerV2 reaches 200M environment steps in under 10 days, while using only a single NVIDIA V100 GPU and a single environment instance. During the 200M environment steps, DreamerV2 learns its policy from 468B compact states imagined under the model, which is $1 0 { , } 0 0 0 \times$ more than the 50M inputs received from the real environment after action repeat. Refer to the project website for videos, the source code, and training curves in JSON format.
+
+![](images/fd68526c0da3d5c87d80d6bf999d8e68d9a2978cc0508816fc3de67e0ac059e9.jpg)  
+Figure 4: Atari performance over 200M steps. See Table 1 for numeric scores. The standards in the literature to aggregate over tasks are shown in the left two plots. These normalize scores by a professional gamer and compute the median or mean over tasks (Mnih et al., 2015; 2016). In Section 3, we point out limitations of this methodology. As a robust measure of performance, we recommend the metric in the right-most plot. We normalize scores by the human world record (Toromanoff et al., 2019) and then clip them, such that exceeding the record does not further increase the score, before averaging over tasks.
+
+Experimental setup We select the 55 games that prior works in the literature from different research labs tend to agree on (Mnih et al., 2016; Brockman et al., 2016; Hessel et al., 2018; Castro et al., 2018; Badia et al., 2020) and recommend this set of games for evaluation going forward. We follow the evaluation protocol of Machado et al. (2018) with 200M environment steps, action repeat of 4, a time limit of 108,000 steps per episode that correspond to 30 minutes of game play, no access to life information, full action space, and sticky actions. Because the world model integrates information over time, DreamerV2 does not use frame stacking. The experiments use a single-task setup where a separate agent is trained for each game. Moreover, each agent uses only a single environment instance. We compare the algorithms based on both human gamer and human world record normalization (Toromanoff et al., 2019).
+
+Model-free baselines We compare the learning curves and final scores of DreamerV2 to four model-free algorithms, IQN (Dabney et al., 2018), Rainbow (Hessel et al., 2018), C51 (Bellemare et al., 2017), and DQN (Mnih et al., 2015). We use the scores of these agents provided by the Dopamine framework (Castro et al., 2018) that use sticky actions. These may differ from the reported results in the papers that introduce these algorithms in the deterministic Atari setup. The training time of Rainbow was reported at 10 days on a single GPU and using one environment instance.
+
+# 3.1 ATARI PERFORMANCE
+
+The performance curves of DreamerV2 and four standard model-free algorithms are visualized in Figure 4. The final scores at 200M environment steps are shown in Table 1 and the scores on individual games are included in Table K1. There are different approaches for aggregating the scores across the 55 games and we show that this choice can have a substantial impact on the relative performance between algorithms. To extensively compare DreamerV2 to the model-free algorithms, we consider the following four aggregation approaches:
+
+<table><tr><td>Agent</td><td>Gamer Median</td><td>Gamer Mean</td><td>Record Mean</td><td>Clipped Record Mean</td></tr><tr><td>DreamerV2</td><td>2.15</td><td>42.26</td><td>0.44</td><td>0.28</td></tr><tr><td>DreamerV2 (schedules)</td><td>2.64</td><td>31.71</td><td>0.43</td><td>0.28</td></tr><tr><td>IMPALA</td><td>1.92</td><td>16.72</td><td>0.34</td><td>0.23</td></tr><tr><td>IQN</td><td>1.29</td><td>11.27</td><td>0.21</td><td>0.21</td></tr><tr><td>Rainbow</td><td>1.47</td><td>9.95</td><td>0.17</td><td>0.17</td></tr><tr><td>C51</td><td>1.09</td><td>8.25</td><td>0.15</td><td>0.15</td></tr><tr><td>DQN</td><td>0.65</td><td>3.28</td><td>0.12</td><td>0.12</td></tr></table>
+
+Table 1: Atari performance at 200M steps. The scores of the 55 games are aggregated using the four different protocols described in Section 3. To overcome limitations of the previous metrics, we recommend the task mean of clipped record normalized scores as a robust measure of algorithm performance, shown in the right-most column. DreamerV2 outperforms previous single-GPU agents across all metrics. The baseline scores are taken from Dopamine Baselines (Castro et al., 2018).
+
+![](images/6948f199b359db699eeba25553e78c4aa4338c59b83125f354d5ad139cbf37fe.jpg)  
+Figure 5: Clipped record normalized scores of various ablations of the DreamerV2 agent. This experiment uses a slightly earlier version of DreamerV2. The score curves for individual tasks are shown in Figure H1. The ablations highlight the benefit of using categorical over Gaussian latent variables and of using KL balancing. Moreover, they show that the world model relies on image gradients for learning its representations. Stopping reward gradients even improves performance on some tasks, suggesting that representations that are not specifically trained to predict previously experienced rewards may generalize better to new situations.
+
+• Gamer Median Atari scores are commonly normalized based on a random policy and a professional gamer, averaged over seeds, and the median over tasks is reported (Mnih et al., 2015; 2016). However, if almost half of the scores would be zero, the median would not be affected. Thus, we argue that median scores are not reflective of the robustness of an algorithm and results in wasted computational resources for games that will not affect the score.
+
+• Gamer Mean Compared to the task median, the task mean considers all tasks. However, the gamer performed poorly on a small number of games, such as Crazy Climber, James Bond, and Video Pinball. This makes it easy for algorithms to achieve a high normalized score on these few games, which then dominate the task mean so it is not informative of overall performance.
+
+• Record Mean Instead of normalizing based on the professional gamer, Toromanoff et al. (2019) suggest to normalize based on the registered human world record of each game. This partially addresses the outlier problem but the mean is still dominated by games where the algorithms easily achieve superhuman performance.
+
+• Clipped Record Mean To overcome these limitations, we recommend normalizing by the human world record and then clipping the scores to not exceed a value of 1, so that performance above the record does not further increase the score. The result is a robust measure of algorithm performance on the Atari suite that considers performance across all games.
+
+From Figure 4 and Table 1, we see that the different aggregation approaches let us examine agent performance from different angles. Interestingly, Rainbow clearly outperforms IQN in the first aggregation method but IQN clearly outperforms Rainbow in the remaining setups. DreamerV2 outperforms the model-free agents in all four metrics, with the largest margin in record normalized mean performance. Despite this, we recommend clipped record normalized mean as the most meaningful aggregation method, as it considers all tasks to a similar degree without being dominated by a small number of outlier scores. In Table 1, we also include DreamerV2 with schedules that anneal the actor entropy loss scale and actor gradient mixing over the course of training, which further increases the gamer median score of DreamerV2.
+
+Individual games The scores on individual Atari games at 200M environment steps are included in Table K1, alongside the model-free algorithms and the baselines of random play, human gamer, and human world record. We filled in reasonable values for the 2 out of 55 games that have no registered world record. Figure E1 compares the score differences between DreamerV2 and each model-free algorithm for the individual games. DreamerV2 achieves comparable or higher performance on most games except for Video Pinball. We hypothesize that the reconstruction loss of the world model does not encourage learning a meaningful latent representation because the most important object in the game, the ball, occupies only a single pixel. One the other hand, DreamerV2 achieves the strongest improvements over the model-free agents on the games James Bond, Up N Down, and Assault.
+
+<table><tr><td>Agent</td><td>Gamer Median</td><td>Gamer Mean</td><td>RecordMean</td><td>Clipped Record Mean</td></tr><tr><td>DreamerV2</td><td>1.64</td><td>13.39</td><td>0.36</td><td>0.25</td></tr><tr><td>No Layer Norm</td><td>1.66</td><td>11.29</td><td>0.38</td><td>0.25</td></tr><tr><td>No Reward Gradients</td><td>1.68</td><td>14.29</td><td>0.37</td><td>0.24</td></tr><tr><td>No Discrete Latents</td><td>0.85</td><td>3.96</td><td>0.24</td><td>0.19</td></tr><tr><td>No KL Balancing</td><td>0.87</td><td>4.25</td><td>0.19</td><td>0.16</td></tr><tr><td>No Policy Reinforce</td><td>0.72</td><td>5.10</td><td>0.16</td><td>0.15</td></tr><tr><td>No Image Gradients</td><td>0.05</td><td>0.37</td><td>0.01</td><td>0.01</td></tr></table>
+
+Table 2: Ablations to DreamerV2 measured by their Atari performance at 200M frames, sorted by the last column. The this experiment uses a slightly earlier version of DreamerV2 compared to Table 1. Each ablation only removes one part of the DreamerV2 agent. Discrete latent variables and KL balancing substantially contribute to the success of DreamerV2. Moreover, the world model relies on image gradients to learn general representations that lead to successful behaviors, even if the representations are not specifically learned for predicting past rewards.
+
+# 3.2 ABLATION STUDY
+
+To understand which ingredients of DreamerV2 are responsible for its success, we conduct an extensive ablation study. We compare equipping the world model with categorical latents, as in DreamerV2, to Gaussian latents, as in DreamerV1. Moreover, we study the importance of KL balancing. Finally, we investigate the importance of gradients from image reconstruction and reward prediction for learning the model representations, by stopping one of the two gradient signals before entering the model states. The results of the ablation study are summarized in Figure 5 and Table 2. Refer to the appendix for the score curves of the individual tasks.
+
+Categorical latents Categorical latent variables outperform than Gaussian latent variables on 42 tasks, achieve lower performance on 8 tasks, and are tied on 5 tasks. We define a tie as being within $5 \%$ of another. While we do not know the reason why the categorical variables are beneficial, we state several hypotheses that can be investigated in future work:
+
+• A categorical prior can perfectly fit the aggregate posterior, because a mixture of categoricals is again a categorical. In contrast, a Gaussian prior cannot match a mixture of Gaussian posteriors, which could make it difficult to predict multi-modal changes between one image and the next.   
+• The level of sparsity enforced by a vector of categorical latent variables could be beneficial for generalization. Flattening the sample from the 32 categorical with 32 classes each results in a sparse binary vector of length 1024 with 32 active bits.   
+• Despite common intuition, categorical variables may be easier to optimize than Gaussian variables, possibly because the straight-through gradient estimator ignores a term that would otherwise scale the gradient. This could reduce exploding and vanishing gradients.   
+• Categorical variables could be a better inductive bias than unimodal continuous latent variables for modeling the non-smooth aspects of Atari games, such as when entering a new room, or when collected items or defeated enemies disappear from the image.
+
+KL balancing KL balancing outperforms the standard KL regularizer on 44 tasks, achieves lower performance on 6 tasks, and is tied on 5 tasks. Learning accurate prior dynamics of the world model is critical because it is used for imagining latent state trajectories using policy optimization. By scaling up the prior cross entropy relative to the posterior entropy, the world model is encouraged to minimize the KL by improving its prior dynamics toward the more informed posteriors, as opposed to reducing the KL by increasing the posterior entropy. KL balancing may also be beneficial for probabilistic models with learned priors beyond world models.
+
+Model gradients Stopping the image gradients increases performance on 3 tasks, decreases performance on 51 tasks, and is tied on 1 task. The world model of DreamerV2 thus heavily relies on the learning signal provided by the high-dimensional images. Stopping the reward gradients increases performance on 15 tasks, decreases performance on 22 tasks, and is tied on 18 tasks. Figure H1 further shows that the difference in scores is small. In contrast to MuZero, DreamerV2 thus learns general representations of the environment state from image information alone. Stopping reward gradients improved performance on a number of tasks, suggesting that the representations that are not specific to previously experienced rewards may generalize better to unseen situations.
+
+<table><tr><td>Algorithm</td><td>Reward Modeling</td><td>Image Modeling</td><td>Latent Transitions</td><td>Single GPU</td><td>Trainable Parameters</td><td>Atari Frames</td><td>Accelerator Days</td></tr><tr><td>DreamerV2</td><td></td><td></td><td></td><td></td><td>22M</td><td>200M</td><td>10</td></tr><tr><td>SimPLe</td><td></td><td></td><td>×</td><td>√</td><td>74M</td><td>4M</td><td>40</td></tr><tr><td>MuZero</td><td></td><td>X</td><td></td><td>×</td><td>40M</td><td>20B</td><td>80</td></tr><tr><td>MuZero Reanalyze</td><td></td><td>×</td><td></td><td>×</td><td>40M</td><td>200M</td><td>80</td></tr></table>
+
+Table 3: Conceptual comparison of recent RL algorithms that leverage planning with a learned model. DreamerV2 and SimPLe learn complete models of the environment by leveraging the learning signal provided by the image inputs, while MuZero learns its model through value gradients that are specific to an individual task. The Monte-Carlo tree search used by MuZero is effective but adds complexity and is challenging to parallelize. This component is orthogonal to the world model proposed here.
+
+Policy gradients Using only Reinforce gradients to optimize the policy increases performance on 18 tasks, decreases performance on 24 tasks, and is tied on 13 tasks. This shows that DreamerV2 relies mostly on Reinforce gradients to learn the policy. However, mixing Reinforce and straight-through gradients yields a substantial improvement on James Bond and Seaquest, leading to a higher gamer normalized task mean score. Using only straight-through gradients to optimize the policy increases performance on 5 tasks, decreases performance on 44 tasks, and is tied on 6 tasks. We conjecture that straight-through gradients alone are not well suited for policy optimization because of their bias.
+
+# 4 RELATED WORK
+
+Model-free Atari The majority of agents applied to the Atari benchmark have been trained using model-free algorithms. DQN (Mnih et al., 2015) showed that deep neural network policies can be trained using Q-learning by incorporating experience replay and target networks. Several works have extended DQN to incorporate bias correction as in DDQN (Van Hasselt et al., 2015), prioritized experience replay (Schaul et al., 2015), architectural improvements (Wang et al., 2016), and distributional value learning (Bellemare et al., 2017; Dabney et al., 2017; 2018). Besides value learning, agents based on policy gradients have targeted the Atari benchmark, such as ACER (Schulman et al., 2017a), PPO (Schulman et al., 2017a), ACKTR (Wu et al., 2017), and Reactor (Gruslys et al., 2017). Another line of work has focused on improving performance by distributing data collection, often while increasing the budget of environment steps beyond 200M (Mnih et al., 2016; Schulman et al., 2017b; Horgan et al., 2018; Kapturowski et al., 2018; Badia et al., 2020).
+
+World models Several model-based agents focus on proprioceptive inputs (Watter et al., 2015; Gal et al., 2016; Higuera et al., 2018; Henaff et al., 2018; Chua et al., 2018; Wang et al., 2019; Wang and Ba, 2019), model images without using them for planning (Oh et al., 2015; Krishnan et al., 2015; Karl et al., 2016; Chiappa et al., 2017; Babaeizadeh et al., 2017; Gemici et al., 2017; Denton and Fergus, 2018; Buesing et al., 2018; Doerr et al., 2018; Gregor and Besse, 2018), or combine the benefits of model-based and model-free approaches (Kalweit and Boedecker, 2017; Nagabandi et al., 2017; Weber et al., 2017; Kurutach et al., 2018; Buckman et al., 2018; Ha and Schmidhuber, 2018; Wayne et al., 2018; Igl et al., 2018; Srinivas et al., 2018; Lee et al., 2019). Risi and Stanley (2019) optimize discrete latents using evolutionary search. Parmas et al. (2019) combine reinforce and reparameterization gradients. Most world model agents with image inputs have thus far been limited to relatively simple control tasks (Watter et al., 2015; Ebert et al., 2017; Ha and Schmidhuber, 2018; Hafner et al., 2018; Zhang et al., 2019; Hafner et al., 2019). We explain the two model-based approaches that were applied to Atari in detail below.
+
+SimPLe The SimPLe agent (Kaiser et al., 2019) learns a video prediction model in pixel-space and uses its predictions to train a PPO agent (Schulman et al., 2017a), as shown in Table 3. The model directly predicts each frame from the previous four frames and receives an additional discrete latent variable as input. The authors evaluate SimPLe on a subset of Atari games for 400k and 2M environment steps, after which they report diminishing returns. Some recent model-free methods have followed the comparison at $4 0 0 \mathrm { k }$ steps (Srinivas et al., 2020; Kostrikov et al., 2020). However, the highest performance achieved in this data-efficient regime is a gamer normalized median score of 0.28 (Kostrikov et al., 2020) that is far from human-level performance. Instead, we focus on the well-established and competitive evaluation after 200M frames, where many successful model-free algorithms are available for comparison.
+
+MuZero The MuZero agent (Schrittwieser et al., 2019) learns a sequence model of rewards and values (Oh et al., 2017) to solve reinforcement learning tasks via Monte-Carlo Tree Search (MCTS; Coulom, 2006; Silver et al., 2017). The sequence model is trained purely by predicting task-specific information and does not incorporate explicit representation learning using the images, as shown in Table 3. MuZero shows that with significant engineering effort and a vast computational budget, planning can achieve impressive performance on several board games and deterministic Atari games. However, MuZero is not publicly available, and it would require over 2 months to train an Atari agent on one GPU. By comparison, DreamerV2 is a simple algorithm that achieves human-level performance on Atari on a single GPU in 10 days, making it reproducible for many researchers. Moreover, the advanced planning components of MuZero are complementary and could be applied to the accurate world models learned by DreamerV2. DreamerV2 leverages the additional learning signal provided by the input images, analogous to recent successes by semi-supervised image classification (Chen et al., 2020; He et al., 2020; Grill et al., 2020).
+
+# 5 DISCUSSION
+
+We present DreamerV2, a model-based agent that achieves human-level performance on the Atari 200M benchmark by learning behaviors purely from the latent-space predictions of a separately trained world model. Using a single GPU and a single environment instance, DreamerV2 outperforms top model-free single-GPU agents Rainbow and IQN using the same computational budget and training time. To develop DreamerV2, we apply several small modifications to the Dreamer agent (Hafner et al., 2019). We confirm experimentally that learning a categorical latent space and using KL balancing improves the performance of the agent. Moreover, we find the DreamerV2 relies on image information for learning generally useful representations — its performance is not impacted by whether the representations are especially learned for predicting rewards.
+
+DreamerV2 serves as proof of concept, showing that model-based RL can outperform top model-free algorithms on the most competitive RL benchmarks, despite the years of research and engineering effort that modern model-free agents rest upon. Beyond achieving strong performance on individual tasks, world models open avenues for efficient transfer and multi-task learning, sample-efficient learning on physical robots, and global exploration based on uncertainty estimates.
+
+Acknowledgements We thank our anonymous reviewers for their feedback and Nick Rhinehart for an insightful discussion about the potential benefits of categorical latent variables.
+
+REFERENCES   
+M Babaeizadeh, C Finn, D Erhan, RH Campbell, S Levine. Stochastic Variational Video Prediction. ArXiv Preprint ArXiv:1710.11252, 2017.   
+AP Badia, B Piot, S Kapturowski, P Sprechmann, A Vitvitskyi, D Guo, C Blundell. Agent57: Outperforming the Atari Human Benchmark. ArXiv Preprint ArXiv:2003.13350, 2020.   
+MG Bellemare, Y Naddaf, J Veness, M Bowling. The Arcade Learning Environment: An Evaluation Platform for General Agents. Journal of Artificial Intelligence Research, 47, 2013.   
+MG Bellemare, W Dabney, R Munos. A Distributional Perspective on Reinforcement Learning. ArXiv Preprint ArXiv:1707.06887, 2017.   
+Y Bengio, N Léonard, A Courville. Estimating or Propagating Gradients Through Stochastic Neurons for Conditional Computation. ArXiv Preprint ArXiv:1308.3432, 2013.   
+G Brockman, V Cheung, L Pettersson, J Schneider, J Schulman, J Tang, W Zaremba. Openai Gym, 2016.   
+J Buckman, D Hafner, G Tucker, E Brevdo, H Lee. Sample-Efficient Reinforcement Learning With Stochastic Ensemble Value Expansion. Advances in Neural Information Processing Systems, 2018.   
+L Buesing, T Weber, S Racaniere, S Eslami, D Rezende, DP Reichert, F Viola, F Besse, K Gregor, D Hassabis, et al. Learning and Querying Fast Generative Models for Reinforcement Learning. ArXiv Preprint ArXiv:1802.03006, 2018.   
+A Byravan, JT Springenberg, A Abdolmaleki, R Hafner, M Neunert, T Lampe, N Siegel, N Heess, M Riedmiller. Imagined Value Gradients: Model-Based Policy Optimization With Transferable Latent Dynamics Models. ArXiv Preprint ArXiv:1910.04142, 2019.   
+PS Castro, S Moitra, C Gelada, S Kumar, MG Bellemare. Dopamine: A Research Framework for Deep Reinforcement Learning. ArXiv Preprint ArXiv:1812.06110, 2018.   
+T Chen, S Kornblith, M Norouzi, G Hinton. A Simple Framework for Contrastive Learning of Visual Representations. ArXiv Preprint ArXiv:2002.05709, 2020.   
+S Chiappa, S Racaniere, D Wierstra, S Mohamed. Recurrent Environment Simulators. ArXiv Preprint ArXiv:1704.02254, 2017.   
+K Cho, B Van Merriënboer, C Gulcehre, D Bahdanau, F Bougares, H Schwenk, Y Bengio. Learning Phrase Representations Using Rnn Encoder-Decoder for Statistical Machine Translation. ArXiv Preprint ArXiv:1406.1078, 2014.   
+K Chua, R Calandra, R McAllister, S Levine. Deep Reinforcement Learning in a Handful of Trials Using Probabilistic Dynamics Models. Advances in Neural Information Processing Systems, 2018.   
+DA Clevert, T Unterthiner, S Hochreiter. Fast and Accurate Deep Network Learning by Exponential Linear Units (Elus). ArXiv Preprint ArXiv:1511.07289, 2015.   
+R Coulom. Efficient Selectivity and Backup Operators in Monte-Carlo Tree Search. International Conference on Computers and Games. Springer, 2006.   
+W Dabney, M Rowland, MG Bellemare, R Munos. Distributional Reinforcement Learning With Quantile Regression. ArXiv Preprint ArXiv:1710.10044, 2017.   
+W Dabney, G Ostrovski, D Silver, R Munos. Implicit Quantile Networks for Distributional Reinforcement Learning. ArXiv Preprint ArXiv:1806.06923, 2018.   
+E Denton R Fergus. Stochastic Video Generation With a Learned Prior. ArXiv Preprint ArXiv:1802.07687, 2018.   
+A Doerr, C Daniel, M Schiegg, D Nguyen-Tuong, S Schaal, M Toussaint, S Trimpe. Probabilistic Recurrent State-Space Models. ArXiv Preprint ArXiv:1801.10395, 2018.   
+F Ebert, C Finn, AX Lee, S Levine. Self-Supervised Visual Planning With Temporal Skip Connections. ArXiv Preprint ArXiv:1710.05268, 2017.   
+M Fortunato, MG Azar, B Piot, J Menick, I Osband, A Graves, V Mnih, R Munos, D Hassabis, O Pietquin, et al. Noisy Networks for Exploration. ArXiv Preprint ArXiv:1706.10295, 2017.   
+Y Gal, R McAllister, CE Rasmussen. Improving Pilco With Bayesian Neural Network Dynamics Models. Data-Efficient Machine Learning Workshop, ICML, 2016.   
+M Gemici, CC Hung, A Santoro, G Wayne, S Mohamed, DJ Rezende, D Amos, T Lillicrap. Generative Temporal Models With Memory. ArXiv Preprint ArXiv:1702.04649, 2017.   
+K Gregor F Besse. Temporal Difference Variational Auto-Encoder. ArXiv Preprint ArXiv:1806.03107, 2018.   
+JB Grill, F Strub, F Altché, C Tallec, PH Richemond, E Buchatskaya, C Doersch, BA Pires, ZD Guo, MG Azar, et al. Bootstrap Your Own Latent: A New Approach to Self-Supervised Learning. ArXiv Preprint ArXiv:2006.07733, 2020.   
+A Gruslys, W Dabney, MG Azar, B Piot, M Bellemare, R Munos. The Reactor: A Fast and SampleEfficient Actor-Critic Agent for Reinforcement Learning. ArXiv Preprint ArXiv:1704.04651, 2017.   
+D Ha J Schmidhuber. World Models. ArXiv Preprint ArXiv:1803.10122, 2018.   
+D Hafner, T Lillicrap, I Fischer, R Villegas, D Ha, H Lee, J Davidson. Learning Latent Dynamics for Planning From Pixels. ArXiv Preprint ArXiv:1811.04551, 2018.   
+D Hafner, T Lillicrap, J Ba, M Norouzi. Dream to Control: Learning Behaviors by Latent Imagination. ArXiv Preprint ArXiv:1912.01603, 2019.   
+K He, H Fan, Y Wu, S Xie, R Girshick. Momentum Contrast for Unsupervised Visual Representation Learning. Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, 2020.   
+M Henaff, WF Whitney, Y LeCun. Model-Based Planning With Discrete and Continuous Actions. ArXiv Preprint ArXiv:1705.07177, 2018.   
+M Hessel, J Modayil, H Van Hasselt, T Schaul, G Ostrovski, W Dabney, D Horgan, B Piot, M Azar, D Silver. Rainbow: Combining Improvements in Deep Reinforcement Learning. Thirty-Second AAAI Conference on Artificial Intelligence, 2018.   
+I Higgins, L Matthey, A Pal, C Burgess, X Glorot, M Botvinick, S Mohamed, A Lerchner. BetaVae: Learning Basic Visual Concepts With a Constrained Variational Framework. International Conference on Learning Representations, 2016.   
+JCG Higuera, D Meger, G Dudek. Synthesizing Neural Network Controllers With Probabilistic Model Based Reinforcement Learning. ArXiv Preprint ArXiv:1803.02291, 2018.   
+D Horgan, J Quan, D Budden, G Barth-Maron, M Hessel, H Van Hasselt, D Silver. Distributed Prioritized Experience Replay. ArXiv Preprint ArXiv:1803.00933, 2018.   
+M Igl, L Zintgraf, TA Le, F Wood, S Whiteson. Deep Variational Reinforcement Learning for Pomdps. ArXiv Preprint ArXiv:1806.02426, 2018.   
+L Kaiser, M Babaeizadeh, P Milos, B Osinski, RH Campbell, K Czechowski, D Erhan, C Finn, P Kozakowski, S Levine, et al. Model-Based Reinforcement Learning for Atari. ArXiv Preprint ArXiv:1903.00374, 2019.   
+G Kalweit J Boedecker. Uncertainty-Driven Imagination for Continuous Deep Reinforcement Learning. Conference on Robot Learning, 2017.   
+S Kapturowski, G Ostrovski, J Quan, R Munos, W Dabney. Recurrent Experience Replay in Distributed Reinforcement Learning. International Conference on Learning Representations, 2018.   
+M Karl, M Soelch, J Bayer, P van der Smagt. Deep Variational Bayes Filters: Unsupervised Learning of State Space Models From Raw Data. ArXiv Preprint ArXiv:1605.06432, 2016.   
+DP Kingma J Ba. Adam: A Method for Stochastic Optimization. ArXiv Preprint ArXiv:1412.6980, 2014.   
+DP Kingma M Welling. Auto-Encoding Variational Bayes. ArXiv Preprint ArXiv:1312.6114, 2013.   
+I Kostrikov, D Yarats, R Fergus. Image Augmentation Is All You Need: Regularizing Deep Reinforcement Learning From Pixels. ArXiv Preprint ArXiv:2004.13649, 2020.   
+RG Krishnan, U Shalit, D Sontag. Deep Kalman Filters. ArXiv Preprint ArXiv:1511.05121, 2015.   
+T Kurutach, I Clavera, Y Duan, A Tamar, P Abbeel. Model-Ensemble Trust-Region Policy Optimization. ArXiv Preprint ArXiv:1802.10592, 2018.   
+Y LeCun, B Boser, JS Denker, D Henderson, RE Howard, W Hubbard, LD Jackel. Backpropagation Applied to Handwritten Zip Code Recognition. Neural Computation, 1(4), 1989.   
+AX Lee, A Nagabandi, P Abbeel, S Levine. Stochastic Latent Actor-Critic: Deep Reinforcement Learning With a Latent Variable Model. ArXiv Preprint ArXiv:1907.00953, 2019.   
+MC Machado, MG Bellemare, E Talvitie, J Veness, M Hausknecht, M Bowling. Revisiting the Arcade Learning Environment: Evaluation Protocols and Open Problems for General Agents. Journal of Artificial Intelligence Research, 61, 2018.   
+V Mnih, K Kavukcuoglu, D Silver, AA Rusu, J Veness, MG Bellemare, A Graves, M Riedmiller, AK Fidjeland, G Ostrovski, et al. Human-Level Control Through Deep Reinforcement Learning. Nature, 518(7540), 2015.   
+V Mnih, AP Badia, M Mirza, A Graves, T Lillicrap, T Harley, D Silver, K Kavukcuoglu. Asynchronous Methods for Deep Reinforcement Learning. International Conference on Machine Learning, 2016.   
+A Nagabandi, G Kahn, RS Fearing, S Levine. Neural Network Dynamics for Model-Based Deep Reinforcement Learning With Model-Free Fine-Tuning. ArXiv Preprint ArXiv:1708.02596, 2017.   
+J Oh, X Guo, H Lee, RL Lewis, S Singh. Action-Conditional Video Prediction Using Deep Networks in Atari Games. Advances in Neural Information Processing Systems, 2015.   
+J Oh, S Singh, H Lee. Value Prediction Network. Advances in Neural Information Processing Systems, 2017.   
+P Parmas, CE Rasmussen, J Peters, K Doya. Pipps: Flexible Model-Based Policy Search Robust to the Curse of Chaos. ArXiv Preprint ArXiv:1902.01240, 2019.   
+D Pathak, P Agrawal, AA Efros, T Darrell. Curiosity-Driven Exploration by Self-Supervised Prediction. Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition Workshops, 2017.   
+DJ Rezende, S Mohamed, D Wierstra. Stochastic Backpropagation and Approximate Inference in Deep Generative Models. ArXiv Preprint ArXiv:1401.4082, 2014.   
+S Risi KO Stanley. Deep Neuroevolution of Recurrent and Discrete World Models. Proceedings of the Genetic and Evolutionary Computation Conference, 2019.   
+T Schaul, J Quan, I Antonoglou, D Silver. Prioritized Experience Replay. ArXiv Preprint ArXiv:1511.05952, 2015.   
+J Schrittwieser, I Antonoglou, T Hubert, K Simonyan, L Sifre, S Schmitt, A Guez, E Lockhart, D Hassabis, T Graepel, et al. Mastering Atari, Go, Chess and Shogi by Planning With a Learned Model. ArXiv Preprint ArXiv:1911.08265, 2019.   
+J Schulman, P Moritz, S Levine, M Jordan, P Abbeel. High-Dimensional Continuous Control Using Generalized Advantage Estimation. ArXiv Preprint ArXiv:1506.02438, 2015.   
+J Schulman, F Wolski, P Dhariwal, A Radford, O Klimov. Proximal Policy Optimization Algorithms. ArXiv Preprint ArXiv:1707.06347, 2017a.   
+J Schulman, F Wolski, P Dhariwal, A Radford, O Klimov. Proximal Policy Optimization Algorithms. ArXiv Preprint ArXiv:1707.06347, 2017b.   
+R Sekar, O Rybkin, K Daniilidis, P Abbeel, D Hafner, D Pathak. Planning to Explore via SelfSupervised World Models. ArXiv Preprint ArXiv:2005.05960, 2020.   
+D Silver, J Schrittwieser, K Simonyan, I Antonoglou, A Huang, A Guez, T Hubert, L Baker, M Lai, A Bolton, et al. Mastering the Game of Go Without Human Knowledge. Nature, 550(7676), 2017.   
+A Srinivas, A Jabri, P Abbeel, S Levine, C Finn. Universal Planning Networks. ArXiv Preprint ArXiv:1804.00645, 2018.   
+A Srinivas, M Laskin, P Abbeel. Curl: Contrastive Unsupervised Representations for Reinforcement Learning. ArXiv Preprint ArXiv:2004.04136, 2020.   
+RS Sutton. Dyna, an Integrated Architecture for Learning, Planning, and Reacting. ACM SIGART Bulletin, 2(4), 1991.   
+RS Sutton AG Barto. Reinforcement Learning: An Introduction. MIT press, 2018.   
+AA Taiga, W Fedus, MC Machado, A Courville, MG Bellemare. On Bonus Based Exploration Methods in the Arcade Learning Environment. International Conference on Learning Representations, 2019.   
+M Toromanoff, E Wirbel, F Moutarde. Is Deep Reinforcement Learning Really Superhuman on Atari? Leveling the Playing Field. ArXiv Preprint ArXiv:1908.04683, 2019.   
+H Van Hasselt, A Guez, D Silver. Deep Reinforcement Learning With Double Q-Learning. ArXiv Preprint ArXiv:1509.06461, 2015.   
+T Wang J Ba. Exploring Model-Based Planning With Policy Networks. ArXiv Preprint ArXiv:1906.08649, 2019.   
+T Wang, X Bao, I Clavera, J Hoang, Y Wen, E Langlois, S Zhang, G Zhang, P Abbeel, J Ba. Benchmarking Model-Based Reinforcement Learning. CoRR, abs/1907.02057, 2019.   
+Z Wang, T Schaul, M Hessel, H Hasselt, M Lanctot, N Freitas. Dueling Network Architectures for Deep Reinforcement Learning. International Conference on Machine Learning, 2016.   
+M Watter, J Springenberg, J Boedecker, M Riedmiller. Embed to Control: A Locally Linear Latent Dynamics Model for Control From Raw Images. Advances in Neural Information Processing Systems, 2015.   
+G Wayne, CC Hung, D Amos, M Mirza, A Ahuja, A Grabska-Barwinska, J Rae, P Mirowski, JZ Leibo, A Santoro, et al. Unsupervised Predictive Memory in a Goal-Directed Agent. ArXiv Preprint ArXiv:1803.10760, 2018.   
+T Weber, S Racanière, DP Reichert, L Buesing, A Guez, DJ Rezende, AP Badia, O Vinyals, N Heess, Y Li, et al. Imagination-Augmented Agents for Deep Reinforcement Learning. ArXiv Preprint ArXiv:1707.06203, 2017.   
+RJ Williams. Simple Statistical Gradient-Following Algorithms for Connectionist Reinforcement Learning. Machine Learning, 8(3-4), 1992.   
+Y Wu, E Mansimov, RB Grosse, S Liao, J Ba. Scalable Trust-Region Method for Deep Reinforcement Learning Using Kronecker-Factored Approximation. Advances in Neural Information Processing Systems, 2017.   
+T Yu, G Thomas, L Yu, S Ermon, J Zou, S Levine, C Finn, T Ma. Mopo: Model-Based Offline Policy Optimization. ArXiv Preprint ArXiv:2005.13239, 2020.   
+M Zhang, S Vikram, L Smith, P Abbeel, M Johnson, S Levine. Solar: Deep Structured Representations for Model-Based Reinforcement Learning. International Conference on Machine Learning, 2019.
+
+# A HUMANOID FROM PIXELS
+
+![](images/bc32d1cbcd0659936feccbe1b4b19ff3bdb8dc7b88387c80e5a755a3f2a1fc15.jpg)  
+Figure A1: Behavior learned by DreamerV2 on the Humanoid Walk task from pixel inputs only. The task is provided by the DeepMind Control Suite and uses a continuous action space with 21 dimensions. The frames show the agent inputs.
+
+While the main experiments of this paper focus on the Atari benchmark with discrete actions, DreamerV2 is also applicable to control tasks with continuous actions. For this, we the actor outputs a truncated normal distribution instead of a categorical distribution. To demonstrate the abilities of DreamerV2 for continuous control, we choose the challenging humanoid environment with only image inputs, shown in Figure A1. We find that for continuous control tasks, dynamics backpropagation substantially outperforms reinforce gradients and thus set $\rho = 0$ . We also set $\eta = 1 0 ^ { - 5 }$ and $\beta = 2$ and leave all other hyper parameters at their defaults. We find that DreamerV2 reliably solves both the stand-up motion required at the beginning of the episode and the subsequent walking. The score is shown in Figure A2. To the best of our knowledge, this constitutes the first published result of solving the humanoid environment from only pixel inputs.
+
+![](images/0bf2ee3035c8920e73f8c5b324d734387450736fe0a5b877d68595407b21dc56.jpg)  
+Figure A2: Performance on the humanoid walking task from only pixel inputs.
+
+# B MONTEZUMA’S REVENGE
+
+![](images/e6a13f2e99bee24ebd28c60df77a96ac2c6cf01412caa499f882c669a39921d6.jpg)  
+Figure B1: Behavior learned by DreamerV2 on the Atari game Montezuma’s Revenge, that poses a hard exploration challenge. Without any explicit exploration mechanism, DreamerV2 reaches about the same performance as the exploration method ICM.
+
+While our main experiments use the same hyper parameters across all tasks, we find that DreamerV2 achieves higher performance on Montezuma’s Revenge by using a lower discount factor of $\gamma = 0 . 9 9$ , possibly to stabilize value learning under sparse rewards. Figure B2 shows the resulting performance, with all other hyper parameters left at their defaults. DreamerV2 outperforms existing modelfree approaches on the hard-exploration game Montezuma’s Revenge and matches the performance of the explicit exploration algorithm ICM (Pathak et al., 2017) that was applied on top of Rainbow by Taiga et al. (2019). This suggests that the world model may help with solving sparse reward tasks, for example due to improved generalization, efficient policy optimization in the compact latent space enabling more actor critic updates, or because the reward predictor generalizes and thus smooths out the sparse rewards.
+
+![](images/05f3223a1030ab1e287d71467d39db47d9ec8b8c2405d903daa77293d658f380.jpg)  
+Figure B2: Performance on the Atari game Montezuma’s Revenge.
+
+# C SUMMARY OF MODIFICATIONS
+
+To develop DreamerV2, we used the Dreamer agent (Hafner et al., 2019) as a starting point. This subsection describes the changes that we applied to the agent to achieve high performance on the Atari benchmark, as well as the changes that were tried but not found to increase performance and thus were not not included in DreamerV2.
+
+Summary of changes that were tried and were found to help:
+
+• Categorical latents Using categorical latent states using straight-through gradients in the world model instead of Gaussian latents with reparameterized gradients. • KL balancing Separately scaling the prior cross entropy and the posterior entropy in the KL loss to encourage learning an accurate temporal prior, instead of using free nats. • Reinforce only Reinforce gradients worked substantially better for Atari than dynamics backpropagation. For continuous control, dynamics backpropagation worked substantially better. • Model size Increasing the number of units or feature maps per layer of all model components, resulting in a change from 13M parameters to 22M parameters. • Policy entropy Regularizing the policy entropy for exploration both in imagination and during data collection, instead of using external action noise during data collection.
+
+Summary of changes that were tried but were found to not help substantially:
+
+• Binary latents Using a larger number of binary latents for the world model instead of categorical latents, which could have encouraged a more disentangled representation, was worse. • Long-term entropy Including the policy entropy into temporal-difference loss of the value function, so that the actor seeks out states with high action entropy beyond the planning horizon. • Mixed actor gradients Combining Reinforce and dynamics backpropagation gradients for learning the actor instead of Reinforce provided marginal or no benefits. • Scheduling Scheduling the learning rates, KL scale, actor entropy loss scale, and actor gradient mixing (from 0.1 to 0) provided marginal or no benefits. • Layer norm Using layer normalization in the GRU that is used as part of the RSSM latent transition model, instead of no normalization, provided no or marginal benefits.
+
+Due to the large computational requirements, a comprehensive ablation study on this list of all changes is unfortunately infeasible for us. This would require 55 tasks times 5 seeds for 10 days per change to run, resulting in over 60,000 GPU hours per change. However, we include ablations for the most important design choices in the main text of the paper.
+
+# D HYPER PARAMETERS
+
+<table><tr><td>Name</td><td>Symbol</td><td>Value</td></tr><tr><td>World Model</td><td></td><td></td></tr><tr><td>Dataset size (FIFO)</td><td></td><td>2·106</td></tr><tr><td>Batch size</td><td>B</td><td>50</td></tr><tr><td>Sequence length</td><td>L</td><td>50</td></tr><tr><td>Discrete latent dimensions</td><td>一</td><td>32</td></tr><tr><td>Discrete latent classes</td><td></td><td>32</td></tr><tr><td>RSSM number of units</td><td></td><td>600</td></tr><tr><td>KL loss scale</td><td>β</td><td>0.1</td></tr><tr><td>KL balancing</td><td>α</td><td>0.8</td></tr><tr><td>World model learning rate</td><td></td><td>2·10-4</td></tr><tr><td>Reward transformation</td><td></td><td>tanh</td></tr><tr><td>Behavior</td><td></td><td></td></tr><tr><td>Imagination horizon</td><td>H</td><td>15</td></tr><tr><td>Discount</td><td>Y</td><td>0.995</td></tr><tr><td>X-target parameter</td><td>入</td><td>0.95</td></tr><tr><td>Actor gradient mixing</td><td>p</td><td>1</td></tr><tr><td>Actor entropy loss scale</td><td>m</td><td>1.10-3</td></tr><tr><td>Actor learning rate</td><td>一</td><td>4·10-5</td></tr><tr><td>Critic learning rate</td><td></td><td>1·10-4</td></tr><tr><td>Slow critic update interval</td><td></td><td>100</td></tr><tr><td>Common</td><td></td><td></td></tr><tr><td>Environment steps per update</td><td></td><td>4</td></tr><tr><td>MPL number of layers</td><td></td><td>4</td></tr><tr><td>MPL number of units</td><td></td><td>400</td></tr><tr><td>Gradient clipping</td><td></td><td>100</td></tr><tr><td>Adam epsilon</td><td>E</td><td>10-5</td></tr><tr><td>Weight decay (decoupled)</td><td></td><td>10-6</td></tr></table>
+
+Table D1: Atari hyper parameters of DreamerV2. When tuning the agent for a new task, we recommend searching over the KL loss scale $\beta \in \{ 0 . 1 , 0 . 3 , 1 , 3 \bar { \} }$ , actor entropy loss scale $\eta \in$ $\{ 3 \cdot 1 0 ^ { - 5 } , 1 0 ^ { - 4 } , 3 \cdot 1 \bar { 0 } ^ { - 4 } , 1 0 ^ { - 3 } \}$ , and the discount factor $\gamma \in \{ 0 . 9 9 , 0 . 9 9 9 \}$ . The training frequency update should be increased when aiming for higher data-efficiency.
+
+# E AGENT COMPARISON
+
+![](images/fc3b8c73568e1a7b086627d9746bcee5500174bcddb9315ffd7b96af68036171.jpg)  
+Figure E1: Atari agent comparison. The bars show the difference in gamer normalized scores at 200M steps. DreamerV2 outperforms the four model-free algorithms IQN, Rainbow, C51, and DQN while learning behaviors purely by planning within a separately learned world model. DreamerV2 achieves higher or similar performance on all tasks besides Video Pinball, where we hypothesize that the reconstruction loss does not focus on the ball that makes up only one pixel on the screen.
+
+# F MODEL-FREE COMPARISON
+
+![](images/e679a24243b7da6f2e951a41ebdcb9aafeb1469e13576d463b51e9680d103e47.jpg)  
+Figure F1: Comparison of DreamerV2 to the top model-free RL methods IQN and Rainbow. The DreamerV2 IQN Rainbow curves show mean and standard deviation over 5 seeds. IQN and Rainbow additionally average each point over 10 evaluation episodes, explaining the smoother curves. DreamerV2 outperforms IQN and Rainbow in all four aggregated scores. While IQN and Rainbow tend to succeed on the same tasks, DreamerV2 shows a different performance profile.
+
+![](images/eed0b0ae6d2b45de124cd919bfef252716709e661c978099fe2cf5ce203c65cc.jpg)  
+DreamerV2 Gaussian Latents No KL Balance Figure G1: Comparison of DreamerV2, Gaussian instead of categorical latent variables, and no KL balancing. The ablation experiments use a slightly earlier version of the agent. The curves show mean and standard deviation across two seeds. Categorical latent variables and KL balancing both substantially improve performance across many of the tasks. The importance of the two techniques is reflected in all four aggregated scores.
+
+# H REPRESENTATION LEARNING ABLATIONS
+
+![](images/1716341150b25e3d0b368c8a1ec95ad4758b7b94ed3d6e5eb9dcaad4fd794463.jpg)  
+DreamerV2 No Reward Gradients No Image Gradients Figure H1: Comparison of leveraging image prediction, reward prediction, or both for learning the model representations. While image gradients are crucial, reward gradients are not necessary for our world model to succeed and their gradients can be stopped. Representations learned purely from images are not biased toward previously encountered rewards and outperform reward-specific representations on a number of tasks, suggesting that they may generalize better to unseen situations.
+
+# I POLICY LEARNING ABLATIONS
+
+![](images/41c9359f8f79627244b10d8837e0be1ccb1dad738025504462e1b0551c1d0e9e.jpg)  
+Figure I1: Comparison of leveraging Reinforce gradients, straight-through gradients, or both forDreamerV2 No Straight-Through No Reinforce training the actor. While Reinforce gradients are crucial, straight-through gradients are not important for most of the tasks. Nonetheless, combining both gradients yields substantial improvements on a small number of games, most notably on Seaquest. We conjecture that straight-through gradients have low variance and thus help the agent start learning, whereas Reinforce gradients are unbiased and help converging to a better solution.
+
+![](images/2570f9ee70cd656d96643d86b22e1451b02016d20928abc622b191d46f2bf382.jpg)  
+DreamerV2 No Layer Norm Random DataFigure J1: Comparison of DreamerV2 to a version without layer norm in the GRU and to training from experience collected over time by a uniform random policy. We find that the benefit of layer norm depends on the task at hand, increasing and decreasing performance on a roughly equal number of tasks. The comparison to random data collection highlights which of the tasks require non-trivial exploration, which can help guide future work on directed exploration using world models.
+
+K ATARI TASK SCORES   
+
+<table><tr><td rowspan="2"></td><td colspan="3">Baselines</td><td colspan="3"></td></tr><tr><td>Random</td><td>Gamer</td><td>Record</td><td>Rainbow</td><td>Algorithms IQN</td><td>DreamerV2</td></tr><tr><td>Task</td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>Alien</td><td>229 6</td><td>7128 1720</td><td>251916 104159</td><td>3457 2529</td><td>4961 2393</td><td>3967 2577</td></tr><tr><td>Amidar</td><td></td><td></td><td></td><td>3229</td><td>4885</td><td>23625</td></tr><tr><td>Assault</td><td>222</td><td>742</td><td>8647</td><td></td><td></td><td></td></tr><tr><td>Asterix</td><td>210</td><td>8503</td><td>1000000</td><td>18367</td><td>10374</td><td>72311</td></tr><tr><td>Asteroids</td><td>719</td><td>47389 29028</td><td>10506650</td><td>1484</td><td>1585 890214</td><td>41526</td></tr><tr><td>Atlantis Bank Heist</td><td>12850</td><td>753</td><td>10604840 82058</td><td>802548 1075</td><td>1052</td><td>978778</td></tr><tr><td>Battle Zone</td><td>14</td><td>37188</td><td>801000</td><td></td><td>40953</td><td>1126</td></tr><tr><td>Beam Rider</td><td>2360 364</td><td>16926</td><td>999999</td><td>40061</td><td>7130</td><td>40325 18646</td></tr><tr><td>Berzerk</td><td></td><td>2630</td><td>1057940</td><td>6290</td><td>648</td><td></td></tr><tr><td>Bowling</td><td>124</td><td>161</td><td></td><td>833 43</td><td>39</td><td>810</td></tr><tr><td>Boxing</td><td>23</td><td>12</td><td>300</td><td>99</td><td></td><td>49</td></tr><tr><td>Breakout</td><td>0</td><td>30</td><td>100 864</td><td>120</td><td>98 79</td><td>92</td></tr><tr><td>Centipede</td><td>2</td><td>12017</td><td>1301709</td><td>6510</td><td>3728</td><td>312</td></tr><tr><td></td><td>2091</td><td>7388</td><td>999999</td><td>12338</td><td>9282</td><td>11883</td></tr><tr><td>Chopper Command</td><td>811</td><td>35829</td><td>219900</td><td>145389</td><td>132738</td><td>2861 161839</td></tr><tr><td>Crazy Climber Demon Attack</td><td>10780</td><td>1971</td><td>1556345</td><td>17071</td><td>15350</td><td>82263</td></tr><tr><td>Double Dunk</td><td>152</td><td>-16</td><td>22</td><td>22</td><td>21</td><td>17</td></tr><tr><td>Enduro</td><td>-19 0</td><td>860</td><td>9500</td><td>2200</td><td>2203</td><td>1656</td></tr><tr><td>Fishing Derby</td><td>-92</td><td>-39</td><td>71</td><td>42</td><td>45</td><td>65</td></tr><tr><td>Freeway</td><td>0</td><td>30</td><td>38</td><td>34</td><td>34</td><td>33</td></tr><tr><td>Frostbite</td><td>65</td><td>4335</td><td>454830</td><td>8208</td><td>7812</td><td>11384</td></tr><tr><td>Gopher</td><td>258</td><td>2412</td><td>355040</td><td>10641</td><td>12108</td><td>92282</td></tr><tr><td>Gravitar</td><td>173</td><td>3351</td><td>162850</td><td>1272</td><td>1347</td><td>3789</td></tr><tr><td>Hero</td><td>1027</td><td>30826</td><td>1000000</td><td>46675</td><td>36058</td><td>21868</td></tr><tr><td>Ice Hockey</td><td>-11</td><td></td><td>36</td><td>0</td><td>-5</td><td>26</td></tr><tr><td>James Bond</td><td>7</td><td>29</td><td>45550</td><td>1097</td><td>3166</td><td>40445</td></tr><tr><td>Kangaroo</td><td>52</td><td>3035</td><td>1424600</td><td>12748</td><td>12602</td><td>14064</td></tr><tr><td>Krull</td><td>1598</td><td>2666</td><td>104100</td><td>4066</td><td>8844</td><td>50061</td></tr><tr><td>Kung Fu Master</td><td>258</td><td>22736</td><td>1000000</td><td>26475</td><td>31653</td><td>62741</td></tr><tr><td>Montezuma Revenge</td><td>0</td><td>4753</td><td>1219200</td><td>500</td><td>500</td><td>81</td></tr><tr><td>Ms Pacman</td><td>307</td><td>6952</td><td>290090</td><td>3861</td><td>5218</td><td>5652</td></tr><tr><td>Name This Game</td><td>2292</td><td>8049</td><td>25220</td><td>9026</td><td>6639</td><td>14649</td></tr><tr><td>Phoenix</td><td>761</td><td>7243</td><td>4014440</td><td>8545</td><td>5102</td><td>49375</td></tr><tr><td>Pitfall</td><td>-229</td><td>6464</td><td>114000</td><td>-20</td><td>-13</td><td>0</td></tr><tr><td>Pong</td><td>-21</td><td>15</td><td>21</td><td>20</td><td>20</td><td>20</td></tr><tr><td>Private Eye</td><td>25</td><td>69571</td><td>101800</td><td>21334</td><td>4181</td><td>2198</td></tr><tr><td>Qbert</td><td>164</td><td>13455</td><td>2400000</td><td>17383</td><td>16730</td><td>94688</td></tr><tr><td>Riverraid</td><td>1338</td><td>17118</td><td>1000000</td><td>20756</td><td>15183</td><td>16351</td></tr><tr><td>Road Runner</td><td></td><td>7845</td><td>2038100</td><td>54662</td><td>58966</td><td>203576</td></tr><tr><td>Robotank</td><td>12</td><td></td><td>76</td><td></td><td>66</td><td>78</td></tr><tr><td>Seaquest</td><td>2 68</td><td>12 42055</td><td></td><td>66 9903</td><td>17039</td><td>7480</td></tr><tr><td>Skiing</td><td>-17098</td><td>-4337</td><td>999999 -3272</td><td>-28708</td><td>-11162</td><td>-9299</td></tr><tr><td>Solaris</td><td>1236</td><td></td><td></td><td></td><td>1684</td><td>922</td></tr><tr><td></td><td></td><td>12327</td><td>111420</td><td>1583</td><td></td><td></td></tr><tr><td>Space Invaders</td><td>148</td><td>1669</td><td>621535</td><td>4131</td><td>4530</td><td>2474</td></tr><tr><td>Star Gunner</td><td>664</td><td>10250</td><td>77400</td><td>57909</td><td>80003</td><td>7800</td></tr><tr><td>Tennis</td><td>-24</td><td>-8</td><td>21</td><td>0</td><td>23</td><td>14</td></tr><tr><td>Time Pilot</td><td>3568</td><td>5229</td><td>65300</td><td>12051</td><td>11666</td><td>37945</td></tr><tr><td>Tutankham</td><td>11</td><td>168</td><td>5384</td><td>239</td><td>251</td><td>264</td></tr><tr><td>Up N Down</td><td>533</td><td>11693</td><td>82840</td><td>34888</td><td>59944</td><td>653662</td></tr><tr><td>Venture</td><td>0</td><td>1188</td><td>38900</td><td>1529</td><td>1313</td><td>2</td></tr><tr><td>Video Pinball Wizard Of Wor</td><td>16257 564</td><td>17668 4756</td><td>89218328 395300</td><td>466895 7879</td><td>415833 5671</td><td>41860 12851</td></table>
+
+Table K1: Atari individual scores. We select the 55 games that are common among most papers in the literature. We compare the algorithms DreamerV2, IQN, and Rainbow to the baselines of random actions, DeepMind’s human gamer, and the human world record. Algorithm scores are highlighted in bold when they fall within $5 \%$ of the best algorithm. Note that these scores are already averaged across seeds, whereas any aggregated scores must be computed before averaging across seeds.

parse/train/BBIbj9w8Lvj8F/BBIbj9w8Lvj8F.md

@@ -0,0 +1,198 @@
+# Efficient Learning of Domain-invariant Image Representations
+
+Judy Hoffman UCB EECS & ICSI jhoffman@eecs.berkeley.edu
+
+Erik Rodner UCB EECS & ICSI erik.rodner@gmail.com
+
+Jeff Donahue UCB EECS & ICSI jdonahue@eecs.berkeley.edu
+
+Trevor Darrell UCB EECS & ICSI trevor@eecs.berkeley.edu
+
+Kate Saenko University of Massachusetts, Lowell saenko@cs.uml.edu
+
+# Abstract
+
+We present an algorithm that learns representations which explicitly compensate for domain mismatch and which can be efficiently realized as linear classifiers. Specifically, we form a linear transformation that maps features from the target (test) domain to the source (training) domain as part of training the classifier. We optimize both the transformation and classifier parameters jointly, and introduce an efficient cost function based on misclassification loss. Our method combines several features previously unavailable in a single algorithm: multi-class adaptation through representation learning, ability to map across heterogeneous feature spaces, and scalability to large datasets. We present experiments on several image datasets that demonstrate improved accuracy and computational advantages compared to previous approaches.
+
+# 1 Introduction
+
+We address the problem of learning domain-invariant image representations for multi-class classifiers. The ideal image representation often depends not just on the task but also on the domain. Recent studies have demonstrated a significant degradation in the performance of state-of-the-art image classifiers when input feature distributions change due to different image sensors and noise conditions [1], pose changes [2], a shift from commercial to consumer video [3, 4], and, more generally, training datasets biased by the way in which they were collected [5]. Learning adaptive representations for linear classifiers is particularly interesting as they are efficient and prevalent in vision applications, with fast linear SVMs forming the core of some of the most popular object detection methods [6, 7].
+
+Previous work proposed to adapt linear SVMs [8, 9, 10], learning a perturbation of the source hyperplane by minimizing the classification error on labeled target examples for each binary task. These perturbations can be thought of as new feature representations that correct for the domain change. The recent HFA method [11] learns both the perturbed classifier and a latent domain-invariant feature representation, allowing domains to have heterogeneous features with different dimensionalities. However, existing SVM-based methods are limited to learning a separate representation for each binary problem and cannot transfer a common, class-independent component of the shift (such as global lighting change) to unlabeled categories, as illustrated in Figure 1. Additionally, the HFA algorithm cannot be solved in linear space and therefore scales poorly to large datasets.
+
+![](images/fbb65d7b613e8da86d648bbe90f75335c1f72c297d368a695cf4601c719c82c1.jpg)  
+Figure 1: (a) Linear classifiers (shown as decision boundaries) learned for a four-class problem on a fully labeled source domain. (b) Problem: classifiers learned on the source domain do not fit the target domain points shown here due to a change in feature distribution. (c) Existing SVM-based methods only adapt the features of classes with labels (crosses and triangles). (d) Our method adapts all points, including those from classes without labels, by transforming all target features to a new domain-invariant representation.
+
+Recently proposed feature adaptation methods [1, 2, 12, 13, 14, 15] offer a solution by learning a category-independent feature transform that maps target features into the source, pooling all training labels across categories. This enables multi-class adaptation, i.e. transferring the categoryindependent component of the domain-invariant representation to unlabeled categories. For example, a map learned on the labeled “triangle” class in Figure 1 can also be used to map the unlabeled “star” class to the source domain. An additional advantage of the asymmetric transform method ARC-t [12] over metric learning [1] or the recently proposed Geodesic Flow Kernel (GFK) [15], is that, like HFA [11], ARC-t can map between heterogeneous feature spaces. However, ARC-t has two major limitations: First, the feature learning does not optimize the objective function of a strong, discriminative classifier directly; rather, it maximizes some notion of similarity between the transformed target points and points in the source. Second, it does not scale well to domains with large numbers of points due to the high number of constraints, which is proportional to the product of the number of labeled data points in the source and target.
+
+In this paper, we present a novel technique that combines the desirable aspects of recent methods in a single algorithm, which we call Max-Margin Domain Transforms, or MMDT for short. MMDT uses an asymmetric (non-square) transform $W$ to map target features $x$ to a new representation $W x$ maximally aligned with the source, learning the transform jointly on all categories for which target labels are available (Figure 1(d)). MMDT provides a way to adapt max-margin classifiers in a multi-class manner, by learning a shared component of the domain shift as captured by the feature transformation $W$ . Additionally, MMDT can be optimized quickly in linear space, making it a feasible solution for problem settings with a large amount of training data.
+
+The key idea behind our approach is to simultaneously learn both the projection of the target features into the source domain and the classifier parameters themselves, using the same classification loss to jointly optimize both.
+
+Thus our method learns a feature representation that combines the strengths of max-margin learning with the flexibility of the feature transform. Because it operates over the input features, it can generalize the learned shift in a way that parameter-based methods cannot. On the other hand, it overcomes the two flaws of the ARC-t method: by optimizing the classification loss directly in the transform learning framework, it can achieve higher accuracy; furthermore, replacing similarity constraints with more efficient hyperplane constraints significantly reduces the training time of the algorithm and learning a transformation directly from target to source allows optimization in linear space.
+
+The main contributions of our paper can be summarized as follows (also see Table 1):
+
+• Experiments show that MMDT in linear feature space outperforms competing methods in terms of multi-class accuracy even compared to previous kernelized methods. • MMDT learns a representation via an asymmetric category independent transform. Therefore, it can adapt features even when the target domain does not have any labeled examples for some categories and when the target and source features are not equivalent.
+
+<table><tr><td></td><td>ARC-t [12]</td><td>HFA[11]</td><td>GFK[15]</td><td>MMDT (ours)</td></tr><tr><td>multi-class</td><td>yes</td><td>no</td><td>yes</td><td>yes</td></tr><tr><td>large datasets</td><td>no</td><td>no</td><td>yes</td><td>yes</td></tr><tr><td>heterogeneous features</td><td>yes</td><td>yes</td><td>no</td><td>yes</td></tr><tr><td>optimize max-margin objective</td><td>no</td><td>yes</td><td>no</td><td>yes</td></tr></table>
+
+Table 1: Unlike previous methods, our approach is able to simultaneously learn muti-class representations that can transfer to novel classes, scale to large training datasets, and handle different feature dimensionalities.
+
+• The optimization of MMDT is scalable to large datasets because the number of constraints to optimize is linear in the number of training data points and because it can be optimized in linear feature space.
+
+• Our final iterative solution can be solved using standard QP packages, making MMDT easy to implement.
+
+# 2 Related Work
+
+Domain adaptation, or covariate shift, is a fundamental problem in machine learning, and has attracted a lot of attention in the machine learning and natural language community, e.g. [16, 17, 18, 19] (see [20] for a comprehensive overview). It is related to multi-task learning but differs from it in the following way: in domain adaptation problems, the distribution over the features $\mathrm { p } ( X )$ varies across domains while the output labels $Y$ remain the same; in multi-task learning or knowledge transfer, $\mathrm { p } ( X )$ stays the same (single domain) while the output labels vary (see [20] for more details). In this paper, we perform multi-task learning across domains, i.e. both $\mathrm { p } ( X )$ and the output labels $Y$ can change between domains.
+
+Domain adaptation has been gaining considerable attention in the vision community. Several SVMbased approaches have been proposed for image domain adaptation, including: weighted combination of source and target SVMs and transductive SVMs applied to adaptation in [21]; the feature replication method of [17]; Adaptive SVM [8, 9], where the source model parameters are adapted by adding a perturbation function, and its successor PMT-SVM [10]; Domain Transfer SVM [3], which learns a target decision function while reducing the mismatch in the domain distributions; and a related method [4] based on multiple kernel learning. In the linear case, feature replication [17] can be shown to decompose the learned parameter into $\theta = \widehat { \theta } + \theta ^ { \prime }$ , where $\hat { \theta }$ is shared by all domains [22], in a similar fashion to adaptive SVMs.
+
+Several authors considered learning feature representations for unsupervised and transfer learning [23], and for domain adaptation [18, 24]. For visual domain adaptation, transform-based adaptation methods [1, 12, 13, 2, 14, 11] have recently been proposed. These methods attempt to learn a perturbation over the feature space rather than a class-specific perturbation over the model parameters, typically in the form of a transformation matrix/kernel. The most closely related are the ARC-t method [12], which learns a transformation that maximizes similarity constraints between points in the source and those projected from the target domain, and the recent HFA method [11], which learns a transformation both from the source and target into a common latent space, as well as the classifier parameters. Another related method is the recently proposed GFK [15], which computes a symmetric kernel between source and target points based on geodesic flow along a latent manifold. We will present a detailed comparison to these three methods in the next section.
+
+# 3 Max-Margin Domain Transforms
+
+We propose a novel method for multi-task domain adaptation of linear SVMs by learning a target feature representation. Denote the normal to the affine hyperplane associated with the $k$ ’th binary SVM as $\theta _ { k }$ , $k = 1 , . . . , K$ , and the offset of that hyperplane from the origin as $b _ { k }$ . Intuitively, we would like to learn a new target feature representation that is shared across multiple categories. transformation W T of the source hyperplane parameters θk. Let xs1, . . . , xsnS of the input features, or, equivalently, a denote the training points in the source domain $( \mathcal { D } _ { S } )$ , with labels $y _ { 1 } ^ { s } , \ldots , y _ { n _ { S } } ^ { s }$ . Let $x _ { 1 } ^ { t } , \ldots , x _ { n _ { T } } ^ { t }$ denote the labeled points in the target domain $( \mathcal { D } _ { T } )$ , with labels $y _ { 1 } ^ { t } , \ldots , y _ { n _ { T } } ^ { t }$ . Thus our goal is to jointly learn 1) affine hyperplanes that separate the classes in the common domain consisting of the source domain and target points projected to the source and 2) the new feature representation of the target domain determined by the transformation $W$ mapping points from the target domain into the source domain. The transformation should have the property that it projects the target points onto the correct side of each source hyperplane.
+
+For simplicity of presentation, we first show the optimization problem for a binary problem (dropping $k$ ) with no slack variables. Our objective is as follows:
+
+$$
+\begin{array} { r l } { \underset { W , \theta , b } { \mathrm { m i n } } \quad } & { \frac { 1 } { 2 } | | W | | _ { F } ^ { 2 } + \frac { 1 } { 2 } | | \theta | | _ { 2 } ^ { 2 } } \\ { \mathrm { s . t . } \quad } & { y _ { i } ^ { s } \left( \left[ x _ { 1 } ^ { s } \right] ^ { T } \left[ \theta \right] \right) \geq 1 \quad \quad \forall i \in \mathcal { D } _ { S } } \\ & { y _ { i } ^ { t } \left( \left[ x _ { 1 } ^ { t } \right] ^ { T } W ^ { T } \left[ \theta \right] \right) \geq 1 \quad \forall i \in \mathcal { D } _ { T } } \end{array}
+$$
+
+Note that this can be easily extended to the multi-class case by simply adding a sum over the regularizers on all $\theta _ { k }$ parameters and pooling the constraints for all categories. The objective function, written as in Equations (1)-(3), is not a convex problem and so is both hard to optimize and is not guaranteed to have a global solution. Therefore, a standard way to solve this problem is to do alternating minimization on the parameters, in our case $W$ and $( \theta , b )$ . We can effectively do this because when each parameter vector is fixed, the resulting optimization problem is convex.
+
+We begin by re-writing Equations (1)-(3) for the more general problem with soft constraints and $K$ categories. Let us denote the hinge loss as: $\mathcal { L } ( y , x , \theta ) \overset { \cdot } { = } \operatorname* { m a x } \{ 0 , 1 - \delta ( y , k ) \cdot x ^ { T } \theta \}$ . We define a cost function
+
+$$
+\begin{array} { l c l } { { { \cal J } ( W , \theta _ { k } , b _ { k } ) } } & { { = } } & { { \displaystyle { \frac { 1 } { 2 } | | W | | _ { F } ^ { 2 } + \sum _ { k = 1 } ^ { K } \left[ \frac { 1 } { 2 } | | \theta _ { k } | | _ { 2 } ^ { 2 } \right. } } } \\ { { } } & { { } } & { { \displaystyle { \left. + C _ { S } \sum _ { i = 1 } ^ { n _ { S } } { \mathcal { L } \left( y _ { i } ^ { s } , \left[ \boldsymbol { \boldsymbol { \chi } } _ { i } ^ { s } \right] { } , \left[ \boldsymbol { \theta } _ { k } \right] { } \right) } + C _ { T } \sum _ { i = 1 } ^ { n _ { T } } { \mathcal { L } \left( y _ { i } ^ { t } , W \cdot \left[ \boldsymbol { \chi } _ { i } ^ { t } \right] , \left[ \boldsymbol { \theta } _ { k } \right] { } \right) } \right] } } } \end{array}
+$$
+
+where the constant $C _ { S }$ penalizes the source classification error and $C _ { T }$ penalizes the target adaptation error. Finally, we define our objective function with soft constraints as follows:
+
+$$
+\operatorname* { m i n } _ { W , \theta _ { k } , b _ { k } } J ( W , \theta _ { k } , b _ { k } )
+$$
+
+To solve the above optimization problem we perform coordinate descent on $W$ and $( \theta , b )$ .
+
+1. Set iteration $j = 0$ , $W ^ { ( j ) } = 0$ .
+
+2. Solve the sub-proble m (θ(j+1)k , b $\begin{array} { r } { ( \theta _ { k } ^ { ( j + 1 ) } , b _ { k } ^ { ( j + 1 ) } ) = \arg \operatorname* { m i n } _ { \theta _ { k } , b _ { k } } J ( W ^ { ( j ) } , \theta _ { k } , b _ { k } ) } \end{array}$
+
+$$
+\operatorname* { m i n } _ { \theta , b } \sum _ { k = 1 } ^ { K } \left[ \frac { 1 } { 2 } | | \theta _ { k } | | _ { 2 } ^ { 2 } + C _ { S } \sum _ { i = 1 } ^ { n _ { S } } \mathcal { L } \left( y _ { i } ^ { s } , \left[ \underline { { x } } _ { i } ^ { s } \right] , \left[ \underline { { \theta } } _ { k } ; \right] \right) + C _ { T } \sum _ { i = 1 } ^ { n _ { T } } \mathcal { L } \left( y _ { i } ^ { t } , W ^ { ( j ) } \cdot \left[ \underline { { x } } _ { i } ^ { t } \right] , \left[ \underline { { \theta } } _ { k } \right] \right) \right]
+$$
+
+Notice, this corresponds to the standard SVM objective function, except that the target points are first projected into the source using $W ^ { ( j ) }$ . Therefore, we can solve this intermediate problem using a standard SVM solver package.
+
+3. Solve the subproblem $W ^ { ( j + 1 ) } = \arg \operatorname* { m i n } _ { W } J ( W , \theta ^ { ( j + 1 ) } , b ^ { ( j + 1 ) } )$ by solving
+
+$$
+\operatorname* { m i n } _ { W } \qquad \frac { 1 } { 2 } | | W | | _ { F } ^ { 2 } + C _ { T } \sum _ { k = 1 } ^ { K } \sum _ { i = 1 } ^ { n _ { T } } \mathcal { L } \left( y _ { i } ^ { t } , W \cdot \left[ x _ { i } ^ { t } \right] , \left[ \theta _ { k } ^ { ( j + 1 ) } \right] \right)
+$$
+
+and increment $j$ . This optimization sub-problem is convex and is in a form that a standard QP optimization package can solve.
+
+4. Iterate steps 2 & 3 until convergence.
+
+It is straightforward to show that both stages (2) and (3) cannot increase the global cost function $J ( W , \theta , b )$ . Therefore, this algorithm is guaranteed to converge to a local optimum. A proof is included in the supplemental material.
+
+It is important to note that since both steps of our iterative algorithm can be solved using standard QP solvers, the algorithm can be easily implemented. Additionally, since the constraints in our algorithm grow linearly with the number of training points and it can be solved in linear feature space, the optimization can be solved efficiently even as the number of training points grows.
+
+Relation to existing work: We now analyze the proposed algorithm in the context of the previous feature transform methods ARC-t [12], HFA [11] and GFK [15]. ARC-t introduced similarity-based constraints to learn a mapping similar to that in step 3 in our algorithm. This approach creates a constraint for each labeled point $x _ { i } ^ { s }$ in the source and labeled point $\boldsymbol { x } _ { i } ^ { t }$ in the target, and then learns a transformation $W$ that satisfies constraints of the form $( x _ { i } ^ { s } ) ^ { T } W x _ { i } ^ { t } > u$ if the labels of $\boldsymbol { x } _ { i } ^ { s }$ and $\ v x _ { i } ^ { t }$ are the same, and $( x _ { i } ^ { s } ) ^ { T } W x _ { i } ^ { t } < l$ if the labels are different, for some constants $u , l$ .
+
+The ARC-t formulation has two distinct limitations that our method overcomes. First, it must solve $n _ { S } \cdot n _ { T }$ constraints, whereas our formulation only needs to solve $K \cdot n _ { T }$ constraints, for a $K$ category problem. In general, our method scales to much larger source domains than with ARC-t. The second benefit of our max-margin transformation learning approach is that the transformation learned using the max-margin constraints is learned jointly with the classifier, and explicitly seeks to optimize the final SVM classifier objective. While ARC-t’s similarity-based constraints seek to map points of the same category arbitrarily close to one another, followed by a separate classifier learning step, we seek simply to project the target points onto the correct side of the learned hyperplane, leading to better classification performance.
+
+The HFA formulation also takes advantage of the max-margin framework to directly optimize the classification objective while learning transformations. HFA learns the classifier and transformations to a common latent feature representation between the source and target. However, HFA is formulated to solve a binary problem so a new feature transformation must be learned for each category. Therefore, unlike MMDT, HFA cannot learn a representation that generalizes to novel target categories. Additionally, due to the difficulty of defining the dimension of the latent feature representation directly, the authors optimize with respect to a larger combined transformation matrix and a relaxed constraint. This transformation matrix becomes too large when the feature dimensions in source and target are large so the HFA must usually be solved in kernel space. This can make the method slow and cause it to scale poorly with the number of training examples. In contrast, our method can be efficiently solved in linear feature space which makes it fast and potentially more scalable.
+
+Finally, GFK [15] formulates a kernelized representation of the data that is equivalent to computing the dot product in infinitely many subspaces along the geodesic flow between the source and target domain subspaces. The kernel is defined by the authors to be symmetric and so can not handle source and target domains of different initial dimension. Additionally, GFK does not directly optimize a classification objective. In contrast, our method, MMDT, can handle source and target domains of different feature dimensions via an asymmetric $W$ , as well as directly optimizes the classification objective.
+
+# 4 Experiments on Image Datasets
+
+We now present experiments using the Office [1], Caltech256 [25] and Bing [21] datasets to evaluate our algorithm according to the following four criteria. 1) Using a subset of the Office and Caltech256 datasets we evaluate multi-class accuracy performance in a standard supervised domain adaptation setting, where all categories have a small number of labeled examples in the target. 2) Using the full Office dataset we evaluate multi-class accuracy for the supervised domain adaptation setting where the source and target have different feature dimensions. 3) Using the full Office dataset we evaluate multi-class accuracy in the multi-task domain adaptation setting with novel target categories at test time. 4) Using the Bing dataset we assess the ability to scale to larger datasets by analyzing timing performance.
+
+Table 2: Multi-class accuracy for the standard supervised domain adaptation setting: All results are from our implementation. When averaged across all domain shifts the reported average value for gfk was 51.65 while our implementation had an average of $5 1 . 0 \pm 0 . 7$ . Therefore, the result difference is within the standard deviation over data splits. Red indicates the best result for each domain split. Blue indicates the group of results that are close to the best performing result. The domain names are shortened for space: a: amazon, w: webcam, d: dslr, c: Caltech256   
+
+<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>svms</td><td rowspan=1 colspan=1>svmt</td><td rowspan=1 colspan=1>arct[12]</td><td rowspan=1 colspan=1>hfa[11]</td><td rowspan=1 colspan=1>gfk[15]</td><td rowspan=1 colspan=1>mmdt (ours)</td></tr><tr><td rowspan=1 colspan=1>a→w</td><td rowspan=1 colspan=1>33.9 ± 0.7</td><td rowspan=1 colspan=1>62.4 ± 0.9</td><td rowspan=1 colspan=1>55.7 ± 0.9</td><td rowspan=1 colspan=1>61.8 ± 1.1</td><td rowspan=1 colspan=1>58.6 ± 1.0</td><td rowspan=1 colspan=1>64.6 ± 1.2</td></tr><tr><td rowspan=1 colspan=1>a→d</td><td rowspan=1 colspan=1>35.0 ±0.8</td><td rowspan=1 colspan=1>55.9 ± 0.8</td><td rowspan=1 colspan=1>50.2 ± 0.7</td><td rowspan=1 colspan=1>52.7 ± 0.9</td><td rowspan=1 colspan=1>50.7 ±0.8</td><td rowspan=1 colspan=1>56.7 ± 1.3</td></tr><tr><td rowspan=1 colspan=1>w→a</td><td rowspan=1 colspan=1>35.7 ± 0.4</td><td rowspan=1 colspan=1>45.6± 0.7</td><td rowspan=1 colspan=1>43.4 ± 0.5</td><td rowspan=1 colspan=1>45.9 ± 0.7</td><td rowspan=1 colspan=1>44.1 ± 0.4</td><td rowspan=1 colspan=1>47.7 ± 0.9</td></tr><tr><td rowspan=1 colspan=1>w→d</td><td rowspan=1 colspan=1>66.6 ± 0.7</td><td rowspan=1 colspan=1>55.1 ± 0.8</td><td rowspan=1 colspan=1>71.3 ± 0.8</td><td rowspan=1 colspan=1>51.7 ± 1.0</td><td rowspan=1 colspan=1>70.5 ± 0.7</td><td rowspan=1 colspan=1>67.0 ± 1.1</td></tr><tr><td rowspan=1 colspan=1>d→a</td><td rowspan=1 colspan=1>34.0 ± 0.3</td><td rowspan=1 colspan=1>45.7 ± 0.9</td><td rowspan=1 colspan=1>42.5 ± 0.5</td><td rowspan=1 colspan=1>45.8 ± 0.9</td><td rowspan=1 colspan=1>45.7 ± 0.6</td><td rowspan=1 colspan=1>46.9 ± 1.0</td></tr><tr><td rowspan=1 colspan=1>d→w</td><td rowspan=1 colspan=1>74.3 ± 0.5</td><td rowspan=1 colspan=1>62.1 ± 0.8</td><td rowspan=1 colspan=1>78.3 ± 0.5</td><td rowspan=1 colspan=1>62.1 ± 0.7</td><td rowspan=1 colspan=1>76.5 ± 0.5</td><td rowspan=1 colspan=1>74.1 ± 0.8</td></tr><tr><td rowspan=1 colspan=1>a→c</td><td rowspan=1 colspan=1>35.1 ± 0.3</td><td rowspan=1 colspan=1>32.0 ±0.8</td><td rowspan=1 colspan=1>37.0 ± 0.4</td><td rowspan=1 colspan=1>31.1 ± 0.6</td><td rowspan=1 colspan=1>36.0 ± 0.5</td><td rowspan=1 colspan=1>36.4 ± 0.8</td></tr><tr><td rowspan=1 colspan=1>w→c</td><td rowspan=1 colspan=1>31.3 ± 0.4</td><td rowspan=1 colspan=1>30.4 ± 0.7</td><td rowspan=1 colspan=1>31.9 ± 0.5</td><td rowspan=1 colspan=1>29.4 ± 0.6</td><td rowspan=1 colspan=1>31.1 ± 0.6</td><td rowspan=1 colspan=1>32.2 ± 0.8</td></tr><tr><td rowspan=1 colspan=1>d→c</td><td rowspan=1 colspan=1>31.4 ± 0.3</td><td rowspan=1 colspan=1>31.7 ± 0.6</td><td rowspan=1 colspan=1>33.5 ± 0.4</td><td rowspan=1 colspan=1>31.0 ± 0.5</td><td rowspan=1 colspan=1>32.9 ± 0.5</td><td rowspan=1 colspan=1>34.1 ± 0.8</td></tr><tr><td rowspan=1 colspan=1>c→a</td><td rowspan=1 colspan=1>35.9 ± 0.4</td><td rowspan=1 colspan=1>45.3 ± 0.9</td><td rowspan=1 colspan=1>44.1 ± 0.6</td><td rowspan=1 colspan=1>45.5 ± 0.9</td><td rowspan=1 colspan=1>44.7 ± 0.8</td><td rowspan=1 colspan=1>49.4 ± 0.8</td></tr><tr><td rowspan=1 colspan=1>c→w</td><td rowspan=1 colspan=1>30.8 ± 1.1</td><td rowspan=1 colspan=1>60.3 ± 1.0</td><td rowspan=1 colspan=1>55.9 ± 1.0</td><td rowspan=1 colspan=1>60.5 ± 0.9</td><td rowspan=1 colspan=1>63.7 ± 0.8</td><td rowspan=1 colspan=1>63.8 ± 1.1</td></tr><tr><td rowspan=1 colspan=1>c→d</td><td rowspan=1 colspan=1>35.6±0.7</td><td rowspan=1 colspan=1>55.8 ± 0.9</td><td rowspan=1 colspan=1>50.6± 0.8</td><td rowspan=1 colspan=1>51.9 ± 1.1</td><td rowspan=1 colspan=1>57.7 ± 1.1</td><td rowspan=1 colspan=1>56.5 ± 0.9</td></tr><tr><td rowspan=1 colspan=1>mean</td><td rowspan=1 colspan=1>40.0±0.6</td><td rowspan=1 colspan=1>48.5± 0.8</td><td rowspan=1 colspan=1>49.5 ± 0.6</td><td rowspan=1 colspan=1>47.4 ± 0.8</td><td rowspan=1 colspan=1>51.0 ± 0.7</td><td rowspan=1 colspan=1>52.5 ± 1.0</td></tr></table>
+
+Office Dataset The Office dataset is a collection of images that provides three distinct domains: amazon, webcam, and dslr. The dataset has 31 categories consisting of common office objects such as chairs, backpacks and keyboards. The amazon domain contains product images (from amazon.com) containing a single object, centered, and usually on a white background. The webcam and ${ \tt d s l r }$ domains contain images taken in“the wild” using a webcam or a dslr camera, respectively. They are taken in an office setting and so have different lighting variation and background changes (see Figure 1 for some examples.) We use the SURF-BoW image features provided by the authors [1]. More details on how these features were computed can be found in [1]. The available features are vector quantized to 800 dimensions for all domains and additionally for the dslr domain there are 600 dimensional features available (we denote this as $\mathsf { d s } 1 \mathtt { r } - 6 0 0 \ r { \ r { \ r { \ r { \ r { \ r { \ll } } } } } }$ ).
+
+Office $^ +$ Caltech256 Dataset This dataset consists of the 10 common categories shared by the Office and Caltech256 datasets. To better compare to previously reported performance, we use the features provided by [15], which are also SURF-BoW 800 dimensional features.
+
+Bing Dataset To demonstrate the effect that constraint set size has on run-time performance, we use the Bing dataset from [21], which has a larger number of images in each domain than Office. The source domain has images from the Bing search engine and the target domain is from the Caltech256 benchmark. We run experiments using the first 20 categories and set the number of source examples per category to be 50. We use the train/test split from [21] and then vary the number of labeled target examples available from 5 to 25.
+
+Baselines We use the following baselines as a comparison in the experiments where applicable.1
+
+• $\mathbf { s v m } _ { s }$ : A support vector machine using source training data.   
+• $\mathbf { s v m } _ { t }$ : A support vector machine using target training data.   
+• arc-t: A category general feature transform method proposed by [12]. We implement the transform learning and then apply both a KNN classifier (as originally proposed) and an SVM classifier.   
+• hfa: A max-margin transform approach that learns a latent common space between source and target as well as a classifier that can be applied to points in that common space [11].   
+• gfk: The geodesic flow kernel [15] applied to all source and target data (including test data). Following [15], we use a 1-nearest neighbor classifier with the kernel.
+
+<table><tr><td rowspan=1 colspan=1>source</td><td rowspan=1 colspan=1>target</td><td rowspan=1 colspan=1>svmt</td><td rowspan=1 colspan=1>arc-t</td><td rowspan=1 colspan=1>hfa</td><td rowspan=1 colspan=1>mmdt</td></tr><tr><td rowspan=1 colspan=1>amazon</td><td rowspan=1 colspan=1>dslr-600</td><td rowspan=1 colspan=1>52.9 ± 0.7</td><td rowspan=1 colspan=1>58.2 ± 0.6</td><td rowspan=1 colspan=1>57.8 ± 0.6</td><td rowspan=1 colspan=1>62.3 ± 0.8</td></tr><tr><td rowspan=1 colspan=1>webcam</td><td rowspan=1 colspan=1>dslr-600</td><td rowspan=1 colspan=1>51.8 ± 0.6</td><td rowspan=1 colspan=1>58.2 ± 0.7</td><td rowspan=1 colspan=1>60.0± 0.6</td><td rowspan=1 colspan=1>63.3 ± 0.5</td></tr></table>
+
+Table 3: Multiclass accuracy results on the standard supervised domain adaptation task with different feature dimensions in the source and target. The target domain is dslr for both cases.
+
+<table><tr><td rowspan=1 colspan=1>source</td><td rowspan=1 colspan=1>svms</td><td rowspan=1 colspan=1>arc-t</td><td rowspan=1 colspan=1>gfk</td><td rowspan=1 colspan=1>mmdt</td></tr><tr><td rowspan=1 colspan=1>amazon</td><td rowspan=1 colspan=1>10.3 ± 0.6</td><td rowspan=1 colspan=1>41.4 ± 0.3</td><td rowspan=1 colspan=1>38.9± 0.4</td><td rowspan=1 colspan=1>44.6 ± 0.3</td></tr><tr><td rowspan=1 colspan=1>webcam</td><td rowspan=1 colspan=1>51.6 ± 0.5</td><td rowspan=1 colspan=1>59.4 ± 0.4</td><td rowspan=1 colspan=1>62.9 ± 0.5</td><td rowspan=1 colspan=1>58.3 ± 0.5</td></tr></table>
+
+Table 4: Multiclass accuracy results on the Office dataset for the domain shift of webcam dslr for target test categories not seen in at training time. Following the experimental setup of [12]. We compare against pmt-svm [10] and ARC-t [12] using both knn and svm classification.
+
+Standard Domain Adaptation Experiment For our first experiment, we use the Office+Caltech256 domain adaptation benchmark dataset to evaluate multi-class accuracy in the standard domain adaptation setting where a few labeled examples are available for all categories in the target domain. We follow the setup of [1] and [15]: 20 training examples for amazon source (8 for all other domains as source) and 3 labeled examples per category for the target domain. We created 20 random train/test splits and averaged results across them.
+
+The multi-class accuracy for each domain pair is shown in Table 2. Our method produced the highest multi-class accuracy for 9 out of 12 of the domain shifts and competitively on the other 3 shifts. This experiment demonstrates that our method achieves a high recognition performance and is able to outperform the most recent domain adaptation algorithms. Our method especially stands out in the settings where the domains are initially very different. The most similar domains in this dataset are webcam and ${ \tt d s l r }$ and we see that our algorithm does not perform as well on those two shifts as gfk. This fits with our intuition since gfk is a 1-nearest neighbor approach and so is more suitable when the domains are initially similar.
+
+Additionally, an important observation is that our linear method on average outperforms all the baselines, even though they each learn a non-linear transformation.
+
+Asymmetric Transform Experiment Next, we analyze the effectiveness of our asymmetric transform learning by experimenting with the source and target having different feature dimensions. We use the same experimental setup as previously, but use the Office dataset and the alternate representation for the ${ \tt d s l r }$ domain that is 600-dimensional (denoted as $\mathsf { d s } \mathtt { l r } - 6 0 0 \rrangle$ ). We compare against $\mathbf { s v m } _ { t }$ , arc-t and hfa, the baselines that can handle this scenario. The results are shown in Table 3. Again, we find that our method can effectively learn a feature representation for the target domain that optimizes the final classification objective.
+
+Generalizing to Novel Categories Experiment We next consider the setting of practical importance where labeled target examples are not available for all objects. Recall that this is a setting that many category specific adaptation methods cannot generalize to, including hfa [11]. Therefore, we compare our results for this setting to the arc-t [12] method which learns a category independent feature transform and the gfk [15] method which learns a category independent kernel to compare the domains. Following the experimental setup of [12], we use the full Office dataset and allow 20 labeled examples per category in the source for amazon and 10 labeled examples for the first 15 object categories in the target (dslr). For the webcam dslr shift, we use 8 labeled examples per category in the source for webcam and 4 labeled examples for the first 15 object categories in the target dslr.
+
+The experimental results for the domain shift of webcam dslr are evaluated and shown in Table 4; MMDT outperforms the baselines for the amazon dslr shift and offers adaptive benefit over $\mathbf { s v m } _ { s }$ for the shift from webcam to dslr. As in the first experiment, both arc-t and gfk use nearest neighbor classifiers on a learned kernel are more suitable to the shift between webcam and dslr, which are initially very similar.
+
+Scaling to Larger Datasets Experiment With our last experiment we show that our method not only offers high accuracy performance it also scales well with an increasing dataset size. Specifically, the number of constraints our algorithm optimizes scales linearly with the number of training 45points. Conversely, the number of constraints that need to be optimized for the arc-t baseline is quadratic in the number of training points.
+
+![](images/40f89b388e5f8e9ec417c11fb5cdaa170ec5e747a42163d1e90ac8534d3dcdcd.jpg)  
+Figure 2: Left: multiclass accuracy on the Bing dataset using 50 training examples in the source and 55varying the number of available labeled examples in the target. Right: training time comparison.
+
+To demonstrate the effect that constraint set size has on run-time performance, we use the Bing [21] 35dataset, which has a larger number of images in each domain than Office. The source domain has images from the Bing search engine and the target domain is from the Caltech256 benchmark. We 30run experiments using the first 20 categories and set the number of source examples per category to be 50. We use the train/test split from [21] and then vary the number of labeled target examples Number of Labeled Target Examplesavailable from 5 to 20. The left-hand plot in Figure 2 presents multi-class accuracy for this setup. Additionally, the training time of our method (run to convergence) and that of the baselines is shown on the right-hand plot.
+
+Our mmdt method provides a considerable improvement over all the baselines in terms of multiclass accuracy. It is also considerably faster than all but the gfk method. An important point to note is that both our method and arc-t scale approximately linearly with the number of target training points which is empirical verification for our claims. Note that hfa and gfk do not vary significantly as the number of target training points increases. However, for hfa the main bottleneck time is consumed by a distance computation between each pair of training points. Therefore, since there are many more source training points than target, adding a few more target points does not significantly increase the overall time spent for this experiment, but would present a problem as the size of the dataset grew in general.
+
+# 5 Conclusion
+
+In this paper, we presented a feature learning technique for domain adaptation that combines the ability of feature transform-based methods to perform multi-task adaptation with the performance benefits of directly adapting classifier parameters.
+
+We validated the computational efficiency and effectiveness of our method using two standard benchmarks used for image domain adaptation. Our experiments show that 1) our method is a competitive domain adaptation algorithm able to outperform previous methods, 2) is successfully able to generalize to novel target categories at test time, and 3) can learn asymmetric transformations. In addition, these benefits are offered through a framework that is scalable to larger datasets and achieves higher classification accuracy than previous approaches.
+
+So far we have focused on linear transforms because of its speed and scalability; however, our method can also be kernelized to include nonlinear transforms. In future work, we would like to explore the kernelized version of our algorithm and especially experiment with the geodesic flow kernel as input to our algorithm.
+
+Acknowledgements: This work was supported by NSF grants IIS-1116411 and IIS-1212798, DARPA, and the Toyota Corporation.
+
+# References
+
+ECCV, 2010.   
+[2] A. Farhadi and M. K. Tabrizi. Learning to recognize activities from the wrong view point. In Proc. ECCV, 2008. [3] L. Duan, I. W. Tsang, D. Xu, and S. J. Maybank. Domain transfer svm for video concept detection. In CVPR, 2009.   
+[4] L. Duan, D. Xu, I. Tsang, and J. Luo. Visual event recognition in videos by learning from web data. In Proc. CVPR, 2010. [5] A. Torralba and A. Efros. Unbiased look at dataset bias. In Proc. CVPR, 2011.   
+[6] D. McAllester P. Felzenszwalb, R. Girshick and D. Ramanan. Object detection with discriminatively trained part based models. IEEE Transactions on Pattern Analysis and Machine Intelligence, 32(9), 2010.   
+[7] Lubomir Bourdev and Jitendra Malik. Poselets: Body part detectors trained using 3d human pose annotations. In Proc. ICCV, 2009. [8] J. Yang, R. Yan, and A. Hauptmann. Adapting svm classifiers to data with shifted distributions. In ICDM Workshops, 2007.   
+[9] X. Li. Regularized adaptation: Theory, algorithms and applications. In PhD thesis, University of Washington, USA, 2007.   
+[10] Y. Aytar and A. Zisserman. Tabula rasa: Model transfer for object category detection. In Proc. ICCV, 2011.   
+[11] Lixin Duan, Dong Xu, and Ivor W. Tsang. Learning with augmented features for heterogeneous domain adaptation. In Proc. ICML, 2012.   
+[12] B. Kulis, K. Saenko, and T. Darrell. What you saw is not what you get: Domain adaptation using asymmetric kernel transforms. In Proc. CVPR, 2011.   
+[13] R. Gopalan, R. Li, and R. Chellappa. Domain adaptation for object recognition: An unsupervised approach. In Proc. ICCV, 2011.   
+[14] W. Dai, Y. Chen, G. Xue, Q. Yang, and Y. Yu. Translated learning: Transfer learning across different feature spaces. In Proc. NIPS, 2008.   
+[15] B. Gong, Y. Shi, F. Sha, and K. Grauman. Geodesic flow kernel for unsupervised domain adaptation. In Proc. CVPR, 2012.   
+[16] J. Blitzer, M. Dredze, and F. Pereira. Biographies, bollywood, boom-boxes and blenders: Domain adaptation for sentiment classification. 2007.   
+[17] H. Daume III. Frustratingly easy domain adaptation. In Proc. ACL, 2007.   
+[18] S. Ben-david, J. Blitzer, K. Crammer, and O. Pereira. Analysis of representations for domain adaptation. In In NIPS. MIT Press, 2007.   
+[19] J. Jiang and C. X. Zhai. Instance weighting for domain adaptation in nlp. In Proceedings of the 45th Annual Meeting of the Association of Computational Linguistics, pages 264–271, 2007.   
+[20] J. Jiang. A literature survey on domain adaptation of statistical classifiers. http://sifaka.cs. uiuc.edu/jiang4/domain_adaptation/survey/.   
+[21] A. Bergamo and L. Torresani. Exploiting weakly-labeled web images to improve object classification: a domain adaptation approach. In Proc. NIPS, 2010.   
+[22] W. Jiang, E. Zavesky, S. Chang, and A. Loui. Cross-domain learning methods for high-level visual concept classification. In ICIP, 2008.   
+[23] Yoshua Bengio. Deep learning of representations for unsupervised and transfer learning. Journal of Machine Learning Research - Proceedings Track, 27:17–36, 2012.   
+[24] John Blitzer, Ryan McDonald, and Fernando Pereira. Domain adaptation with structural correspondence learning. In Proceedings of the 2006 Conference on Empirical Methods in Natural Language Processing, EMNLP ’06, pages 120–128, 2006.   
+[25] G. Griffin, A. Holub, and P. Perona. Caltech-256 object category dataset. Technical Report 7694, California Institute of Technology, 2007.   
+[26] Chih-Chung Chang and Chih-Jen Lin. LIBSVM: A library for support vector machines. ACM Transactions on Intelligent Systems and Technology, 2:27:1–27:27, 2011. Software available at http: //www.csie.ntu.edu.tw/˜cjlin/libsvm.   
+[27] Rong-En Fan, Kai-Wei Chang, Cho-Jui Hsieh, Xiang-Rui Wang, and Chih-Jen Lin. LIBLINEAR: A library for large linear classification. Journal of Machine Learning Research, 9:1871–1874, 2008.

parse/train/BBIbj9w8Lvj8F/BBIbj9w8Lvj8F_content_list.json

@@ -0,0 +1,933 @@
+[
+    {
+        "type": "text",
+        "text": "Efficient Learning of Domain-invariant Image Representations ",
+        "text_level": 1,
+        "bbox": [
+            220,
+            133,
+            777,
+            185
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Judy Hoffman UCB EECS & ICSI jhoffman@eecs.berkeley.edu ",
+        "bbox": [
+            370,
+            238,
+            627,
+            281
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Erik Rodner UCB EECS & ICSI erik.rodner@gmail.com ",
+        "bbox": [
+            233,
+            301,
+            442,
+            344
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Jeff Donahue UCB EECS & ICSI jdonahue@eecs.berkeley.edu ",
+        "bbox": [
+            509,
+            301,
+            764,
+            344
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Trevor Darrell UCB EECS & ICSI trevor@eecs.berkeley.edu ",
+        "bbox": [
+            228,
+            364,
+            465,
+            406
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Kate Saenko University of Massachusetts, Lowell saenko@cs.uml.edu ",
+        "bbox": [
+            527,
+            364,
+            769,
+            406
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            443,
+            535,
+            459
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We present an algorithm that learns representations which explicitly compensate for domain mismatch and which can be efficiently realized as linear classifiers. Specifically, we form a linear transformation that maps features from the target (test) domain to the source (training) domain as part of training the classifier. We optimize both the transformation and classifier parameters jointly, and introduce an efficient cost function based on misclassification loss. Our method combines several features previously unavailable in a single algorithm: multi-class adaptation through representation learning, ability to map across heterogeneous feature spaces, and scalability to large datasets. We present experiments on several image datasets that demonstrate improved accuracy and computational advantages compared to previous approaches. ",
+        "bbox": [
+            233,
+            473,
+            764,
+            627
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            645,
+            312,
+            662
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We address the problem of learning domain-invariant image representations for multi-class classifiers. The ideal image representation often depends not just on the task but also on the domain. Recent studies have demonstrated a significant degradation in the performance of state-of-the-art image classifiers when input feature distributions change due to different image sensors and noise conditions [1], pose changes [2], a shift from commercial to consumer video [3, 4], and, more generally, training datasets biased by the way in which they were collected [5]. Learning adaptive representations for linear classifiers is particularly interesting as they are efficient and prevalent in vision applications, with fast linear SVMs forming the core of some of the most popular object detection methods [6, 7]. ",
+        "bbox": [
+            174,
+            666,
+            825,
+            791
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Previous work proposed to adapt linear SVMs [8, 9, 10], learning a perturbation of the source hyperplane by minimizing the classification error on labeled target examples for each binary task. These perturbations can be thought of as new feature representations that correct for the domain change. The recent HFA method [11] learns both the perturbed classifier and a latent domain-invariant feature representation, allowing domains to have heterogeneous features with different dimensionalities. However, existing SVM-based methods are limited to learning a separate representation for each binary problem and cannot transfer a common, class-independent component of the shift (such as global lighting change) to unlabeled categories, as illustrated in Figure 1. Additionally, the HFA algorithm cannot be solved in linear space and therefore scales poorly to large datasets. ",
+        "bbox": [
+            174,
+            797,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/fbb65d7b613e8da86d648bbe90f75335c1f72c297d368a695cf4601c719c82c1.jpg",
+        "image_caption": [
+            "Figure 1: (a) Linear classifiers (shown as decision boundaries) learned for a four-class problem on a fully labeled source domain. (b) Problem: classifiers learned on the source domain do not fit the target domain points shown here due to a change in feature distribution. (c) Existing SVM-based methods only adapt the features of classes with labels (crosses and triangles). (d) Our method adapts all points, including those from classes without labels, by transforming all target features to a new domain-invariant representation. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            103,
+            816,
+            219
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Recently proposed feature adaptation methods [1, 2, 12, 13, 14, 15] offer a solution by learning a category-independent feature transform that maps target features into the source, pooling all training labels across categories. This enables multi-class adaptation, i.e. transferring the categoryindependent component of the domain-invariant representation to unlabeled categories. For example, a map learned on the labeled “triangle” class in Figure 1 can also be used to map the unlabeled “star” class to the source domain. An additional advantage of the asymmetric transform method ARC-t [12] over metric learning [1] or the recently proposed Geodesic Flow Kernel (GFK) [15], is that, like HFA [11], ARC-t can map between heterogeneous feature spaces. However, ARC-t has two major limitations: First, the feature learning does not optimize the objective function of a strong, discriminative classifier directly; rather, it maximizes some notion of similarity between the transformed target points and points in the source. Second, it does not scale well to domains with large numbers of points due to the high number of constraints, which is proportional to the product of the number of labeled data points in the source and target. ",
+        "bbox": [
+            174,
+            347,
+            825,
+            526
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we present a novel technique that combines the desirable aspects of recent methods in a single algorithm, which we call Max-Margin Domain Transforms, or MMDT for short. MMDT uses an asymmetric (non-square) transform $W$ to map target features $x$ to a new representation $W x$ maximally aligned with the source, learning the transform jointly on all categories for which target labels are available (Figure 1(d)). MMDT provides a way to adapt max-margin classifiers in a multi-class manner, by learning a shared component of the domain shift as captured by the feature transformation $W$ . Additionally, MMDT can be optimized quickly in linear space, making it a feasible solution for problem settings with a large amount of training data. ",
+        "bbox": [
+            174,
+            535,
+            825,
+            646
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The key idea behind our approach is to simultaneously learn both the projection of the target features into the source domain and the classifier parameters themselves, using the same classification loss to jointly optimize both. ",
+        "bbox": [
+            176,
+            652,
+            820,
+            694
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Thus our method learns a feature representation that combines the strengths of max-margin learning with the flexibility of the feature transform. Because it operates over the input features, it can generalize the learned shift in a way that parameter-based methods cannot. On the other hand, it overcomes the two flaws of the ARC-t method: by optimizing the classification loss directly in the transform learning framework, it can achieve higher accuracy; furthermore, replacing similarity constraints with more efficient hyperplane constraints significantly reduces the training time of the algorithm and learning a transformation directly from target to source allows optimization in linear space. ",
+        "bbox": [
+            174,
+            700,
+            825,
+            813
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The main contributions of our paper can be summarized as follows (also see Table 1): ",
+        "bbox": [
+            176,
+            819,
+            733,
+            834
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• Experiments show that MMDT in linear feature space outperforms competing methods in terms of multi-class accuracy even compared to previous kernelized methods. • MMDT learns a representation via an asymmetric category independent transform. Therefore, it can adapt features even when the target domain does not have any labeled examples for some categories and when the target and source features are not equivalent. ",
+        "bbox": [
+            214,
+            845,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "table",
+        "img_path": "images/1de28b50c5a6a7534559f975b575e70168255fa288b9c3a605ffd9bae4f8e3d3.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>ARC-t [12]</td><td>HFA[11]</td><td>GFK[15]</td><td>MMDT (ours)</td></tr><tr><td>multi-class</td><td>yes</td><td>no</td><td>yes</td><td>yes</td></tr><tr><td>large datasets</td><td>no</td><td>no</td><td>yes</td><td>yes</td></tr><tr><td>heterogeneous features</td><td>yes</td><td>yes</td><td>no</td><td>yes</td></tr><tr><td>optimize max-margin objective</td><td>no</td><td>yes</td><td>no</td><td>yes</td></tr></table>",
+        "bbox": [
+            197,
+            101,
+            799,
+            174
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Table 1: Unlike previous methods, our approach is able to simultaneously learn muti-class representations that can transfer to novel classes, scale to large training datasets, and handle different feature dimensionalities. ",
+        "bbox": [
+            174,
+            190,
+            825,
+            233
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "• The optimization of MMDT is scalable to large datasets because the number of constraints to optimize is linear in the number of training data points and because it can be optimized in linear feature space. ",
+        "bbox": [
+            215,
+            256,
+            821,
+            299
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "• Our final iterative solution can be solved using standard QP packages, making MMDT easy to implement. ",
+        "bbox": [
+            210,
+            305,
+            823,
+            334
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            354,
+            323,
+            372
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Domain adaptation, or covariate shift, is a fundamental problem in machine learning, and has attracted a lot of attention in the machine learning and natural language community, e.g. [16, 17, 18, 19] (see [20] for a comprehensive overview). It is related to multi-task learning but differs from it in the following way: in domain adaptation problems, the distribution over the features $\\mathrm { p } ( X )$ varies across domains while the output labels $Y$ remain the same; in multi-task learning or knowledge transfer, $\\mathrm { p } ( X )$ stays the same (single domain) while the output labels vary (see [20] for more details). In this paper, we perform multi-task learning across domains, i.e. both $\\mathrm { p } ( X )$ and the output labels $Y$ can change between domains. ",
+        "bbox": [
+            174,
+            376,
+            825,
+            488
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Domain adaptation has been gaining considerable attention in the vision community. Several SVMbased approaches have been proposed for image domain adaptation, including: weighted combination of source and target SVMs and transductive SVMs applied to adaptation in [21]; the feature replication method of [17]; Adaptive SVM [8, 9], where the source model parameters are adapted by adding a perturbation function, and its successor PMT-SVM [10]; Domain Transfer SVM [3], which learns a target decision function while reducing the mismatch in the domain distributions; and a related method [4] based on multiple kernel learning. In the linear case, feature replication [17] can be shown to decompose the learned parameter into $\\theta = \\widehat { \\theta } + \\theta ^ { \\prime }$ , where $\\hat { \\theta }$ is shared by all domains [22], in a similar fashion to adaptive SVMs. ",
+        "bbox": [
+            174,
+            494,
+            825,
+            622
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Several authors considered learning feature representations for unsupervised and transfer learning [23], and for domain adaptation [18, 24]. For visual domain adaptation, transform-based adaptation methods [1, 12, 13, 2, 14, 11] have recently been proposed. These methods attempt to learn a perturbation over the feature space rather than a class-specific perturbation over the model parameters, typically in the form of a transformation matrix/kernel. The most closely related are the ARC-t method [12], which learns a transformation that maximizes similarity constraints between points in the source and those projected from the target domain, and the recent HFA method [11], which learns a transformation both from the source and target into a common latent space, as well as the classifier parameters. Another related method is the recently proposed GFK [15], which computes a symmetric kernel between source and target points based on geodesic flow along a latent manifold. We will present a detailed comparison to these three methods in the next section. ",
+        "bbox": [
+            174,
+            628,
+            825,
+            782
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 Max-Margin Domain Transforms ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            803,
+            485,
+            820
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We propose a novel method for multi-task domain adaptation of linear SVMs by learning a target feature representation. Denote the normal to the affine hyperplane associated with the $k$ ’th binary SVM as $\\theta _ { k }$ , $k = 1 , . . . , K$ , and the offset of that hyperplane from the origin as $b _ { k }$ . Intuitively, we would like to learn a new target feature representation that is shared across multiple categories. transformation W T of the source hyperplane parameters θk. Let xs1, . . . , xsnS of the input features, or, equivalently, a denote the training points in the source domain $( \\mathcal { D } _ { S } )$ , with labels $y _ { 1 } ^ { s } , \\ldots , y _ { n _ { S } } ^ { s }$ . Let $x _ { 1 } ^ { t } , \\ldots , x _ { n _ { T } } ^ { t }$ denote the labeled points in the target domain $( \\mathcal { D } _ { T } )$ , with labels $y _ { 1 } ^ { t } , \\ldots , y _ { n _ { T } } ^ { t }$ . Thus our goal is to jointly learn 1) affine hyperplanes that separate the classes in the common domain consisting of the source domain and target points projected to the source and 2) the new feature representation of the target domain determined by the transformation $W$ mapping points from the target domain into the source domain. The transformation should have the property that it projects the target points onto the correct side of each source hyperplane. ",
+        "bbox": [
+            174,
+            824,
+            825,
+            925
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            102,
+            825,
+            188
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For simplicity of presentation, we first show the optimization problem for a binary problem (dropping $k$ ) with no slack variables. Our objective is as follows: ",
+        "bbox": [
+            169,
+            194,
+            821,
+            223
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/99129229c19429d57f0f25da6f138b6cb776050aa353c09b6743f9cedd9e9491.jpg",
+        "text": "$$\n\\begin{array} { r l } { \\underset { W , \\theta , b } { \\mathrm { m i n } } \\quad } & { \\frac { 1 } { 2 } | | W | | _ { F } ^ { 2 } + \\frac { 1 } { 2 } | | \\theta | | _ { 2 } ^ { 2 } } \\\\ { \\mathrm { s . t . } \\quad } & { y _ { i } ^ { s } \\left( \\left[ x _ { 1 } ^ { s } \\right] ^ { T } \\left[ \\theta \\right] \\right) \\geq 1 \\quad \\quad \\forall i \\in \\mathcal { D } _ { S } } \\\\ & { y _ { i } ^ { t } \\left( \\left[ x _ { 1 } ^ { t } \\right] ^ { T } W ^ { T } \\left[ \\theta \\right] \\right) \\geq 1 \\quad \\forall i \\in \\mathcal { D } _ { T } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            341,
+            227,
+            656,
+            347
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Note that this can be easily extended to the multi-class case by simply adding a sum over the regularizers on all $\\theta _ { k }$ parameters and pooling the constraints for all categories. The objective function, written as in Equations (1)-(3), is not a convex problem and so is both hard to optimize and is not guaranteed to have a global solution. Therefore, a standard way to solve this problem is to do alternating minimization on the parameters, in our case $W$ and $( \\theta , b )$ . We can effectively do this because when each parameter vector is fixed, the resulting optimization problem is convex. ",
+        "bbox": [
+            173,
+            349,
+            825,
+            434
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We begin by re-writing Equations (1)-(3) for the more general problem with soft constraints and $K$ categories. Let us denote the hinge loss as: $\\mathcal { L } ( y , x , \\theta ) \\overset { \\cdot } { = } \\operatorname* { m a x } \\{ 0 , 1 - \\delta ( y , k ) \\cdot x ^ { T } \\theta \\}$ . We define a cost function ",
+        "bbox": [
+            174,
+            439,
+            823,
+            483
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b8507bc3bee06f05649946891384fd5603eabf8e65e5b8e10b174945b4eb4749.jpg",
+        "text": "$$\n\\begin{array} { l c l } { { { \\cal J } ( W , \\theta _ { k } , b _ { k } ) } } & { { = } } & { { \\displaystyle { \\frac { 1 } { 2 } | | W | | _ { F } ^ { 2 } + \\sum _ { k = 1 } ^ { K } \\left[ \\frac { 1 } { 2 } | | \\theta _ { k } | | _ { 2 } ^ { 2 } \\right. } } } \\\\ { { } } & { { } } & { { \\displaystyle { \\left. + C _ { S } \\sum _ { i = 1 } ^ { n _ { S } } { \\mathcal { L } \\left( y _ { i } ^ { s } , \\left[ \\boldsymbol { \\boldsymbol { \\chi } } _ { i } ^ { s } \\right] { } , \\left[ \\boldsymbol { \\theta } _ { k } \\right] { } \\right) } + C _ { T } \\sum _ { i = 1 } ^ { n _ { T } } { \\mathcal { L } \\left( y _ { i } ^ { t } , W \\cdot \\left[ \\boldsymbol { \\chi } _ { i } ^ { t } \\right] , \\left[ \\boldsymbol { \\theta } _ { k } \\right] { } \\right) } \\right] } } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            230,
+            505,
+            767,
+            585
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where the constant $C _ { S }$ penalizes the source classification error and $C _ { T }$ penalizes the target adaptation error. Finally, we define our objective function with soft constraints as follows: ",
+        "bbox": [
+            171,
+            588,
+            821,
+            617
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1c0a21c4a5eb4631d5a26b04e7feda8b9554cd24ca487038408fedf59ce0128d.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { W , \\theta _ { k } , b _ { k } } J ( W , \\theta _ { k } , b _ { k } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            415,
+            622,
+            552,
+            647
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To solve the above optimization problem we perform coordinate descent on $W$ and $( \\theta , b )$ . ",
+        "bbox": [
+            171,
+            660,
+            759,
+            675
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "1. Set iteration $j = 0$ , $W ^ { ( j ) } = 0$ . ",
+        "bbox": [
+            178,
+            686,
+            398,
+            702
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2. Solve the sub-proble m (θ(j+1)k , b $\\begin{array} { r } { ( \\theta _ { k } ^ { ( j + 1 ) } , b _ { k } ^ { ( j + 1 ) } ) = \\arg \\operatorname* { m i n } _ { \\theta _ { k } , b _ { k } } J ( W ^ { ( j ) } , \\theta _ { k } , b _ { k } ) } \\end{array}$ ",
+        "bbox": [
+            173,
+            705,
+            740,
+            726
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0b8f5f2f15bdf98f493e137150c345b18aa71a32ce71a2cc4345d6dbaeb8a544.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { \\theta , b } \\sum _ { k = 1 } ^ { K } \\left[ \\frac { 1 } { 2 } | | \\theta _ { k } | | _ { 2 } ^ { 2 } + C _ { S } \\sum _ { i = 1 } ^ { n _ { S } } \\mathcal { L } \\left( y _ { i } ^ { s } , \\left[ \\underline { { x } } _ { i } ^ { s } \\right] , \\left[ \\underline { { \\theta } } _ { k } ; \\right] \\right) + C _ { T } \\sum _ { i = 1 } ^ { n _ { T } } \\mathcal { L } \\left( y _ { i } ^ { t } , W ^ { ( j ) } \\cdot \\left[ \\underline { { x } } _ { i } ^ { t } \\right] , \\left[ \\underline { { \\theta } } _ { k } \\right] \\right) \\right]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            210,
+            732,
+            810,
+            773
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Notice, this corresponds to the standard SVM objective function, except that the target points are first projected into the source using $W ^ { ( j ) }$ . Therefore, we can solve this intermediate problem using a standard SVM solver package. ",
+        "bbox": [
+            194,
+            777,
+            823,
+            821
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3. Solve the subproblem $W ^ { ( j + 1 ) } = \\arg \\operatorname* { m i n } _ { W } J ( W , \\theta ^ { ( j + 1 ) } , b ^ { ( j + 1 ) } )$ by solving ",
+        "bbox": [
+            176,
+            825,
+            694,
+            843
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8e497b52c9822a60fc865dda0753d7cad5eb0e32e9dc67058ca57f6f4fbe69a2.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { W } \\qquad \\frac { 1 } { 2 } | | W | | _ { F } ^ { 2 } + C _ { T } \\sum _ { k = 1 } ^ { K } \\sum _ { i = 1 } ^ { n _ { T } } \\mathcal { L } \\left( y _ { i } ^ { t } , W \\cdot \\left[ x _ { i } ^ { t } \\right] , \\left[ \\theta _ { k } ^ { ( j + 1 ) } \\right] \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            302,
+            848,
+            718,
+            891
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "and increment $j$ . This optimization sub-problem is convex and is in a form that a standard QP optimization package can solve. ",
+        "bbox": [
+            196,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4. Iterate steps 2 & 3 until convergence. ",
+        "bbox": [
+            178,
+            104,
+            441,
+            117
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "It is straightforward to show that both stages (2) and (3) cannot increase the global cost function $J ( W , \\theta , b )$ . Therefore, this algorithm is guaranteed to converge to a local optimum. A proof is included in the supplemental material. ",
+        "bbox": [
+            174,
+            137,
+            825,
+            179
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "It is important to note that since both steps of our iterative algorithm can be solved using standard QP solvers, the algorithm can be easily implemented. Additionally, since the constraints in our algorithm grow linearly with the number of training points and it can be solved in linear feature space, the optimization can be solved efficiently even as the number of training points grows. ",
+        "bbox": [
+            174,
+            186,
+            825,
+            242
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Relation to existing work: We now analyze the proposed algorithm in the context of the previous feature transform methods ARC-t [12], HFA [11] and GFK [15]. ARC-t introduced similarity-based constraints to learn a mapping similar to that in step 3 in our algorithm. This approach creates a constraint for each labeled point $x _ { i } ^ { s }$ in the source and labeled point $\\boldsymbol { x } _ { i } ^ { t }$ in the target, and then learns a transformation $W$ that satisfies constraints of the form $( x _ { i } ^ { s } ) ^ { T } W x _ { i } ^ { t } > u$ if the labels of $\\boldsymbol { x } _ { i } ^ { s }$ and $\\ v x _ { i } ^ { t }$ are the same, and $( x _ { i } ^ { s } ) ^ { T } W x _ { i } ^ { t } < l$ if the labels are different, for some constants $u , l$ . ",
+        "bbox": [
+            173,
+            250,
+            825,
+            335
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The ARC-t formulation has two distinct limitations that our method overcomes. First, it must solve $n _ { S } \\cdot n _ { T }$ constraints, whereas our formulation only needs to solve $K \\cdot n _ { T }$ constraints, for a $K$ category problem. In general, our method scales to much larger source domains than with ARC-t. The second benefit of our max-margin transformation learning approach is that the transformation learned using the max-margin constraints is learned jointly with the classifier, and explicitly seeks to optimize the final SVM classifier objective. While ARC-t’s similarity-based constraints seek to map points of the same category arbitrarily close to one another, followed by a separate classifier learning step, we seek simply to project the target points onto the correct side of the learned hyperplane, leading to better classification performance. ",
+        "bbox": [
+            173,
+            342,
+            825,
+            468
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The HFA formulation also takes advantage of the max-margin framework to directly optimize the classification objective while learning transformations. HFA learns the classifier and transformations to a common latent feature representation between the source and target. However, HFA is formulated to solve a binary problem so a new feature transformation must be learned for each category. Therefore, unlike MMDT, HFA cannot learn a representation that generalizes to novel target categories. Additionally, due to the difficulty of defining the dimension of the latent feature representation directly, the authors optimize with respect to a larger combined transformation matrix and a relaxed constraint. This transformation matrix becomes too large when the feature dimensions in source and target are large so the HFA must usually be solved in kernel space. This can make the method slow and cause it to scale poorly with the number of training examples. In contrast, our method can be efficiently solved in linear feature space which makes it fast and potentially more scalable. ",
+        "bbox": [
+            173,
+            474,
+            825,
+            640
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Finally, GFK [15] formulates a kernelized representation of the data that is equivalent to computing the dot product in infinitely many subspaces along the geodesic flow between the source and target domain subspaces. The kernel is defined by the authors to be symmetric and so can not handle source and target domains of different initial dimension. Additionally, GFK does not directly optimize a classification objective. In contrast, our method, MMDT, can handle source and target domains of different feature dimensions via an asymmetric $W$ , as well as directly optimizes the classification objective. ",
+        "bbox": [
+            173,
+            647,
+            825,
+            746
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 Experiments on Image Datasets ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            767,
+            470,
+            785
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We now present experiments using the Office [1], Caltech256 [25] and Bing [21] datasets to evaluate our algorithm according to the following four criteria. 1) Using a subset of the Office and Caltech256 datasets we evaluate multi-class accuracy performance in a standard supervised domain adaptation setting, where all categories have a small number of labeled examples in the target. 2) Using the full Office dataset we evaluate multi-class accuracy for the supervised domain adaptation setting where the source and target have different feature dimensions. 3) Using the full Office dataset we evaluate multi-class accuracy in the multi-task domain adaptation setting with novel target categories at test time. 4) Using the Bing dataset we assess the ability to scale to larger datasets by analyzing timing performance. ",
+        "bbox": [
+            173,
+            797,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/bab00c509d1152d01d0c4ea6882d88bd36705558abfc15cc863b1f25ab3d8067.jpg",
+        "table_caption": [
+            "Table 2: Multi-class accuracy for the standard supervised domain adaptation setting: All results are from our implementation. When averaged across all domain shifts the reported average value for gfk was 51.65 while our implementation had an average of $5 1 . 0 \\pm 0 . 7$ . Therefore, the result difference is within the standard deviation over data splits. Red indicates the best result for each domain split. Blue indicates the group of results that are close to the best performing result. The domain names are shortened for space: a: amazon, w: webcam, d: dslr, c: Caltech256 "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>svms</td><td rowspan=1 colspan=1>svmt</td><td rowspan=1 colspan=1>arct[12]</td><td rowspan=1 colspan=1>hfa[11]</td><td rowspan=1 colspan=1>gfk[15]</td><td rowspan=1 colspan=1>mmdt (ours)</td></tr><tr><td rowspan=1 colspan=1>a→w</td><td rowspan=1 colspan=1>33.9 ± 0.7</td><td rowspan=1 colspan=1>62.4 ± 0.9</td><td rowspan=1 colspan=1>55.7 ± 0.9</td><td rowspan=1 colspan=1>61.8 ± 1.1</td><td rowspan=1 colspan=1>58.6 ± 1.0</td><td rowspan=1 colspan=1>64.6 ± 1.2</td></tr><tr><td rowspan=1 colspan=1>a→d</td><td rowspan=1 colspan=1>35.0 ±0.8</td><td rowspan=1 colspan=1>55.9 ± 0.8</td><td rowspan=1 colspan=1>50.2 ± 0.7</td><td rowspan=1 colspan=1>52.7 ± 0.9</td><td rowspan=1 colspan=1>50.7 ±0.8</td><td rowspan=1 colspan=1>56.7 ± 1.3</td></tr><tr><td rowspan=1 colspan=1>w→a</td><td rowspan=1 colspan=1>35.7 ± 0.4</td><td rowspan=1 colspan=1>45.6± 0.7</td><td rowspan=1 colspan=1>43.4 ± 0.5</td><td rowspan=1 colspan=1>45.9 ± 0.7</td><td rowspan=1 colspan=1>44.1 ± 0.4</td><td rowspan=1 colspan=1>47.7 ± 0.9</td></tr><tr><td rowspan=1 colspan=1>w→d</td><td rowspan=1 colspan=1>66.6 ± 0.7</td><td rowspan=1 colspan=1>55.1 ± 0.8</td><td rowspan=1 colspan=1>71.3 ± 0.8</td><td rowspan=1 colspan=1>51.7 ± 1.0</td><td rowspan=1 colspan=1>70.5 ± 0.7</td><td rowspan=1 colspan=1>67.0 ± 1.1</td></tr><tr><td rowspan=1 colspan=1>d→a</td><td rowspan=1 colspan=1>34.0 ± 0.3</td><td rowspan=1 colspan=1>45.7 ± 0.9</td><td rowspan=1 colspan=1>42.5 ± 0.5</td><td rowspan=1 colspan=1>45.8 ± 0.9</td><td rowspan=1 colspan=1>45.7 ± 0.6</td><td rowspan=1 colspan=1>46.9 ± 1.0</td></tr><tr><td rowspan=1 colspan=1>d→w</td><td rowspan=1 colspan=1>74.3 ± 0.5</td><td rowspan=1 colspan=1>62.1 ± 0.8</td><td rowspan=1 colspan=1>78.3 ± 0.5</td><td rowspan=1 colspan=1>62.1 ± 0.7</td><td rowspan=1 colspan=1>76.5 ± 0.5</td><td rowspan=1 colspan=1>74.1 ± 0.8</td></tr><tr><td rowspan=1 colspan=1>a→c</td><td rowspan=1 colspan=1>35.1 ± 0.3</td><td rowspan=1 colspan=1>32.0 ±0.8</td><td rowspan=1 colspan=1>37.0 ± 0.4</td><td rowspan=1 colspan=1>31.1 ± 0.6</td><td rowspan=1 colspan=1>36.0 ± 0.5</td><td rowspan=1 colspan=1>36.4 ± 0.8</td></tr><tr><td rowspan=1 colspan=1>w→c</td><td rowspan=1 colspan=1>31.3 ± 0.4</td><td rowspan=1 colspan=1>30.4 ± 0.7</td><td rowspan=1 colspan=1>31.9 ± 0.5</td><td rowspan=1 colspan=1>29.4 ± 0.6</td><td rowspan=1 colspan=1>31.1 ± 0.6</td><td rowspan=1 colspan=1>32.2 ± 0.8</td></tr><tr><td rowspan=1 colspan=1>d→c</td><td rowspan=1 colspan=1>31.4 ± 0.3</td><td rowspan=1 colspan=1>31.7 ± 0.6</td><td rowspan=1 colspan=1>33.5 ± 0.4</td><td rowspan=1 colspan=1>31.0 ± 0.5</td><td rowspan=1 colspan=1>32.9 ± 0.5</td><td rowspan=1 colspan=1>34.1 ± 0.8</td></tr><tr><td rowspan=1 colspan=1>c→a</td><td rowspan=1 colspan=1>35.9 ± 0.4</td><td rowspan=1 colspan=1>45.3 ± 0.9</td><td rowspan=1 colspan=1>44.1 ± 0.6</td><td rowspan=1 colspan=1>45.5 ± 0.9</td><td rowspan=1 colspan=1>44.7 ± 0.8</td><td rowspan=1 colspan=1>49.4 ± 0.8</td></tr><tr><td rowspan=1 colspan=1>c→w</td><td rowspan=1 colspan=1>30.8 ± 1.1</td><td rowspan=1 colspan=1>60.3 ± 1.0</td><td rowspan=1 colspan=1>55.9 ± 1.0</td><td rowspan=1 colspan=1>60.5 ± 0.9</td><td rowspan=1 colspan=1>63.7 ± 0.8</td><td rowspan=1 colspan=1>63.8 ± 1.1</td></tr><tr><td rowspan=1 colspan=1>c→d</td><td rowspan=1 colspan=1>35.6±0.7</td><td rowspan=1 colspan=1>55.8 ± 0.9</td><td rowspan=1 colspan=1>50.6± 0.8</td><td rowspan=1 colspan=1>51.9 ± 1.1</td><td rowspan=1 colspan=1>57.7 ± 1.1</td><td rowspan=1 colspan=1>56.5 ± 0.9</td></tr><tr><td rowspan=1 colspan=1>mean</td><td rowspan=1 colspan=1>40.0±0.6</td><td rowspan=1 colspan=1>48.5± 0.8</td><td rowspan=1 colspan=1>49.5 ± 0.6</td><td rowspan=1 colspan=1>47.4 ± 0.8</td><td rowspan=1 colspan=1>51.0 ± 0.7</td><td rowspan=1 colspan=1>52.5 ± 1.0</td></tr></table>",
+        "bbox": [
+            187,
+            101,
+            808,
+            308
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Office Dataset The Office dataset is a collection of images that provides three distinct domains: amazon, webcam, and dslr. The dataset has 31 categories consisting of common office objects such as chairs, backpacks and keyboards. The amazon domain contains product images (from amazon.com) containing a single object, centered, and usually on a white background. The webcam and ${ \\tt d s l r }$ domains contain images taken in“the wild” using a webcam or a dslr camera, respectively. They are taken in an office setting and so have different lighting variation and background changes (see Figure 1 for some examples.) We use the SURF-BoW image features provided by the authors [1]. More details on how these features were computed can be found in [1]. The available features are vector quantized to 800 dimensions for all domains and additionally for the dslr domain there are 600 dimensional features available (we denote this as $\\mathsf { d s } 1 \\mathtt { r } - 6 0 0 \\ r { \\ r { \\ r { \\ r { \\ r { \\ r { \\ll } } } } } }$ ). ",
+        "bbox": [
+            173,
+            434,
+            825,
+            574
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Office $^ +$ Caltech256 Dataset This dataset consists of the 10 common categories shared by the Office and Caltech256 datasets. To better compare to previously reported performance, we use the features provided by [15], which are also SURF-BoW 800 dimensional features. ",
+        "bbox": [
+            174,
+            580,
+            821,
+            622
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Bing Dataset To demonstrate the effect that constraint set size has on run-time performance, we use the Bing dataset from [21], which has a larger number of images in each domain than Office. The source domain has images from the Bing search engine and the target domain is from the Caltech256 benchmark. We run experiments using the first 20 categories and set the number of source examples per category to be 50. We use the train/test split from [21] and then vary the number of labeled target examples available from 5 to 25. ",
+        "bbox": [
+            174,
+            628,
+            825,
+            712
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Baselines We use the following baselines as a comparison in the experiments where applicable.1 ",
+        "bbox": [
+            176,
+            717,
+            815,
+            733
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "• $\\mathbf { s v m } _ { s }$ : A support vector machine using source training data.   \n• $\\mathbf { s v m } _ { t }$ : A support vector machine using target training data.   \n• arc-t: A category general feature transform method proposed by [12]. We implement the transform learning and then apply both a KNN classifier (as originally proposed) and an SVM classifier.   \n• hfa: A max-margin transform approach that learns a latent common space between source and target as well as a classifier that can be applied to points in that common space [11].   \n• gfk: The geodesic flow kernel [15] applied to all source and target data (including test data). Following [15], we use a 1-nearest neighbor classifier with the kernel. ",
+        "bbox": [
+            204,
+            744,
+            825,
+            892
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/a6f0c24cb7571960854b6ded7a6d6f671fd578168ef90d26ab6097d023473869.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>source</td><td rowspan=1 colspan=1>target</td><td rowspan=1 colspan=1>svmt</td><td rowspan=1 colspan=1>arc-t</td><td rowspan=1 colspan=1>hfa</td><td rowspan=1 colspan=1>mmdt</td></tr><tr><td rowspan=1 colspan=1>amazon</td><td rowspan=1 colspan=1>dslr-600</td><td rowspan=1 colspan=1>52.9 ± 0.7</td><td rowspan=1 colspan=1>58.2 ± 0.6</td><td rowspan=1 colspan=1>57.8 ± 0.6</td><td rowspan=1 colspan=1>62.3 ± 0.8</td></tr><tr><td rowspan=1 colspan=1>webcam</td><td rowspan=1 colspan=1>dslr-600</td><td rowspan=1 colspan=1>51.8 ± 0.6</td><td rowspan=1 colspan=1>58.2 ± 0.7</td><td rowspan=1 colspan=1>60.0± 0.6</td><td rowspan=1 colspan=1>63.3 ± 0.5</td></tr></table>",
+        "bbox": [
+            228,
+            102,
+            769,
+            150
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 3: Multiclass accuracy results on the standard supervised domain adaptation task with different feature dimensions in the source and target. The target domain is dslr for both cases. ",
+        "bbox": [
+            173,
+            166,
+            823,
+            195
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/cd2a6d6ced72450fd061139ea04f328f6403f6449b3407298308dd8ef987b51b.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>source</td><td rowspan=1 colspan=1>svms</td><td rowspan=1 colspan=1>arc-t</td><td rowspan=1 colspan=1>gfk</td><td rowspan=1 colspan=1>mmdt</td></tr><tr><td rowspan=1 colspan=1>amazon</td><td rowspan=1 colspan=1>10.3 ± 0.6</td><td rowspan=1 colspan=1>41.4 ± 0.3</td><td rowspan=1 colspan=1>38.9± 0.4</td><td rowspan=1 colspan=1>44.6 ± 0.3</td></tr><tr><td rowspan=1 colspan=1>webcam</td><td rowspan=1 colspan=1>51.6 ± 0.5</td><td rowspan=1 colspan=1>59.4 ± 0.4</td><td rowspan=1 colspan=1>62.9 ± 0.5</td><td rowspan=1 colspan=1>58.3 ± 0.5</td></tr></table>",
+        "bbox": [
+            276,
+            207,
+            720,
+            256
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 4: Multiclass accuracy results on the Office dataset for the domain shift of webcam dslr for target test categories not seen in at training time. Following the experimental setup of [12]. We compare against pmt-svm [10] and ARC-t [12] using both knn and svm classification. ",
+        "bbox": [
+            176,
+            265,
+            823,
+            308
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Standard Domain Adaptation Experiment For our first experiment, we use the Office+Caltech256 domain adaptation benchmark dataset to evaluate multi-class accuracy in the standard domain adaptation setting where a few labeled examples are available for all categories in the target domain. We follow the setup of [1] and [15]: 20 training examples for amazon source (8 for all other domains as source) and 3 labeled examples per category for the target domain. We created 20 random train/test splits and averaged results across them. ",
+        "bbox": [
+            173,
+            320,
+            825,
+            404
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The multi-class accuracy for each domain pair is shown in Table 2. Our method produced the highest multi-class accuracy for 9 out of 12 of the domain shifts and competitively on the other 3 shifts. This experiment demonstrates that our method achieves a high recognition performance and is able to outperform the most recent domain adaptation algorithms. Our method especially stands out in the settings where the domains are initially very different. The most similar domains in this dataset are webcam and ${ \\tt d s l r }$ and we see that our algorithm does not perform as well on those two shifts as gfk. This fits with our intuition since gfk is a 1-nearest neighbor approach and so is more suitable when the domains are initially similar. ",
+        "bbox": [
+            174,
+            411,
+            825,
+            523
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Additionally, an important observation is that our linear method on average outperforms all the baselines, even though they each learn a non-linear transformation. ",
+        "bbox": [
+            174,
+            530,
+            821,
+            558
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Asymmetric Transform Experiment Next, we analyze the effectiveness of our asymmetric transform learning by experimenting with the source and target having different feature dimensions. We use the same experimental setup as previously, but use the Office dataset and the alternate representation for the ${ \\tt d s l r }$ domain that is 600-dimensional (denoted as $\\mathsf { d s } \\mathtt { l r } - 6 0 0 \\rrangle$ ). We compare against $\\mathbf { s v m } _ { t }$ , arc-t and hfa, the baselines that can handle this scenario. The results are shown in Table 3. Again, we find that our method can effectively learn a feature representation for the target domain that optimizes the final classification objective. ",
+        "bbox": [
+            174,
+            563,
+            825,
+            660
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Generalizing to Novel Categories Experiment We next consider the setting of practical importance where labeled target examples are not available for all objects. Recall that this is a setting that many category specific adaptation methods cannot generalize to, including hfa [11]. Therefore, we compare our results for this setting to the arc-t [12] method which learns a category independent feature transform and the gfk [15] method which learns a category independent kernel to compare the domains. Following the experimental setup of [12], we use the full Office dataset and allow 20 labeled examples per category in the source for amazon and 10 labeled examples for the first 15 object categories in the target (dslr). For the webcam dslr shift, we use 8 labeled examples per category in the source for webcam and 4 labeled examples for the first 15 object categories in the target dslr. ",
+        "bbox": [
+            173,
+            665,
+            825,
+            804
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The experimental results for the domain shift of webcam dslr are evaluated and shown in Table 4; MMDT outperforms the baselines for the amazon dslr shift and offers adaptive benefit over $\\mathbf { s v m } _ { s }$ for the shift from webcam to dslr. As in the first experiment, both arc-t and gfk use nearest neighbor classifiers on a learned kernel are more suitable to the shift between webcam and dslr, which are initially very similar. ",
+        "bbox": [
+            174,
+            810,
+            823,
+            881
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Scaling to Larger Datasets Experiment With our last experiment we show that our method not only offers high accuracy performance it also scales well with an increasing dataset size. Specifically, the number of constraints our algorithm optimizes scales linearly with the number of training 45points. Conversely, the number of constraints that need to be optimized for the arc-t baseline is quadratic in the number of training points. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/40f89b388e5f8e9ec417c11fb5cdaa170ec5e747a42163d1e90ac8534d3dcdcd.jpg",
+        "image_caption": [
+            "Figure 2: Left: multiclass accuracy on the Bing dataset using 50 training examples in the source and 55varying the number of available labeled examples in the target. Right: training time comparison. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            101,
+            797,
+            299
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            361,
+            825,
+            404
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "To demonstrate the effect that constraint set size has on run-time performance, we use the Bing [21] 35dataset, which has a larger number of images in each domain than Office. The source domain has images from the Bing search engine and the target domain is from the Caltech256 benchmark. We 30run experiments using the first 20 categories and set the number of source examples per category to be 50. We use the train/test split from [21] and then vary the number of labeled target examples Number of Labeled Target Examplesavailable from 5 to 20. The left-hand plot in Figure 2 presents multi-class accuracy for this setup. Additionally, the training time of our method (run to convergence) and that of the baselines is shown on the right-hand plot. ",
+        "bbox": [
+            174,
+            410,
+            825,
+            522
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Our mmdt method provides a considerable improvement over all the baselines in terms of multiclass accuracy. It is also considerably faster than all but the gfk method. An important point to note is that both our method and arc-t scale approximately linearly with the number of target training points which is empirical verification for our claims. Note that hfa and gfk do not vary significantly as the number of target training points increases. However, for hfa the main bottleneck time is consumed by a distance computation between each pair of training points. Therefore, since there are many more source training points than target, adding a few more target points does not significantly increase the overall time spent for this experiment, but would present a problem as the size of the dataset grew in general. ",
+        "bbox": [
+            174,
+            529,
+            825,
+            655
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            667,
+            299,
+            685
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we presented a feature learning technique for domain adaptation that combines the ability of feature transform-based methods to perform multi-task adaptation with the performance benefits of directly adapting classifier parameters. ",
+        "bbox": [
+            176,
+            693,
+            823,
+            734
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We validated the computational efficiency and effectiveness of our method using two standard benchmarks used for image domain adaptation. Our experiments show that 1) our method is a competitive domain adaptation algorithm able to outperform previous methods, 2) is successfully able to generalize to novel target categories at test time, and 3) can learn asymmetric transformations. In addition, these benefits are offered through a framework that is scalable to larger datasets and achieves higher classification accuracy than previous approaches. ",
+        "bbox": [
+            174,
+            742,
+            825,
+            825
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "So far we have focused on linear transforms because of its speed and scalability; however, our method can also be kernelized to include nonlinear transforms. In future work, we would like to explore the kernelized version of our algorithm and especially experiment with the geodesic flow kernel as input to our algorithm. ",
+        "bbox": [
+            176,
+            833,
+            823,
+            888
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgements: This work was supported by NSF grants IIS-1116411 and IIS-1212798, DARPA, and the Toyota Corporation. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            267,
+            118
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "ECCV, 2010.   \n[2] A. Farhadi and M. K. Tabrizi. Learning to recognize activities from the wrong view point. In Proc. ECCV, 2008. [3] L. Duan, I. W. Tsang, D. Xu, and S. J. Maybank. Domain transfer svm for video concept detection. In CVPR, 2009.   \n[4] L. Duan, D. Xu, I. Tsang, and J. Luo. Visual event recognition in videos by learning from web data. In Proc. CVPR, 2010. [5] A. Torralba and A. Efros. Unbiased look at dataset bias. In Proc. CVPR, 2011.   \n[6] D. McAllester P. Felzenszwalb, R. Girshick and D. Ramanan. Object detection with discriminatively trained part based models. IEEE Transactions on Pattern Analysis and Machine Intelligence, 32(9), 2010.   \n[7] Lubomir Bourdev and Jitendra Malik. Poselets: Body part detectors trained using 3d human pose annotations. In Proc. ICCV, 2009. [8] J. Yang, R. Yan, and A. Hauptmann. Adapting svm classifiers to data with shifted distributions. In ICDM Workshops, 2007.   \n[9] X. Li. Regularized adaptation: Theory, algorithms and applications. In PhD thesis, University of Washington, USA, 2007.   \n[10] Y. Aytar and A. Zisserman. Tabula rasa: Model transfer for object category detection. In Proc. ICCV, 2011.   \n[11] Lixin Duan, Dong Xu, and Ivor W. Tsang. Learning with augmented features for heterogeneous domain adaptation. In Proc. ICML, 2012.   \n[12] B. Kulis, K. Saenko, and T. Darrell. What you saw is not what you get: Domain adaptation using asymmetric kernel transforms. In Proc. CVPR, 2011.   \n[13] R. Gopalan, R. Li, and R. Chellappa. Domain adaptation for object recognition: An unsupervised approach. In Proc. ICCV, 2011.   \n[14] W. Dai, Y. Chen, G. Xue, Q. Yang, and Y. Yu. Translated learning: Transfer learning across different feature spaces. In Proc. NIPS, 2008.   \n[15] B. Gong, Y. Shi, F. Sha, and K. Grauman. Geodesic flow kernel for unsupervised domain adaptation. In Proc. CVPR, 2012.   \n[16] J. Blitzer, M. Dredze, and F. Pereira. Biographies, bollywood, boom-boxes and blenders: Domain adaptation for sentiment classification. 2007.   \n[17] H. Daume III. Frustratingly easy domain adaptation. In Proc. ACL, 2007.   \n[18] S. Ben-david, J. Blitzer, K. Crammer, and O. Pereira. Analysis of representations for domain adaptation. In In NIPS. MIT Press, 2007.   \n[19] J. Jiang and C. X. Zhai. Instance weighting for domain adaptation in nlp. In Proceedings of the 45th Annual Meeting of the Association of Computational Linguistics, pages 264–271, 2007.   \n[20] J. Jiang. A literature survey on domain adaptation of statistical classifiers. http://sifaka.cs. uiuc.edu/jiang4/domain_adaptation/survey/.   \n[21] A. Bergamo and L. Torresani. Exploiting weakly-labeled web images to improve object classification: a domain adaptation approach. In Proc. NIPS, 2010.   \n[22] W. Jiang, E. Zavesky, S. Chang, and A. Loui. Cross-domain learning methods for high-level visual concept classification. In ICIP, 2008.   \n[23] Yoshua Bengio. Deep learning of representations for unsupervised and transfer learning. Journal of Machine Learning Research - Proceedings Track, 27:17–36, 2012.   \n[24] John Blitzer, Ryan McDonald, and Fernando Pereira. Domain adaptation with structural correspondence learning. In Proceedings of the 2006 Conference on Empirical Methods in Natural Language Processing, EMNLP ’06, pages 120–128, 2006.   \n[25] G. Griffin, A. Holub, and P. Perona. Caltech-256 object category dataset. Technical Report 7694, California Institute of Technology, 2007.   \n[26] Chih-Chung Chang and Chih-Jen Lin. LIBSVM: A library for support vector machines. ACM Transactions on Intelligent Systems and Technology, 2:27:1–27:27, 2011. Software available at http: //www.csie.ntu.edu.tw/˜cjlin/libsvm.   \n[27] Rong-En Fan, Kai-Wei Chang, Cho-Jui Hsieh, Xiang-Rui Wang, and Chih-Jen Lin. LIBLINEAR: A library for large linear classification. Journal of Machine Learning Research, 9:1871–1874, 2008. ",
+        "bbox": [
+            171,
+            142,
+            828,
+            920
+        ],
+        "page_idx": 8
+    }
+]

parse/train/BJC_jUqxe/BJC_jUqxe.md

@@ -0,0 +1,338 @@
+# A STRUCTURED SELF-ATTENTIVE SENTENCE EMBEDDING
+
+Zhouhan $\mathbf { L i n } ^ { \dagger \circ }$ ∗, Minwei Feng, Cicero Nogueira dos Santos, Mo $\mathbf { V } \mathbf { u } ^ { \circ }$ , Bing Xiang, Bowen Zhou & Yoshua Bengio‡†
+
+IBM Watson   
+‡Montreal Institute for Learning Algorithms (MILA), Universite de Montr ´ eal ´   
+†CIFAR Senior Fellow   
+lin.zhouhan@gmail.com   
+{mfeng, cicerons, yum, bingxia, zhou}@us.ibm.com
+
+# ABSTRACT
+
+This paper proposes a new model for extracting an interpretable sentence embedding by introducing self-attention. Instead of using a vector, we use a 2-D matrix to represent the embedding, with each row of the matrix attending on a different part of the sentence. We also propose a self-attention mechanism and a special regularization term for the model. As a side effect, the embedding comes with an easy way of visualizing what specific parts of the sentence are encoded into the embedding. We evaluate our model on 3 different tasks: author profiling, sentiment classification and textual entailment. Results show that our model yields a significant performance gain compared to other sentence embedding methods in all of the 3 tasks.
+
+# 1 INTRODUCTION
+
+Much progress has been made in learning semantically meaningful distributed representations of individual words, also known as word embeddings (Bengio et al., 2001; Mikolov et al., 2013). On the other hand, much remains to be done to obtain satisfying representations of phrases and sentences. Those methods generally fall into two categories. The first consists of universal sentence embeddings usually trained by unsupervised learning (Hill et al., 2016). This includes SkipThought vectors (Kiros et al., 2015), ParagraphVector (Le & Mikolov, 2014), recursive auto-encoders (Socher et al., 2011; 2013), Sequential Denoising Autoencoders (SDAE), FastSent (Hill et al., 2016), etc.
+
+The other category consists of models trained specifically for a certain task. They are usually combined with downstream applications and trained by supervised learning. One generally finds that specifically trained sentence embeddings perform better than generic ones, although generic ones can be used in a semi-supervised setting, exploiting large unlabeled corpora. Several models have been proposed along this line, by using recurrent networks (Hochreiter & Schmidhuber, 1997; Chung et al., 2014), recursive networks (Socher et al., 2013) and convolutional networks (Kalchbrenner et al., 2014; dos Santos & Gatti, 2014; Kim, 2014) as an intermediate step in creating sentence representations to solve a wide variety of tasks including classification and ranking (Yin & Schutze, ¨ 2015; Palangi et al., 2016; Tan et al., 2016; Feng et al., 2015). A common approach in previous methods consists in creating a simple vector representation by using the final hidden state of the RNN or the max (or average) pooling from either RNNs hidden states or convolved n-grams. Additional works have also been done in exploiting linguistic structures such as parse and dependence trees to improve sentence representations (Ma et al., 2015; Mou et al., 2015b; Tai et al., 2015).
+
+For some tasks people propose to use attention mechanism on top of the CNN or LSTM model to introduce extra source of information to guide the extraction of sentence embedding (dos Santos et al., 2016). However, for some other tasks like sentiment classification, this is not directly applicable since there is no such extra information: the model is only given one single sentence as input. In those cases, the most common way is to add a max pooling or averaging step across all time steps (Lee & Dernoncourt, 2016), or just pick up the hidden representation at the last time step as the encoded embedding (Margarit & Subramaniam, 2016).
+
+![](images/60681ffc941822535da20ab69058a148910ef62a2ce6c2d7c0ce089c4d576168.jpg)  
+Figure 1: A sample model structure showing the sentence embedding model combined with a fully connected and softmax layer for sentiment analysis (a). The sentence embedding $M$ is computed as multiple weighted sums of hidden states from a bidirectional LSTM $( \mathbf { h _ { 1 } } , . . . , \mathbf { h _ { n } } )$ , where the summation weights $( A _ { i 1 } , . . . , A _ { i n } )$ are computed in a way illustrated in (b). Blue colored shapes stand for hidden representations, and red colored shapes stand for weights, annotations, or input/output.
+
+A common approach in many of the aforementioned methods consists of creating a simple vector representation by using the final hidden state of the RNN or the max (or average) pooling from either RNNs hidden states or convolved n-grams. We hypothesize that carrying the semantics along all time steps of a recurrent model is relatively hard and not necessary. We propose a self-attention mechanism for these sequential models to replace the max pooling or averaging step. Different from previous approaches, the proposed self-attention mechanism allows extracting different aspects of the sentence into multiple vector representations. It is performed on top of an LSTM in our sentence embedding model. This enables attention to be used in those cases when there are no extra inputs. In addition, due to its direct access to hidden representations from previous time steps, it relieves some long-term memorization burden from LSTM. As a side effect coming together with our proposed self-attentive sentence embedding, interpreting the extracted embedding becomes very easy and explicit.
+
+Section 2 details on our proposed self-attentive sentence embedding model, as well as a regularization term we proposed for this model, which is described in Section 2.2. We also provide a visualization method for this sentence embedding in section 2.3. We then evaluate our model in author profiling, sentiment classification and textual entailment tasks in Section 4.
+
+# 2 APPROACH
+
+# 2.1 MODEL
+
+The proposed sentence embedding model consists of two parts. The first part is a bidirectional LSTM, and the second part is the self-attention mechanism, which provides a set of summation weight vectors for the LSTM hidden states. These set of summation weight vectors are dotted with the LSTM hidden states, and the resulting weighted LSTM hidden states are considered as an embedding for the sentence. It can be combined with, for example, a multilayer perceptron to be applied on a downstream application. Figure 1 shows an example when the proposed sentence embedding model is applied to sentiment analysis, combined with a fully connected layer and a softmax layer. Besides using a fully connected layer, we also proposes an approach that prunes weight connections by utilizing the 2-D structure of matrix sentence embedding, which is detailed in Appendix A. For this section, we will use Figure 1 to describe our model.
+
+Suppose we have a sentence, which has $n$ tokens, represented in a sequence of word embeddings.
+
+$$
+S = \left( \mathbf { w _ { 1 } } , \mathbf { w _ { 2 } } , \cdot \cdot \cdot \mathbf { w _ { n } } \right)
+$$
+
+Here $w _ { i }$ is a vector standing for a $d$ dimentional word embedding for the $i$ -th word in the sentence. $S$ is thus a sequence represented as a 2-D matrix, which concatenates all the word embeddings together. $S$ should have the shape $n$ -by- $d$ .
+
+Now each entry in the sequence $S$ are independent with each other. To gain some dependency between adjacent words within a single sentence, we use a bidirectional LSTM to process the sentence:
+
+$$
+\begin{array} { r } { \overrightarrow { h _ { t } } = \overrightarrow { L S T M } ( w _ { t } , \overrightarrow { h _ { t - 1 } } ) } \\ { \overleftarrow { h _ { t } } = \overleftarrow { L S T M } ( w _ { t } , \overbrace { h _ { t + 1 } } ) } \end{array}
+$$
+
+And we concatenate each $\overrightarrow { h _ { t } }$ with $\left\{ { { \overline { { h _ { t } } } } } \right.$ to obtain a hidden state $h _ { t }$ . Let the hidden unit number for each unidirectional LSTM be $u$ . For simplicity, we note all the n $h _ { t } \mathbf { s }$ as $H$ , who have the size $n$ -by- $_ { 2 u }$ .
+
+$$
+H = ( \mathbf { h _ { 1 } } , \mathbf { h _ { 2 } } , \cdot \cdot \cdot \mathbf { h _ { n } } )
+$$
+
+Our aim is to encode a variable length sentence into a fixed size embedding. We achieve that by choosing a linear combination of the $n$ LSTM hidden vectors in $H$ . Computing the linear combination requires the self-attention mechanism. The attention mechanism takes the whole LSTM hidden states $H$ as input, and outputs a vector of weights $\mathbf { a }$ :
+
+$$
+\mathbf { a } = s o f t m a x \left( \mathbf { w _ { s 2 } } t a n h \left( W _ { s 1 } H ^ { T } \right) \right)
+$$
+
+Here $W _ { s 1 }$ is a weight matrix with a shape of $d _ { a }$ -by- $_ { 2 u }$ . and ${ \bf w _ { s 2 } }$ is a vector of parameters with size $d _ { a }$ , where $d _ { a }$ is a hyperparameter we can set arbitrarily. Since $H$ is sized $n$ -by- $_ { 2 u }$ , the annotation vector $a$ will have a size $n$ . the $s o f t m a x ( )$ ensures all the computed weights sum up to 1. Then we sum up the LSTM hidden states $H$ according to the weight provided by a to get a vector representation $\mathbf { m }$ of the input sentence.
+
+This vector representation usually focuses on a specific component of the sentence, like a special set of related words or phrases. So it is expected to reflect an aspect, or component of the semantics in a sentence. However, there can be multiple components in a sentence that together forms the overall semantics of the whole sentence, especially for long sentences. (For example, two clauses linked together by an ”and.”) Thus, to represent the overall semantics of the sentence, we need multiple m’s that focus on different parts of the sentence. Thus we need to perform multiple hops of attention. Say we want $r$ different parts to be extracted from the sentence, with regard to this, we extend the ${ \bf w _ { s 2 } }$ into a $r$ -by- $\cdot d _ { a }$ matrix, note it as $W _ { s 2 }$ , and the resulting annotation vector a becomes annotation matrix $A$ . Formally,
+
+$$
+A = s o f t m a x \left( W _ { s 2 } t a n h \left( W _ { s 1 } H ^ { T } \right) \right)
+$$
+
+Here the sof tmax $( )$ is performed along the second dimension of its input. We can deem Equation 6 as a 2-layer MLP without bias, whose hidden unit numbers is $d _ { a }$ , and parameters are $\{ W _ { s 2 } , \mathbf { \bar { W } } _ { s 1 } \}$ .
+
+The embedding vector $m$ then becomes an $r$ -by- $_ { 2 u }$ embedding matrix $M$ . We compute the $r$ weighted sums by multiplying the annotation matrix $A$ and LSTM hidden states $H$ , the resulting matrix is the sentence embedding:
+
+$$
+M = A H
+$$
+
+# 2.2 PENALIZATION TERM
+
+The embedding matrix $M$ can suffer from redundancy problems if the attention mechanism always provides similar summation weights for all the $r$ hops. Thus we need a penalization term to encourage the diversity of summation weight vectors across different hops of attention.
+
+The best way to evaluate the diversity is definitely the Kullback Leibler divergence between any 2 of the summation weight vectors. However, we found that not very stable in our case. We conjecture it is because we are maximizing a set of KL divergence (instead of minimizing only one, which is the usual case), we are optimizing the annotation matrix A to have a lot of sufficiently small or even zero values at different softmax output units, and these vast amount of zeros is making the training unstable. There is another feature that KL doesn’t provide but we want, which is, we want each individual row to focus on a single aspect of semantics, so we want the probability mass in the annotation softmax output to be more focused. but with KL penalty we cant encourage that.
+
+We hereby introduce a new penalization term which overcomes the aforementioned shortcomings. Compared to the KL divergence penalization, this term consumes only one third of the computation. We use the dot product of $A$ and its transpose, subtracted by an identity matrix, as a measure of redundancy.
+
+$$
+\boldsymbol { P } = \left\| \left( \boldsymbol { A } \boldsymbol { A } ^ { T } - \boldsymbol { I } \right) \right\| _ { F } ^ { 2 }
+$$
+
+Here $\| \bullet \| _ { F }$ stands for the Frobenius norm of a matrix. Similar to adding an L2 regularization term, this penalization term $P$ will be multiplied by a coefficient, and we minimize it together with the original loss, which is dependent on the downstream application.
+
+Let’s consider two different summation vectors $\mathbf { a ^ { i } }$ and $\mathbf { a } ^ { \mathbf { j } }$ in $A$ . Because of the softmax, all entries within any summation vector in $A$ should sum up to 1. Thus they can be deemed as probability masses in a discrete probability distribution. For any non-diagonal elements $a _ { i j } ( i \neq j )$ in the $A A ^ { \check { T } }$ matrix, it corresponds to a summation over elementwise product of two distributions:
+
+$$
+0 < a _ { i j } = \sum _ { k = 1 } ^ { n } a _ { k } ^ { i } a _ { k } ^ { j } < 1
+$$
+
+where $a _ { k } ^ { i }$ and $a _ { k } ^ { j }$ are the $k$ -th element in the $\mathbf { a } ^ { \mathbf { i } }$ and $\mathbf { a } ^ { \mathbf { j } }$ vectors, respectively. In the most extreme case, where there is no overlap between the two probability distributions $\mathbf { a } ^ { \mathbf { i } }$ and $\mathbf { a } ^ { \mathbf { j } }$ , the correspond $a _ { i j }$ will be 0. Otherwise, it will have a positive value. On the other extreme end, if the two distributions are identical and all concentrates on one single word, it will have a maximum value of 1. We subtract an identity matrix from $A A ^ { T }$ so that forces the elements on the diagonal of $A A ^ { T }$ to approximate 1, which encourages each summation vector $\mathbf { a } ^ { \mathbf { i } }$ to focus on as few number of words as possible, forcing each vector to be focused on a single aspect, and all other elements to 0, which punishes redundancy between different summation vectors.
+
+# 2.3 VISUALIZATION
+
+The interpretation of the sentence embedding is quite straight forward because of the existence of annotation matrix $A$ . For each row in the sentence embedding matrix $M$ , we have its corresponding annotation vector $\mathbf { a ^ { i } }$ . Each element in this vector corresponds to how much contribution the LSTM hidden state of a token on that position contributes to. We can thus draw a heat map for each row of the embedding matrix $M$ This way of visualization gives hints on what is encoded in each part of the embedding, adding an extra layer of interpretation. (See Figure 3a and 3b).
+
+The second way of visualization can be achieved by summing up over all the annotation vectors, and then normalizing the resulting weight vector to sum up to 1. Since it sums up all aspects of semantics of a sentence, it yields a general view of what the embedding mostly focuses on. We can figure out which words the embedding takes into account a lot, and which ones are skipped by the embedding. See Figure 3c and 3d.
+
+# 3 RELATED WORK
+
+Various supervised and unsupervised sentence embedding models have been mentioned in Section 1. Different from those models, our proposed method uses a new self-attention mechanism that allows it to extract different aspects of the sentence into multiple vector-representations. The matrix structure together with the penalization term gives our model a greater capacity to disentangle the latent information from the input sentence. We also do not use linguistic structures to guide our sentence representation model. Additionally, using our method we can easily create visualizations that can help in the interpretation of the learned representations.
+
+Some recent work have also proposed supervised methods that use intra/self-sentence attention. Ling et al. (2015) proposed an attention based model for word embedding, which calculates an attention weight for each word at each possible position in the context window. However this method cannot be extended to sentence level embeddings since one cannot exhaustively enumerate all possible sentences. Liu et al. (2016a) proposes a sentence level attention which has a similar motivation but done differently. They utilize the mean pooling over LSTM states as the attention source, and use that to re-weight the pooled vector representation of the sentence.
+
+Apart from the previous 2 variants, we want to note that Li et al. (2016) proposed a same self attention mechanism for question encoding in their factoid QA model, which is concurrent to our work. The difference lies in that their encoding is still presented as a vector, but our attention produces a matrix representation instead, with a specially designed penalty term. We applied the model for sentiment anaysis and entailment, and their model is for factoid QA.
+
+The LSTMN model (Cheng et al., 2016) also proposed a very successful intra-sentence level attention mechanism, which is later used by Parikh et al. (2016). We see our attention and theirs as having different granularities. LSTMN produces an attention vector for each of its hidden states during the recurrent iteration, which is sort of an ”online updating” attention. It’s more fine-grained, targeting at discovering lexical correlations between a certain word and its previous words. On the contrary, our attention mechanism is only performed once, focuses directly on the semantics that makes sense for discriminating the targets. It is less focused on relations between words, but more on the semantics of the whole sentence that each word contributes to. Computationally, our method also scales up with the sentence length better, since it doesn’t require the LSTM to compute an annotation vector over all of its previous words each time when the LSTMN computes its next step.
+
+# 4 EXPERIMENTAL RESULTS
+
+We first evaluate our sentence embedding model by applying it to 3 different datasets: the Age dataset, the Yelp dataset, and the Stanford Natural Language Inference (SNLI) Corpus. These 3 datasets fall into 3 different tasks, corresponding to author profiling, sentiment analysis, and textual entailment, respectively. Then we also perform a set of exploratory experiments to validate properties of various aspects for our sentence embedding model.
+
+# 4.1 AUTHOR PROFILING
+
+The Author Profiling dataset1 consists of Twitter tweets in English, Spanish, and Dutch. For some of the tweets, it also provides an age and gender of the user when writing the tweet. The age range are split into 5 classes: 18-24, 25-34, 35-49, 50-64, $6 5 +$ . We use English tweets as input, and use those tweets to predict the age range of the user. Since we are predicting the age of users, we refer to it as Age dataset in the rest of our paper. We randomly selected 68485 tweets as training set, 4000 for development set, and 4000 for test set. Performances are also chosen to be classification accuracy.
+
+We compare our model with two baseline models: biLSTM and CNN. For the two baseline models. The biLSTM model uses a bidirectional LSTM with 300 dimensions in each direction, and use max pooling across all LSTM hidden states to get the sentence embedding vector, then use a 2-layer ReLU output MLP with 3000 hidden states to output the classification result. The CNN model uses the same scheme, but substituting biLSTM with 1 layer of 1-D convolutional network. During training we use 0.5 dropout on the MLP and 0.0001 L2 regularization. We use stochastic gradient descent as the optimizer, with a learning rate of 0.06, batch size 16. For biLSTM, we also clip the norm of gradients to be between -0.5 and 0.5. We searched hyperparameters in a wide range and find the aforementioned set of hyperparameters yields the highest accuracy.
+
+For our model, we use the same settings as what we did in biLSTM. We also use a 2-layer ReLU output MLP, but with 2000 hidden units. In addition, our self-attention MLP has a hidden layer with 350 units (the $d _ { a }$ in Section 2), we choose the matrix embedding to have 30 rows (the $r$ ), and a coefficient of 1 for the penalization term.
+
+Table 1: Performance Comparision of Different Models on Yelp and Age Dataset   
+
+<table><tr><td>Models</td><td>Yelp</td><td>Age</td></tr><tr><td>BiLSTM + Max Pooling + MLP</td><td>61.99%</td><td>77.40%</td></tr><tr><td>CNN+Max Pooling+MLP</td><td>62.05%</td><td>78.15%</td></tr><tr><td>Our Model</td><td>64.21%</td><td>80.45%</td></tr></table>
+
+We train all the three models until convergence and select the corresponding test set performance according to the best development set performance. Our results show that the model outperforms both of the biLSTM and CNN baselines by a significant margin.
+
+![](images/f74f85ffe002204ab5a7ab119e1c1ee8e94e9f6456e7bc24df8dd1badc45d622.jpg)  
+Figure 2: Heatmap of Yelp reviews with the two extreme score.
+
+# 4.2 SENTIMENT ANALYSIS
+
+We choose the Yelp dataset2 for sentiment analysis task. It consists of 2.7M yelp reviews, we take the review as input and predict the number of stars the user who wrote that review assigned to the corresponding business store. We randomly select 500K review-star pairs as training set, and 2000 for development set, 2000 for test set. We tokenize the review texts by Stanford tokenizer. We use 100 dimensional word2vec as initialization for word embeddings, and tune the embedding during training across all of our experiments. The target number of stars is an integer number in the range of [1, 5], inclusive. We are treating the task as a classification task, i.e., classify a review text into one of the 5 classes. We use classification accuracy as a measurement.
+
+For the two baseline models, we use the same setting as what we used for Author Profiling dataset, except that we are using a batch size of 32 instead. For our model, we are also using the same setting, except that we choose the hidden unit numbers in the output MLP to be 3000 instead. We also observe a significant performance gain comparining to the two baselines. (Table 1)
+
+As an interpretation of the learned sentence embedding, we use the second way of visualization described in Section 2.3 to plot heat maps for some of the reviews in the dataset. We randomly select 5 examples of negative (1 star) and positive (5 stars) reviews from the test set, when the model has a high confidence $( > 0 . 8 )$ in predicting the label. As shown in Figure 2, we find that the model majorly learns to capture some key factors in the review that indicate strongly on the sentiment behind the sentence. For most of the short reviews, the model manages to capture all the key factors that contribute to an extreme score, but for longer reviews, the model is still not able to capture all related factors. For example, in the 3rd review in Figure 2b), it seems that a lot of focus is spent on one single factor, i.e., the ”so much fun”, and the model puts a little amount of attention on other key points like ”highly recommend”, ”amazing food”, etc.
+
+# 4.3 TEXTUAL ENTAILMENT
+
+We use the biggest dataset in textual entailment, the SNLI corpus (Bowman et al., 2015) for our evaluation on this task. SNLI is a collection of 570k human-written English sentence pairs manually labeled for balanced classification with the labels entailment, contradiction, and neutral. The model will be given a pair of sentences, called hypothesis and premise respectively, and asked to tell if the semantics in the two sentences are contradicting with each other or not. It is also a classification task, so we measure the performance by accuracy.
+
+We process the hypothesis and premise independently, and then extract the relation between the two sentence embeddings by using multiplicative interactions proposed in Memisevic (2013) (see Appendix B for details), and use a 2-layer ReLU output MLP with 4000 hidden units to map the hidden representation into classification results. Parameters of biLSTM and attention MLP are shared across hypothesis and premise. The biLSTM is 300 dimension in each direction, the attention MLP has 150 hidden units instead, and both sentence embeddings for hypothesis and premise have 30 rows (the $r$ ). The penalization term coefficient is set to 0.3. We use 300 dimensional GloVe (Pennington et al., 2014) word embedding to initialize word embeddings. We use AdaGrad as the optimizer, with a learning rate of 0.01. We don’t use any extra regularization methods, like dropout or L2 normalization. Training converges after 4 epochs, which is relatively fast.
+
+This task is a bit different from previous two tasks, in that it has 2 sentences as input. There are a bunch of ways to add inter-sentence level attention, and those attentions bring a lot of benefits. To make the comparison focused and fair, we only compare methods that fall into the sentence encoding-based models. i.e., there is no information exchanged between the hypothesis and premise before they are encoded into some distributed encoding.
+
+Table 2: Test Set Performance Compared to other Sentence Encoding Based Methods in SNLI Datset   
+
+<table><tr><td>Model</td><td>Test Accuracy</td></tr><tr><td>300DLSTM encoders (Bowman et al., 2016)</td><td>80.6%</td></tr><tr><td>600D (300+300) BiLSTM encoders (Liu et al.,2016b)</td><td>83.3%</td></tr><tr><td> 300D Tree-based CNN encoders (Mou et al., 2015a)</td><td>82.1%</td></tr><tr><td>300D SPINN-PI encoders (Bowman et al., 2016)</td><td>83.2%</td></tr><tr><td>300D NTI-SLSTM-LSTM encoders (Munkhdalai &amp; Yu,2016a)</td><td>83.4%</td></tr><tr><td>1024D GRU encoders with SkipThoughts pre-training (Vendrov et al., 2015)</td><td>81.4%</td></tr><tr><td>300D NSE encoders (Munkhdalai &amp; Yu,2016b)</td><td>84.6%</td></tr><tr><td>Ourmethod</td><td>84.4%</td></tr></table>
+
+We find that compared to other published approaches, our method shows a significant gain $( \geq 1 \% )$ to them, except for the 300D NSE encoders, which is the state-of-the-art in this category. However, the $0 . 2 \%$ different is relatively small compared to the differences between other methods.
+
+# 4.4 EXPLORATORY EXPERIMENTS
+
+In this subsection we are going to do a set of exploratory experiments to study the relative effect of each component in our model.
+
+# 4.4.1 EFFECT OF PENALIZATION TERM
+
+Since the purpose of introducing the penalization term $P$ is majorly to discourage the redundancy in the embedding, we first directly visualize the heat maps of each row when the model is presented with a sentence. We compare two identical models with the same size as detailed in Section 4.1 trained separately on Age dataset, one with this penalization term (where the penalization coefficient is set to 1.0) and the other with no penalty. We randomly select one tweet from the test set and compare the two models by plotting a heat map for each hop of attention on that single tweet. Since there are 30 hops of attention for each model, which makes plotting all of them quite redundant, we only plot 6 of them. These 6 hops already reflect the situation in all of the 30 hops.
+
+![](images/3063df46fa169ad74f2bf5325c236c0cb983c5420197166d28d806198fca0206.jpg)
+
+Figure 3: Heat maps for 2 models trained on Age dataset. The left column is trained without the penalization term, and the right column is trained with 1.0 penalization. (a) and (b) shows detailed attentions taken by 6 out of 30 rows of the matrix embedding, while (c) and (d) shows the overall attention by summing up all 30 attention weight vectors.
+
+![](images/89bf44b778e1ce2a54bd5f742c83b4577b52f97c87756d6e14dd2bbfadeca00c.jpg)
+
+Figure 4: Attention of sentence embedding on 3 different Yelp reviews. The left one is trained without penalization, and the right one is trained with 1.0 penalization.
+
+Table 3: Performance comparision regarding the penalization term   
+
+<table><tr><td>Penalization coefficient</td><td>Yelp</td><td>Age</td></tr><tr><td>1.0</td><td>64.21%</td><td>80.45%</td></tr><tr><td>0.0</td><td>61.74%</td><td>79.27%</td></tr></table>
+
+From the figure we can tell that the model trained without the penalization term have lots of redundancies between different hops of attention (Figure 3a), resulting in putting lot of focus on the word ”it” (Figure 3c), which is not so relevant to the age of the author. However in the right column, the model shows more variations between different hops, and as a result, the overall embedding focuses on ”mail-replies spam” instead. (Figure 3d)
+
+For the Yelp dataset, we also observe a similar phenomenon. To make the experiments more explorative, we choose to plot heat maps of overall attention heat maps for more samples, instead of plotting detailed heat maps for a single sample again. Figure 4 shows overall focus of the sentence embedding on three different reviews. We observe that with the penalization term, the model tends to be more focused on important parts of the review. We think it is because that we are encouraging it to be focused, in the diagonals of matrix $A A ^ { T }$ (Equation 8).
+
+To validate if these differences result in performance difference, we evaluate four models trained on Yelp and Age datasets, both with and without the penalization term. Results are shown in Table 3. Consistent with what expected, models trained with the penalization term outperforms their counterpart trained without.
+
+In SNLI dataset, although we observe that introducing the penalization term still contributes to encouraging the diversity of different rows in the matrix sentence embedding, and forcing the network to be more focused on the sentences, the quantitative effect of this penalization term is not so obvious on SNLI dataset. Both models yield similar test set accuracies.
+
+# 4.4.2 EFFECT OF MULTIPLE VECTORS
+
+Having multiple rows in the sentence embedding is expected to provide more abundant information about the encoded content. It makes sence to evaluate how significant the improvement can be brought by $r$ . Taking the models we used for Age and SNLI dataset as an example, we vary $r$ from 1 to 30 for each task, and train the resulting 10 models independently (Figure 5). Note that when $r = 1$ , the sentence embedding reduces to a normal vector form.
+
+From this figure we can find that, without having multiple rows, the model performs on-par with its competitiors which use other forms of vector sentence embeddings. But there is significant difference between having only one vector for the sentence embedding and multiple vectors. The models are also quite invariant with respect to $r$ , since in the two figures a wide range of values between 10 to 30 are all generating comparable curves.
+
+![](images/51b6ec69cc29def6c6745dec2737bece1e9dab0778bae6cf51d528dd609d0b63.jpg)  
+Figure 5: Effect of the number of rows $( r )$ in matrix sentence embedding. The vertical axes indicates test set accuracy and the horizontal axes indicates training epoches. Numbers in the legends stand for the corresponding values of $r$ . (a) is conducted in Age dataset and (b) is conducted in SNLI dataset.
+
+# 5 CONCLUSION AND DISCUSSION
+
+In this paper, we introduced a fixed size, matrix sentence embedding with a self-attention mechanism. Because of this attention mechanism, there is a way to interpret the sentence embedding in depth in our model. Experimental results over 3 different tasks show that the model outperforms other sentence embedding models by a significant margin.
+
+Introducing attention mechanism allows the final sentence embedding to directly access previous LSTM hidden states via the attention summation. Thus the LSTM doesn’t need to carry every piece of information towards its last hidden state. Instead, each LSTM hidden state is only expected to provide shorter term context information around each word, while the higher level semantics, which requires longer term dependency, can be picked up directly by the attention mechanism. This setting reliefs the burden of LSTM to carry on long term dependencies. Our experiments also support that, as we observed that our model has a bigger advantage when the contents are longer. Further more, the notion of summing up elements in the attention mechanism is very primitive, it can be something more complex than that, which will allow more operations on the hidden states of LSTM.
+
+The model is able to encode any sequence with variable length into a fixed size representation, without suffering from long-term dependency problems. This brings a lot of scalability to the model: without any modification, it can be applied directly to longer contents like paragraphs, articles, etc. Though this is beyond the focus of this paper, it remains an interesting direction to explore as a future work.
+
+As a downside of our proposed model, the current training method heavily relies on downstream applications, thus we are not able to train it in an unsupervised way. The major obstacle towards enabling unsupervised learning in this model is that during decoding, we don’t know as prior how the different rows in the embedding should be divided and reorganized. Exploring all those possible divisions by using a neural network could easily end up with overfitting. Although we can still do unsupervised learning on the proposed model by using a sequential decoder on top of the sentence embedding, it merits more to find some other structures as a decoder.
+
+# ACKNOWLEDGMENTS
+
+The authors would like to acknowledge the developers of Theano (Theano Development Team, 2016) and Lasagne. The first author would also like to thank IBM Watson for providing resources, fundings and valuable discussions to make this project possible, and Caglar Gulcehre for helpful discussions.
+
+# REFERENCES
+
+Yoshua Bengio, Rejean Ducharme, and Pascal Vincent. A neural probabilistic language model. In ´ Advances in Neural Information Processing Systems, pp. 932–938, 2001.
+
+Samuel R Bowman, Gabor Angeli, Christopher Potts, and Christopher D Manning. A large annotated corpus for learning natural language inference. arXiv preprint arXiv:1508.05326, 2015.
+
+Samuel R Bowman, Jon Gauthier, Abhinav Rastogi, Raghav Gupta, Christopher D Manning, and Christopher Potts. A fast unified model for parsing and sentence understanding. arXiv preprint arXiv:1603.06021, 2016.
+
+Jianpeng Cheng, Li Dong, and Mirella Lapata. Long short-term memory-networks for machine reading. In Conference on Empirical Methods in Natural Language Processing (EMNLP). Association for Computational Linguistics, 2016.
+
+Junyoung Chung, Caglar Gulcehre, KyungHyun Cho, and Yoshua Bengio. Empirical evaluation of gated recurrent neural networks on sequence modeling. arXiv preprint arXiv:1412.3555, 2014.
+
+Cicero dos Santos and Maira Gatti. Deep convolutional neural networks for sentiment analysis of short texts. In Proceedings of COLING 2014, the 25th International Conference on Computational Linguistics: Technical Papers, pp. 69–78, 2014.
+
+Cicero dos Santos, Ming Tan, Bing Xiang, and Bowen Zhou. Attentive pooling networks. arXiv preprint arXiv:1602.03609, 2016.
+
+Minwei Feng, Bing Xiang, Michael R. Glass, Lidan Wang, and Bowen Zhou. Applying deep learning to answer selection: a study and an open task. In 2015 IEEE Workshop on Automatic Speech Recognition and Understanding, ASRU 2015, Scottsdale, AZ, USA, December 13-17, 2015, pp. 813–820, 2015.
+
+Felix Hill, Kyunghyun Cho, and Anna Korhonen. Learning distributed representations of sentences from unlabelled data. In Proceedings of the 2016 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, pp. 1367– 1377, San Diego, California, June 2016. Association for Computational Linguistics. URL http: //www.aclweb.org/anthology/N16-1162.
+
+Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural computation, 9(8): 1735–1780, 1997.
+
+Nal Kalchbrenner, Edward Grefenstette, and Phil Blunsom. A convolutional neural network for modelling sentences. arXiv preprint arXiv:1404.2188, 2014.
+
+Yoon Kim. Convolutional neural networks for sentence classification. arXiv preprint arXiv:1408.5882, 2014.
+
+Ryan Kiros, Yukun Zhu, Ruslan R Salakhutdinov, Richard Zemel, Raquel Urtasun, Antonio Torralba, and Sanja Fidler. Skip-thought vectors. In Advances in neural information processing systems, pp. 3294–3302, 2015.
+
+Quoc V Le and Tomas Mikolov. Distributed representations of sentences and documents. In ICML, volume 14, pp. 1188–1196, 2014.
+
+Ji Young Lee and Franck Dernoncourt. Sequential short-text classification with recurrent and convolutional neural networks. arXiv preprint arXiv:1603.03827, 2016.
+
+Peng Li, Wei Li, Zhengyan He, Xuguang Wang, Ying Cao, Jie Zhou, and Wei Xu. Dataset and neural recurrent sequence labeling model for open-domain factoid question answering. arXiv preprint arXiv:1607.06275, 2016.
+
+Wang Ling, Lin Chu-Cheng, Yulia Tsvetkov, and Silvio Amir. Not all contexts are created equal: Better word representations with variable attention. In Proceedings of the 2015 Conference on Empirical Methods in Natural Language Processing, pp. 1367–1372, Lisbon, Portugal, September 2015. Association for Computational Linguistics.
+
+Yang Liu, Chengjie Sun, Lei Lin, and Xiaolong Wang. Learning natural language inference using bidirectional LSTM model and inner-attention. CoRR, abs/1605.09090, 2016a.
+
+Yang Liu, Chengjie Sun, Lei Lin, and Xiaolong Wang. Learning natural language inference using bidirectional lstm model and inner-attention. arXiv preprint arXiv:1605.09090, 2016b.
+
+Mingbo Ma, Liang Huang, Bing Xiang, and Bowen Zhou. Dependency-based convolutional neural networks for sentence embedding. In Proceedings of the 53rd Annual Meeting of the Association for Computational Linguistics and the 7th International Joint Conference on Natural Language Processing, volume 2, pp. 174–179, 2015.
+
+Horia Margarit and Raghav Subramaniam. A batch-normalized recurrent network for sentiment classification. In Advances in Neural Information Processing Systems, 2016.
+
+Roland Memisevic. Learning to relate images. IEEE transactions on pattern analysis and machine intelligence, 35(8):1829–1846, 2013.
+
+Tomas Mikolov, Kai Chen, Greg Corrado, and Jeffrey Dean. Efficient estimation of word representations in vector space. arXiv preprint arXiv:1301.3781, 2013.
+
+Lili Mou, Rui Men, Ge Li, Yan Xu, Lu Zhang, Rui Yan, and Zhi Jin. Natural language inference by tree-based convolution and heuristic matching. arXiv preprint arXiv:1512.08422, 2015a.
+
+Lili Mou, Hao Peng, Ge Li, Yan Xu, Lu Zhang, and Zhi Jin. Discriminative neural sentence modeling by tree-based convolution. In Proceedings of the 2015 Conference on Empirical Methods in Natural Language Processing, pp. 2315–2325, Lisbon, Portugal, September 2015b. Association for Computational Linguistics. URL http://aclweb.org/anthology/D15-1279.
+
+Tsendsuren Munkhdalai and Hong Yu. Neural tree indexers for text understanding. arXiv preprint arXiv:1607.04492, 2016a.
+
+Tsendsuren Munkhdalai and Hong Yu. Neural semantic encoders. arXiv preprint arXiv:1607.04315, 2016b.
+
+Hamid Palangi, Li Deng, Yelong Shen, Jianfeng Gao, Xiaodong He, Jianshu Chen, Xinying Song, and Rabab Ward. Deep sentence embedding using long short-term memory networks: Analysis and application to information retrieval. IEEE/ACM Transactions on Audio, Speech, and Language Processing, 24(4):694–707, 2016.
+
+Ankur P. Parikh, Oscar Tackstrom, Dipanjan Das, and Jakob Uszkoreit. A decomposable attention model for natural language inference. In Proceedings of EMNLP, 2016.
+
+Jeffrey Pennington, Richard Socher, and Christopher D Manning. Glove: Global vectors for word representation. In EMNLP, volume 14, pp. 1532–43, 2014.
+
+Richard Socher, Jeffrey Pennington, Eric H. Huang, Andrew Y. Ng, and Christopher D. Manning. Semi-supervised recursive autoencoders for predicting sentiment distributions. In Proceedings of the 2011 Conference on Empirical Methods in Natural Language Processing, pp. 151–161, Edinburgh, Scotland, UK., July 2011. Association for Computational Linguistics. URL http: //www.aclweb.org/anthology/D11-1014.
+
+Richard Socher, Alex Perelygin, Jean Y Wu, Jason Chuang, Christopher D Manning, Andrew $\mathrm { \Upsilon { Y g } }$ , and Christopher Potts. Recursive deep models for semantic compositionality over a sentiment treebank. In Proceedings of the conference on empirical methods in natural language processing (EMNLP), volume 1631, pp. 1642. Citeseer, 2013.
+
+Kai Sheng Tai, Richard Socher, and Christopher D. Manning. Improved semantic representations from tree-structured long short-term memory networks. In Proceedings of ACL, pp. 1556–1566, 2015.
+
+Ming Tan, Cicero dos Santos, Bing Xiang, and Bowen Zhou. Improved representation learning for question answer matching. In Proceedings of ACL, pp. 464–473, Berlin, Germany, August 2016. Association for Computational Linguistics. URL http://www.aclweb.org/anthology/ P16-1044.
+
+Theano Development Team. Theano: A {Python} framework for fast computation of mathematical expressions. arXiv e-prints, abs/1605.0, 2016. URL http://arxiv.org/abs/1605. 02688.
+
+Ivan Vendrov, Ryan Kiros, Sanja Fidler, and Raquel Urtasun. Order-embeddings of images and language. arXiv preprint arXiv:1511.06361, 2015.
+
+Wenpeng Yin and Hinrich Schutze. Convolutional neural network for paraphrase identification. ¨ In Proceedings of the 2015 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, pp. 901–911, 2015.
+
+# APPENDIX
+
+# A PRUNED MLP FOR STRUCTURED MATRIX SENTENCE EMBEDDING
+
+As a side effect of having multiple vectors to represent a sentence, the matrix sentence embedding is usually several times larger than vector sentence embeddings. This results in needing more parameters in the subsequent fully connected layer, which connects every hidden units to every units in the matrix sentence embedding. Actually in the example shown in Figure 1, this fully connected layer takes around $90 \%$ percent of the parameters. See Table 4. In this appendix we are going to introduce a weight pruning method which, by utilizing the 2D structure of matrix embedding, is able to drastically reduce the number of parameters in the fully connected hidden layer.
+
+Inheriting the notation used in the main paper, let the matrix embedding $M$ has a shape of $r$ by $u$ , and let the fully connected hidden layer has $b$ units. The normal fully connected hidden layer will require each hidden unit to be connected to every unit in the matrix embedding, as shown in Figure 1. This ends up with $r \times u \times b$ parameters in total.
+
+However there are 2-D structures in the matrix embedding, which we should make use of. Each row $\mathbf { \dot { \phi } } m _ { i }$ in Figure 1) in the matrix is computed from a weighted sum of LSTM hidden states, which means they share some similarities
+
+To reflect these similarity in the fully connected layer, we split the hidden states into $r$ equally sized groups, with each group having $p$ units. The $i$ -th group is only fully connected to the $i$ -th row in the matrix representation. All connections that connects the $i$ -th group hidden units to other rows of the matrix are pruned away. In this way, Simillarity between different rows of matrix embedding are reflected as symmetry of connecting type in the hidden layer. As a result, the hidden layer can be interperated as also having a 2-D structute, with the number $( r )$ and size $( p )$ of groups as its two dimensions (The $M ^ { v }$ in Figure 6). When the total number of hidden units are the same (i.e., $r \times p = b ,$ ), this process prunes away $( r - 1 ) / r$ of weight values, which is a fairly large portion when $r$ is large.
+
+![](images/e429249761e9fa370a75158c97648271293e9bfbedb48b479ee3d18088cd066e.jpg)  
+Figure 6: Hidden layer with pruned weight connections. $M$ is the matrix sentence embedding, $M ^ { v }$ and $M ^ { h }$ are the structured hidden representation computed by pruned weights.
+
+Table 4: Model Size Comparison Before and After Pruning   
+
+<table><tr><td></td><td>Hidden layer</td><td> Softmax</td><td>Other Parts</td><td>Total</td><td>Accuracy</td></tr><tr><td>Yelp, Original, b=3000</td><td>54M</td><td>15K</td><td>1.3M</td><td>55.3M</td><td>64.21%</td></tr><tr><td>Yelp,Pruned, p=150, q=10</td><td>2.7M</td><td>52.5K</td><td>1.3M</td><td>4.1M</td><td>63.86%</td></tr><tr><td>Age, Original, b=4000</td><td>72M</td><td>20K</td><td>1.3M</td><td>73.2M</td><td>80.45%</td></tr><tr><td>Age,Pruned, p=25, q=20</td><td>822K</td><td>63.75K</td><td>1.3M</td><td>2.1M</td><td>77.32%</td></tr><tr><td>SNLI, Original, b=4000 SNLI, Pruned, p=300, q=10</td><td>72M 5.6M</td><td>12K 45K</td><td>22.9M 22.9M</td><td>95.0M 28.6M</td><td>84.43% 83.16%</td></tr></table>
+
+On the other dimension, another form of similarity exists too. For each vector representation $m _ { i }$ in $M$ , the $j$ -th element $m _ { i j }$ is a weighted sum of an LSTM hidden unit at different time steps. And for a certain $j$ -th element in all vector representations, they are summed up from a same LSTM hidden unit. We can also reflect this similarity into the symmetry of weight connections by using the same pruning method we did above. Thus we will have another 2-D structured hidden states sized $u$ -by- $q$ , noted as $M ^ { h }$ in Figure 6.
+
+Table 4 takes the model we use for yelp dataset as a concrete example, and compared the number of parameters in each part of the model, both before and after pruning. We can see the above pruning method drastically reduces the model size. Note that the $p$ and $q$ in this structure can be adjusted freely as hyperparameters. Also, we can continue the corresponding pruning process on top of $M ^ { v }$ and ${ \dot { M } } ^ { h }$ over and over again, and end up with having a stack of structured hidden layers, just like stacking fully connected layers.
+
+The subsequent softmax layer will be fully connected to both $M _ { v }$ and $M _ { h }$ , i.e., each unit in the softmax layer is connected to all units in $M _ { v }$ and $M _ { h }$ . This is not a problem since the speed of softmax is largely dependent of the number of softmax units, which is not changed.In addition, for applications like sentiment analysis and textural entailment, the softmax layer is so tiny that only contains several units.
+
+Experimental results in the three datasets has shown that, this pruning mechanism lowers performances a bit, but still allows all three models to perform comparable or better than other models compared in the paper.
+
+# B DETAILED STRUCTURE OF THE MODEL FOR SNLI DATASET
+
+In Section 2 we tested our matrix sentence embedding model for the textual entailment task on the SNLI dataset. Different from the former two tasks, the textual entailment task consists of a pair of sentences as input. We propose to use a set of multiplicative interactions to combine the two matrix embeddings extracted for each sentence. The form of multiplicative interaction is inspired by Factored Gated Autoencoder (Memisevic, 2013).
+
+![](images/22b6eb1c3efb70e442f8931e24c4aef61dec1d1f63c6ed017e9593cfd00e10ca.jpg)  
+Figure 7: Model structure used for textual entailment task.
+
+The overall structure of our model for SNLI is dipicted in Figure 7. For both hypothesis and premise, we extract their embeddings $M _ { h }$ and $M _ { p }$ in the figure) independently, with a same LSTM and attention mechanism. The parameters of this part of model are shared (rectangles with dashed orange line in the figure).
+
+Comparing the two matrix embeddings corresponds to the green dashed rectangle part in the figure, which computes a single matrix embedding $( F _ { r } )$ as the factor of semantic relation between the two sentences. To represent the relation between $M _ { h }$ and $M _ { p }$ , $F _ { r }$ can be connected to $M _ { h }$ and $M _ { p }$ through a three-way multiplicative interaction. In a three-way multiplicative interaction, the value of anyone of $F _ { r }$ , $M _ { h }$ and $M _ { p }$ is a function of the product of the others. This type of connection is originally introduced to extract relation between images (Memisevic, 2013). Since here we are just computing the factor of relations $( F _ { r } )$ from $M _ { h }$ and $M _ { p }$ , it corresponds to the encoder part in the Factored Gated Autoencoder in Memisevic (2013). We call it Gated Encoder in Figure 7.
+
+First we multiply each row in the matrix embedding by a different weight matrix. Repeating it over all rows, corresponds to a batched dot product between a 2-D matrix and a 3-D weight tensor. Inheriting the name in (Memisevic, 2013), we call the resulting matrix as factor. Doing the batched dot for both hypothesis embedding and premise embedding, we have $F _ { h }$ and $F _ { p }$ , respectively.
+
+$$
+\begin{array} { r } { F _ { h } = b a t c h e d d o t ( M _ { h } , W _ { f h } ) } \\ { F _ { p } = b a t c h e d d o t ( M _ { p } , W _ { f p } ) } \end{array}
+$$
+
+Here $W _ { f h }$ and $W _ { f p }$ are the two weight tensors for hypothesis embedding and premise embedding.
+
+The factor of the relation $( F _ { r } )$ is just an element-wise product of $F _ { h }$ and $F _ { p }$ (the triangle in the middle of Figure 7):
+
+$$
+F _ { r } = F _ { h } \odot F _ { p }
+$$
+
+Here $\odot$ stands for element-wise product. After the $F _ { r }$ layer, we then use an MLP with softmax output to classify the relation into different categlories.

parse/train/BJC_jUqxe/BJC_jUqxe_content_list.json

@@ -0,0 +1,1816 @@
+[
+    {
+        "type": "text",
+        "text": "A STRUCTURED SELF-ATTENTIVE SENTENCE EMBEDDING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            99,
+            581,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Zhouhan $\\mathbf { L i n } ^ { \\dagger \\circ }$ ∗, Minwei Feng\u0005, Cicero Nogueira dos Santos\u0005, Mo $\\mathbf { V } \\mathbf { u } ^ { \\circ }$ , Bing Xiang\u0005, Bowen Zhou\u0005 & Yoshua Bengio‡† ",
+        "bbox": [
+            183,
+            170,
+            673,
+            199
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "\u0005IBM Watson   \n‡Montreal Institute for Learning Algorithms (MILA), Universite de Montr ´ eal ´   \n†CIFAR Senior Fellow   \nlin.zhouhan@gmail.com   \n{mfeng, cicerons, yum, bingxia, zhou}@us.ibm.com ",
+        "bbox": [
+            184,
+            200,
+            689,
+            271
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            308,
+            544,
+            321
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "This paper proposes a new model for extracting an interpretable sentence embedding by introducing self-attention. Instead of using a vector, we use a 2-D matrix to represent the embedding, with each row of the matrix attending on a different part of the sentence. We also propose a self-attention mechanism and a special regularization term for the model. As a side effect, the embedding comes with an easy way of visualizing what specific parts of the sentence are encoded into the embedding. We evaluate our model on 3 different tasks: author profiling, sentiment classification and textual entailment. Results show that our model yields a significant performance gain compared to other sentence embedding methods in all of the 3 tasks. ",
+        "bbox": [
+            233,
+            339,
+            764,
+            478
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            506,
+            334,
+            522
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Much progress has been made in learning semantically meaningful distributed representations of individual words, also known as word embeddings (Bengio et al., 2001; Mikolov et al., 2013). On the other hand, much remains to be done to obtain satisfying representations of phrases and sentences. Those methods generally fall into two categories. The first consists of universal sentence embeddings usually trained by unsupervised learning (Hill et al., 2016). This includes SkipThought vectors (Kiros et al., 2015), ParagraphVector (Le & Mikolov, 2014), recursive auto-encoders (Socher et al., 2011; 2013), Sequential Denoising Autoencoders (SDAE), FastSent (Hill et al., 2016), etc. ",
+        "bbox": [
+            174,
+            537,
+            825,
+            636
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The other category consists of models trained specifically for a certain task. They are usually combined with downstream applications and trained by supervised learning. One generally finds that specifically trained sentence embeddings perform better than generic ones, although generic ones can be used in a semi-supervised setting, exploiting large unlabeled corpora. Several models have been proposed along this line, by using recurrent networks (Hochreiter & Schmidhuber, 1997; Chung et al., 2014), recursive networks (Socher et al., 2013) and convolutional networks (Kalchbrenner et al., 2014; dos Santos & Gatti, 2014; Kim, 2014) as an intermediate step in creating sentence representations to solve a wide variety of tasks including classification and ranking (Yin & Schutze, ¨ 2015; Palangi et al., 2016; Tan et al., 2016; Feng et al., 2015). A common approach in previous methods consists in creating a simple vector representation by using the final hidden state of the RNN or the max (or average) pooling from either RNNs hidden states or convolved n-grams. Additional works have also been done in exploiting linguistic structures such as parse and dependence trees to improve sentence representations (Ma et al., 2015; Mou et al., 2015b; Tai et al., 2015). ",
+        "bbox": [
+            174,
+            642,
+            825,
+            823
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "For some tasks people propose to use attention mechanism on top of the CNN or LSTM model to introduce extra source of information to guide the extraction of sentence embedding (dos Santos et al., 2016). However, for some other tasks like sentiment classification, this is not directly applicable since there is no such extra information: the model is only given one single sentence as input. In those cases, the most common way is to add a max pooling or averaging step across all time steps (Lee & Dernoncourt, 2016), or just pick up the hidden representation at the last time step as the encoded embedding (Margarit & Subramaniam, 2016). ",
+        "bbox": [
+            174,
+            830,
+            823,
+            900
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/60681ffc941822535da20ab69058a148910ef62a2ce6c2d7c0ce089c4d576168.jpg",
+        "image_caption": [
+            "Figure 1: A sample model structure showing the sentence embedding model combined with a fully connected and softmax layer for sentiment analysis (a). The sentence embedding $M$ is computed as multiple weighted sums of hidden states from a bidirectional LSTM $( \\mathbf { h _ { 1 } } , . . . , \\mathbf { h _ { n } } )$ , where the summation weights $( A _ { i 1 } , . . . , A _ { i n } )$ are computed in a way illustrated in (b). Blue colored shapes stand for hidden representations, and red colored shapes stand for weights, annotations, or input/output. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            246,
+            98,
+            751,
+            395
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            506,
+            823,
+            535
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "A common approach in many of the aforementioned methods consists of creating a simple vector representation by using the final hidden state of the RNN or the max (or average) pooling from either RNNs hidden states or convolved n-grams. We hypothesize that carrying the semantics along all time steps of a recurrent model is relatively hard and not necessary. We propose a self-attention mechanism for these sequential models to replace the max pooling or averaging step. Different from previous approaches, the proposed self-attention mechanism allows extracting different aspects of the sentence into multiple vector representations. It is performed on top of an LSTM in our sentence embedding model. This enables attention to be used in those cases when there are no extra inputs. In addition, due to its direct access to hidden representations from previous time steps, it relieves some long-term memorization burden from LSTM. As a side effect coming together with our proposed self-attentive sentence embedding, interpreting the extracted embedding becomes very easy and explicit. ",
+        "bbox": [
+            173,
+            541,
+            825,
+            708
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Section 2 details on our proposed self-attentive sentence embedding model, as well as a regularization term we proposed for this model, which is described in Section 2.2. We also provide a visualization method for this sentence embedding in section 2.3. We then evaluate our model in author profiling, sentiment classification and textual entailment tasks in Section 4. ",
+        "bbox": [
+            174,
+            715,
+            825,
+            770
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 APPROACH",
+        "text_level": 1,
+        "bbox": [
+            174,
+            794,
+            297,
+            809
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 MODEL ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            827,
+            266,
+            840
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The proposed sentence embedding model consists of two parts. The first part is a bidirectional LSTM, and the second part is the self-attention mechanism, which provides a set of summation weight vectors for the LSTM hidden states. These set of summation weight vectors are dotted with the LSTM hidden states, and the resulting weighted LSTM hidden states are considered as an embedding for the sentence. It can be combined with, for example, a multilayer perceptron to be applied on a downstream application. Figure 1 shows an example when the proposed sentence embedding model is applied to sentiment analysis, combined with a fully connected layer and a softmax layer. Besides using a fully connected layer, we also proposes an approach that prunes weight connections by utilizing the 2-D structure of matrix sentence embedding, which is detailed in Appendix A. For this section, we will use Figure 1 to describe our model. ",
+        "bbox": [
+            174,
+            854,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Suppose we have a sentence, which has $n$ tokens, represented in a sequence of word embeddings. ",
+        "bbox": [
+            171,
+            180,
+            808,
+            195
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c5dbdd31719e0235c6f6f68a3c1de99442d2270c59b8110362b991eeb8281963.jpg",
+        "text": "$$\nS = \\left( \\mathbf { w _ { 1 } } , \\mathbf { w _ { 2 } } , \\cdot \\cdot \\cdot \\mathbf { w _ { n } } \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            423,
+            202,
+            575,
+            219
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Here $w _ { i }$ is a vector standing for a $d$ dimentional word embedding for the $i$ -th word in the sentence. $S$ is thus a sequence represented as a 2-D matrix, which concatenates all the word embeddings together. $S$ should have the shape $n$ -by- $d$ . ",
+        "bbox": [
+            174,
+            226,
+            825,
+            268
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Now each entry in the sequence $S$ are independent with each other. To gain some dependency between adjacent words within a single sentence, we use a bidirectional LSTM to process the sentence: ",
+        "bbox": [
+            173,
+            275,
+            823,
+            304
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d34cd7a6339ce097000d4b543f6cdb105439418babf6a6de934e554a32669425.jpg",
+        "text": "$$\n\\begin{array} { r } { \\overrightarrow { h _ { t } } = \\overrightarrow { L S T M } ( w _ { t } , \\overrightarrow { h _ { t - 1 } } ) } \\\\ { \\overleftarrow { h _ { t } } = \\overleftarrow { L S T M } ( w _ { t } , \\overbrace { h _ { t + 1 } } ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            416,
+            308,
+            581,
+            357
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "And we concatenate each $\\overrightarrow { h _ { t } }$ with $\\left\\{ { { \\overline { { h _ { t } } } } } \\right.$ to obtain a hidden state $h _ { t }$ . Let the hidden unit number for each unidirectional LSTM be $u$ . For simplicity, we note all the n $h _ { t } \\mathbf { s }$ as $H$ , who have the size $n$ -by- $_ { 2 u }$ . ",
+        "bbox": [
+            173,
+            359,
+            828,
+            391
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0d02ea350a5a416584aaf94211f046fbc77c37c9bd9e718c62a20cd103c119a4.jpg",
+        "text": "$$\nH = ( \\mathbf { h _ { 1 } } , \\mathbf { h _ { 2 } } , \\cdot \\cdot \\cdot \\mathbf { h _ { n } } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            426,
+            397,
+            571,
+            415
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our aim is to encode a variable length sentence into a fixed size embedding. We achieve that by choosing a linear combination of the $n$ LSTM hidden vectors in $H$ . Computing the linear combination requires the self-attention mechanism. The attention mechanism takes the whole LSTM hidden states $H$ as input, and outputs a vector of weights $\\mathbf { a }$ : ",
+        "bbox": [
+            173,
+            429,
+            823,
+            484
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e1820974c4a95a3b01e33c60787187adb2e76a8f6e11b5ff454b7af20451bf7c.jpg",
+        "text": "$$\n\\mathbf { a } = s o f t m a x \\left( \\mathbf { w _ { s 2 } } t a n h \\left( W _ { s 1 } H ^ { T } \\right) \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            374,
+            492,
+            622,
+            512
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Here $W _ { s 1 }$ is a weight matrix with a shape of $d _ { a }$ -by- $_ { 2 u }$ . and ${ \\bf w _ { s 2 } }$ is a vector of parameters with size $d _ { a }$ , where $d _ { a }$ is a hyperparameter we can set arbitrarily. Since $H$ is sized $n$ -by- $_ { 2 u }$ , the annotation vector $a$ will have a size $n$ . the $s o f t m a x ( )$ ensures all the computed weights sum up to 1. Then we sum up the LSTM hidden states $H$ according to the weight provided by a to get a vector representation $\\mathbf { m }$ of the input sentence. ",
+        "bbox": [
+            173,
+            517,
+            825,
+            590
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "This vector representation usually focuses on a specific component of the sentence, like a special set of related words or phrases. So it is expected to reflect an aspect, or component of the semantics in a sentence. However, there can be multiple components in a sentence that together forms the overall semantics of the whole sentence, especially for long sentences. (For example, two clauses linked together by an ”and.”) Thus, to represent the overall semantics of the sentence, we need multiple m’s that focus on different parts of the sentence. Thus we need to perform multiple hops of attention. Say we want $r$ different parts to be extracted from the sentence, with regard to this, we extend the ${ \\bf w _ { s 2 } }$ into a $r$ -by- $\\cdot d _ { a }$ matrix, note it as $W _ { s 2 }$ , and the resulting annotation vector a becomes annotation matrix $A$ . Formally, ",
+        "bbox": [
+            173,
+            595,
+            825,
+            722
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2179430f989106ab6c8e701981a3aefcf643904eb058b84edf4d5a907fbc77be.jpg",
+        "text": "$$\nA = s o f t m a x \\left( W _ { s 2 } t a n h \\left( W _ { s 1 } H ^ { T } \\right) \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            372,
+            720,
+            625,
+            741
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Here the sof tmax $( )$ is performed along the second dimension of its input. We can deem Equation 6 as a 2-layer MLP without bias, whose hidden unit numbers is $d _ { a }$ , and parameters are $\\{ W _ { s 2 } , \\mathbf { \\bar { W } } _ { s 1 } \\}$ . ",
+        "bbox": [
+            174,
+            746,
+            825,
+            775
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The embedding vector $m$ then becomes an $r$ -by- $_ { 2 u }$ embedding matrix $M$ . We compute the $r$ weighted sums by multiplying the annotation matrix $A$ and LSTM hidden states $H$ , the resulting matrix is the sentence embedding: ",
+        "bbox": [
+            174,
+            781,
+            825,
+            824
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f6aff38f374302ed74f0396d9caf51c3506c62c6e4eac4abd303a3b23063a0ae.jpg",
+        "text": "$$\nM = A H\n$$",
+        "text_format": "latex",
+        "bbox": [
+            464,
+            823,
+            534,
+            837
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 PENALIZATION TERM ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            854,
+            362,
+            869
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The embedding matrix $M$ can suffer from redundancy problems if the attention mechanism always provides similar summation weights for all the $r$ hops. Thus we need a penalization term to encourage the diversity of summation weight vectors across different hops of attention. ",
+        "bbox": [
+            174,
+            881,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The best way to evaluate the diversity is definitely the Kullback Leibler divergence between any 2 of the summation weight vectors. However, we found that not very stable in our case. We conjecture it is because we are maximizing a set of KL divergence (instead of minimizing only one, which is the usual case), we are optimizing the annotation matrix A to have a lot of sufficiently small or even zero values at different softmax output units, and these vast amount of zeros is making the training unstable. There is another feature that KL doesn’t provide but we want, which is, we want each individual row to focus on a single aspect of semantics, so we want the probability mass in the annotation softmax output to be more focused. but with KL penalty we cant encourage that. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            215
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We hereby introduce a new penalization term which overcomes the aforementioned shortcomings. Compared to the KL divergence penalization, this term consumes only one third of the computation. We use the dot product of $A$ and its transpose, subtracted by an identity matrix, as a measure of redundancy. ",
+        "bbox": [
+            173,
+            222,
+            825,
+            277
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b461d69c98694f53431998f5ba0cc8ea68bdbf0703072419c8b06fb821d4d2fc.jpg",
+        "text": "$$\n\\boldsymbol { P } = \\left\\| \\left( \\boldsymbol { A } \\boldsymbol { A } ^ { T } - \\boldsymbol { I } \\right) \\right\\| _ { F } ^ { 2 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            423,
+            276,
+            575,
+            299
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Here $\\| \\bullet \\| _ { F }$ stands for the Frobenius norm of a matrix. Similar to adding an L2 regularization term, this penalization term $P$ will be multiplied by a coefficient, and we minimize it together with the original loss, which is dependent on the downstream application. ",
+        "bbox": [
+            173,
+            300,
+            825,
+            343
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Let’s consider two different summation vectors $\\mathbf { a ^ { i } }$ and $\\mathbf { a } ^ { \\mathbf { j } }$ in $A$ . Because of the softmax, all entries within any summation vector in $A$ should sum up to 1. Thus they can be deemed as probability masses in a discrete probability distribution. For any non-diagonal elements $a _ { i j } ( i \\neq j )$ in the $A A ^ { \\check { T } }$ matrix, it corresponds to a summation over elementwise product of two distributions: ",
+        "bbox": [
+            174,
+            348,
+            823,
+            406
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d69259204fe8ee8bc76d4c8e80cd6980952909c8be7a43b58d342a96dbccc273.jpg",
+        "text": "$$\n0 < a _ { i j } = \\sum _ { k = 1 } ^ { n } a _ { k } ^ { i } a _ { k } ^ { j } < 1\n$$",
+        "text_format": "latex",
+        "bbox": [
+            415,
+            410,
+            581,
+            452
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $a _ { k } ^ { i }$ and $a _ { k } ^ { j }$ are the $k$ -th element in the $\\mathbf { a } ^ { \\mathbf { i } }$ and $\\mathbf { a } ^ { \\mathbf { j } }$ vectors, respectively. In the most extreme case, where there is no overlap between the two probability distributions $\\mathbf { a } ^ { \\mathbf { i } }$ and $\\mathbf { a } ^ { \\mathbf { j } }$ , the correspond $a _ { i j }$ will be 0. Otherwise, it will have a positive value. On the other extreme end, if the two distributions are identical and all concentrates on one single word, it will have a maximum value of 1. We subtract an identity matrix from $A A ^ { T }$ so that forces the elements on the diagonal of $A A ^ { T }$ to approximate 1, which encourages each summation vector $\\mathbf { a } ^ { \\mathbf { i } }$ to focus on as few number of words as possible, forcing each vector to be focused on a single aspect, and all other elements to 0, which punishes redundancy between different summation vectors. ",
+        "bbox": [
+            174,
+            457,
+            823,
+            571
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.3 VISUALIZATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            588,
+            326,
+            603
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The interpretation of the sentence embedding is quite straight forward because of the existence of annotation matrix $A$ . For each row in the sentence embedding matrix $M$ , we have its corresponding annotation vector $\\mathbf { a ^ { i } }$ . Each element in this vector corresponds to how much contribution the LSTM hidden state of a token on that position contributes to. We can thus draw a heat map for each row of the embedding matrix $M$ This way of visualization gives hints on what is encoded in each part of the embedding, adding an extra layer of interpretation. (See Figure 3a and 3b). ",
+        "bbox": [
+            174,
+            614,
+            825,
+            699
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The second way of visualization can be achieved by summing up over all the annotation vectors, and then normalizing the resulting weight vector to sum up to 1. Since it sums up all aspects of semantics of a sentence, it yields a general view of what the embedding mostly focuses on. We can figure out which words the embedding takes into account a lot, and which ones are skipped by the embedding. See Figure 3c and 3d. ",
+        "bbox": [
+            174,
+            705,
+            825,
+            775
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            795,
+            341,
+            810
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Various supervised and unsupervised sentence embedding models have been mentioned in Section 1. Different from those models, our proposed method uses a new self-attention mechanism that allows it to extract different aspects of the sentence into multiple vector-representations. The matrix structure together with the penalization term gives our model a greater capacity to disentangle the latent information from the input sentence. We also do not use linguistic structures to guide our sentence representation model. Additionally, using our method we can easily create visualizations that can help in the interpretation of the learned representations. ",
+        "bbox": [
+            174,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Some recent work have also proposed supervised methods that use intra/self-sentence attention. Ling et al. (2015) proposed an attention based model for word embedding, which calculates an attention weight for each word at each possible position in the context window. However this method cannot be extended to sentence level embeddings since one cannot exhaustively enumerate all possible sentences. Liu et al. (2016a) proposes a sentence level attention which has a similar motivation but done differently. They utilize the mean pooling over LSTM states as the attention source, and use that to re-weight the pooled vector representation of the sentence. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            200
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Apart from the previous 2 variants, we want to note that Li et al. (2016) proposed a same self attention mechanism for question encoding in their factoid QA model, which is concurrent to our work. The difference lies in that their encoding is still presented as a vector, but our attention produces a matrix representation instead, with a specially designed penalty term. We applied the model for sentiment anaysis and entailment, and their model is for factoid QA. ",
+        "bbox": [
+            174,
+            208,
+            825,
+            277
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The LSTMN model (Cheng et al., 2016) also proposed a very successful intra-sentence level attention mechanism, which is later used by Parikh et al. (2016). We see our attention and theirs as having different granularities. LSTMN produces an attention vector for each of its hidden states during the recurrent iteration, which is sort of an ”online updating” attention. It’s more fine-grained, targeting at discovering lexical correlations between a certain word and its previous words. On the contrary, our attention mechanism is only performed once, focuses directly on the semantics that makes sense for discriminating the targets. It is less focused on relations between words, but more on the semantics of the whole sentence that each word contributes to. Computationally, our method also scales up with the sentence length better, since it doesn’t require the LSTM to compute an annotation vector over all of its previous words each time when the LSTMN computes its next step. ",
+        "bbox": [
+            174,
+            285,
+            825,
+            424
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTAL RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            452,
+            415,
+            467
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We first evaluate our sentence embedding model by applying it to 3 different datasets: the Age dataset, the Yelp dataset, and the Stanford Natural Language Inference (SNLI) Corpus. These 3 datasets fall into 3 different tasks, corresponding to author profiling, sentiment analysis, and textual entailment, respectively. Then we also perform a set of exploratory experiments to validate properties of various aspects for our sentence embedding model. ",
+        "bbox": [
+            174,
+            487,
+            825,
+            556
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 AUTHOR PROFILING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            580,
+            352,
+            594
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The Author Profiling dataset1 consists of Twitter tweets in English, Spanish, and Dutch. For some of the tweets, it also provides an age and gender of the user when writing the tweet. The age range are split into 5 classes: 18-24, 25-34, 35-49, 50-64, $6 5 +$ . We use English tweets as input, and use those tweets to predict the age range of the user. Since we are predicting the age of users, we refer to it as Age dataset in the rest of our paper. We randomly selected 68485 tweets as training set, 4000 for development set, and 4000 for test set. Performances are also chosen to be classification accuracy. ",
+        "bbox": [
+            174,
+            608,
+            825,
+            693
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We compare our model with two baseline models: biLSTM and CNN. For the two baseline models. The biLSTM model uses a bidirectional LSTM with 300 dimensions in each direction, and use max pooling across all LSTM hidden states to get the sentence embedding vector, then use a 2-layer ReLU output MLP with 3000 hidden states to output the classification result. The CNN model uses the same scheme, but substituting biLSTM with 1 layer of 1-D convolutional network. During training we use 0.5 dropout on the MLP and 0.0001 L2 regularization. We use stochastic gradient descent as the optimizer, with a learning rate of 0.06, batch size 16. For biLSTM, we also clip the norm of gradients to be between -0.5 and 0.5. We searched hyperparameters in a wide range and find the aforementioned set of hyperparameters yields the highest accuracy. ",
+        "bbox": [
+            174,
+            699,
+            825,
+            825
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For our model, we use the same settings as what we did in biLSTM. We also use a 2-layer ReLU output MLP, but with 2000 hidden units. In addition, our self-attention MLP has a hidden layer with 350 units (the $d _ { a }$ in Section 2), we choose the matrix embedding to have 30 rows (the $r$ ), and a coefficient of 1 for the penalization term. ",
+        "bbox": [
+            176,
+            832,
+            823,
+            887
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/d9259968c3faa7f9a5e88966702b3300ed119297c22852251fc02d3752426281.jpg",
+        "table_caption": [
+            "Table 1: Performance Comparision of Different Models on Yelp and Age Dataset "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Models</td><td>Yelp</td><td>Age</td></tr><tr><td>BiLSTM + Max Pooling + MLP</td><td>61.99%</td><td>77.40%</td></tr><tr><td>CNN+Max Pooling+MLP</td><td>62.05%</td><td>78.15%</td></tr><tr><td>Our Model</td><td>64.21%</td><td>80.45%</td></tr></table>",
+        "bbox": [
+            308,
+            132,
+            689,
+            193
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We train all the three models until convergence and select the corresponding test set performance according to the best development set performance. Our results show that the model outperforms both of the biLSTM and CNN baselines by a significant margin. ",
+        "bbox": [
+            176,
+            223,
+            825,
+            266
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/f74f85ffe002204ab5a7ab119e1c1ee8e94e9f6456e7bc24df8dd1badc45d622.jpg",
+        "image_caption": [
+            "Figure 2: Heatmap of Yelp reviews with the two extreme score. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            238,
+            280,
+            761,
+            784
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 SENTIMENT ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            830,
+            370,
+            844
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We choose the Yelp dataset2 for sentiment analysis task. It consists of 2.7M yelp reviews, we take the review as input and predict the number of stars the user who wrote that review assigned to the corresponding business store. We randomly select 500K review-star pairs as training set, and 2000 for development set, 2000 for test set. We tokenize the review texts by Stanford tokenizer. We use 100 dimensional word2vec as initialization for word embeddings, and tune the embedding during training across all of our experiments. The target number of stars is an integer number in the range of [1, 5], inclusive. We are treating the task as a classification task, i.e., classify a review text into one of the 5 classes. We use classification accuracy as a measurement. ",
+        "bbox": [
+            174,
+            856,
+            825,
+            900
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            172
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "For the two baseline models, we use the same setting as what we used for Author Profiling dataset, except that we are using a batch size of 32 instead. For our model, we are also using the same setting, except that we choose the hidden unit numbers in the output MLP to be 3000 instead. We also observe a significant performance gain comparining to the two baselines. (Table 1) ",
+        "bbox": [
+            174,
+            180,
+            823,
+            236
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "As an interpretation of the learned sentence embedding, we use the second way of visualization described in Section 2.3 to plot heat maps for some of the reviews in the dataset. We randomly select 5 examples of negative (1 star) and positive (5 stars) reviews from the test set, when the model has a high confidence $( > 0 . 8 )$ in predicting the label. As shown in Figure 2, we find that the model majorly learns to capture some key factors in the review that indicate strongly on the sentiment behind the sentence. For most of the short reviews, the model manages to capture all the key factors that contribute to an extreme score, but for longer reviews, the model is still not able to capture all related factors. For example, in the 3rd review in Figure 2b), it seems that a lot of focus is spent on one single factor, i.e., the ”so much fun”, and the model puts a little amount of attention on other key points like ”highly recommend”, ”amazing food”, etc. ",
+        "bbox": [
+            174,
+            243,
+            825,
+            382
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.3 TEXTUAL ENTAILMENT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            400,
+            377,
+            412
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We use the biggest dataset in textual entailment, the SNLI corpus (Bowman et al., 2015) for our evaluation on this task. SNLI is a collection of 570k human-written English sentence pairs manually labeled for balanced classification with the labels entailment, contradiction, and neutral. The model will be given a pair of sentences, called hypothesis and premise respectively, and asked to tell if the semantics in the two sentences are contradicting with each other or not. It is also a classification task, so we measure the performance by accuracy. ",
+        "bbox": [
+            174,
+            425,
+            825,
+            508
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We process the hypothesis and premise independently, and then extract the relation between the two sentence embeddings by using multiplicative interactions proposed in Memisevic (2013) (see Appendix B for details), and use a 2-layer ReLU output MLP with 4000 hidden units to map the hidden representation into classification results. Parameters of biLSTM and attention MLP are shared across hypothesis and premise. The biLSTM is 300 dimension in each direction, the attention MLP has 150 hidden units instead, and both sentence embeddings for hypothesis and premise have 30 rows (the $r$ ). The penalization term coefficient is set to 0.3. We use 300 dimensional GloVe (Pennington et al., 2014) word embedding to initialize word embeddings. We use AdaGrad as the optimizer, with a learning rate of 0.01. We don’t use any extra regularization methods, like dropout or L2 normalization. Training converges after 4 epochs, which is relatively fast. ",
+        "bbox": [
+            174,
+            516,
+            825,
+            655
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "This task is a bit different from previous two tasks, in that it has 2 sentences as input. There are a bunch of ways to add inter-sentence level attention, and those attentions bring a lot of benefits. To make the comparison focused and fair, we only compare methods that fall into the sentence encoding-based models. i.e., there is no information exchanged between the hypothesis and premise before they are encoded into some distributed encoding. ",
+        "bbox": [
+            174,
+            661,
+            823,
+            732
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/36193a2b4e96f00f77fa20691351dedfe2f55303f60611c964674ecaf6c3c5d3.jpg",
+        "table_caption": [
+            "Table 2: Test Set Performance Compared to other Sentence Encoding Based Methods in SNLI Datset "
+        ],
+        "table_footnote": [
+            ""
+        ],
+        "table_body": "<table><tr><td>Model</td><td>Test Accuracy</td></tr><tr><td>300DLSTM encoders (Bowman et al., 2016)</td><td>80.6%</td></tr><tr><td>600D (300+300) BiLSTM encoders (Liu et al.,2016b)</td><td>83.3%</td></tr><tr><td> 300D Tree-based CNN encoders (Mou et al., 2015a)</td><td>82.1%</td></tr><tr><td>300D SPINN-PI encoders (Bowman et al., 2016)</td><td>83.2%</td></tr><tr><td>300D NTI-SLSTM-LSTM encoders (Munkhdalai &amp; Yu,2016a)</td><td>83.4%</td></tr><tr><td>1024D GRU encoders with SkipThoughts pre-training (Vendrov et al., 2015)</td><td>81.4%</td></tr><tr><td>300D NSE encoders (Munkhdalai &amp; Yu,2016b)</td><td>84.6%</td></tr><tr><td>Ourmethod</td><td>84.4%</td></tr></table>",
+        "bbox": [
+            178,
+            785,
+            820,
+            909
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We find that compared to other published approaches, our method shows a significant gain $( \\geq 1 \\% )$ to them, except for the 300D NSE encoders, which is the state-of-the-art in this category. However, the $0 . 2 \\%$ different is relatively small compared to the differences between other methods. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            146
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.4 EXPLORATORY EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            169,
+            421,
+            183
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this subsection we are going to do a set of exploratory experiments to study the relative effect of each component in our model. ",
+        "bbox": [
+            174,
+            196,
+            825,
+            224
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.4.1 EFFECT OF PENALIZATION TERM ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            247,
+            454,
+            260
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Since the purpose of introducing the penalization term $P$ is majorly to discourage the redundancy in the embedding, we first directly visualize the heat maps of each row when the model is presented with a sentence. We compare two identical models with the same size as detailed in Section 4.1 trained separately on Age dataset, one with this penalization term (where the penalization coefficient is set to 1.0) and the other with no penalty. We randomly select one tweet from the test set and compare the two models by plotting a heat map for each hop of attention on that single tweet. Since there are 30 hops of attention for each model, which makes plotting all of them quite redundant, we only plot 6 of them. These 6 hops already reflect the situation in all of the 30 hops. ",
+        "bbox": [
+            173,
+            272,
+            825,
+            385
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/3063df46fa169ad74f2bf5325c236c0cb983c5420197166d28d806198fca0206.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            414,
+            825,
+            632
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Figure 3: Heat maps for 2 models trained on Age dataset. The left column is trained without the penalization term, and the right column is trained with 1.0 penalization. (a) and (b) shows detailed attentions taken by 6 out of 30 rows of the matrix embedding, while (c) and (d) shows the overall attention by summing up all 30 attention weight vectors. ",
+        "bbox": [
+            173,
+            643,
+            825,
+            699
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/89bf44b778e1ce2a54bd5f742c83b4577b52f97c87756d6e14dd2bbfadeca00c.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            719,
+            825,
+            881
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Figure 4: Attention of sentence embedding on 3 different Yelp reviews. The left one is trained without penalization, and the right one is trained with 1.0 penalization. ",
+        "bbox": [
+            169,
+            892,
+            825,
+            920
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/11bce19fa142fa54dc16c62d250885d607f7f7188d58fd00b80198457c3fe6c4.jpg",
+        "table_caption": [
+            "Table 3: Performance comparision regarding the penalization term "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Penalization coefficient</td><td>Yelp</td><td>Age</td></tr><tr><td>1.0</td><td>64.21%</td><td>80.45%</td></tr><tr><td>0.0</td><td>61.74%</td><td>79.27%</td></tr></table>",
+        "bbox": [
+            336,
+            132,
+            661,
+            179
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "From the figure we can tell that the model trained without the penalization term have lots of redundancies between different hops of attention (Figure 3a), resulting in putting lot of focus on the word ”it” (Figure 3c), which is not so relevant to the age of the author. However in the right column, the model shows more variations between different hops, and as a result, the overall embedding focuses on ”mail-replies spam” instead. (Figure 3d) ",
+        "bbox": [
+            173,
+            210,
+            825,
+            281
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "For the Yelp dataset, we also observe a similar phenomenon. To make the experiments more explorative, we choose to plot heat maps of overall attention heat maps for more samples, instead of plotting detailed heat maps for a single sample again. Figure 4 shows overall focus of the sentence embedding on three different reviews. We observe that with the penalization term, the model tends to be more focused on important parts of the review. We think it is because that we are encouraging it to be focused, in the diagonals of matrix $A A ^ { T }$ (Equation 8). ",
+        "bbox": [
+            173,
+            287,
+            825,
+            371
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "To validate if these differences result in performance difference, we evaluate four models trained on Yelp and Age datasets, both with and without the penalization term. Results are shown in Table 3. Consistent with what expected, models trained with the penalization term outperforms their counterpart trained without. ",
+        "bbox": [
+            174,
+            378,
+            825,
+            434
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In SNLI dataset, although we observe that introducing the penalization term still contributes to encouraging the diversity of different rows in the matrix sentence embedding, and forcing the network to be more focused on the sentences, the quantitative effect of this penalization term is not so obvious on SNLI dataset. Both models yield similar test set accuracies. ",
+        "bbox": [
+            174,
+            440,
+            825,
+            497
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.4.2 EFFECT OF MULTIPLE VECTORS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            513,
+            446,
+            527
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Having multiple rows in the sentence embedding is expected to provide more abundant information about the encoded content. It makes sence to evaluate how significant the improvement can be brought by $r$ . Taking the models we used for Age and SNLI dataset as an example, we vary $r$ from 1 to 30 for each task, and train the resulting 10 models independently (Figure 5). Note that when $r = 1$ , the sentence embedding reduces to a normal vector form. ",
+        "bbox": [
+            174,
+            537,
+            825,
+            608
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "From this figure we can find that, without having multiple rows, the model performs on-par with its competitiors which use other forms of vector sentence embeddings. But there is significant difference between having only one vector for the sentence embedding and multiple vectors. The models are also quite invariant with respect to $r$ , since in the two figures a wide range of values between 10 to 30 are all generating comparable curves. ",
+        "bbox": [
+            173,
+            614,
+            823,
+            643
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/51b6ec69cc29def6c6745dec2737bece1e9dab0778bae6cf51d528dd609d0b63.jpg",
+        "image_caption": [
+            "Figure 5: Effect of the number of rows $( r )$ in matrix sentence embedding. The vertical axes indicates test set accuracy and the horizontal axes indicates training epoches. Numbers in the legends stand for the corresponding values of $r$ . (a) is conducted in Age dataset and (b) is conducted in SNLI dataset. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            671,
+            813,
+            852
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            146
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION AND DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            167,
+            465,
+            183
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we introduced a fixed size, matrix sentence embedding with a self-attention mechanism. Because of this attention mechanism, there is a way to interpret the sentence embedding in depth in our model. Experimental results over 3 different tasks show that the model outperforms other sentence embedding models by a significant margin. ",
+        "bbox": [
+            174,
+            199,
+            823,
+            255
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Introducing attention mechanism allows the final sentence embedding to directly access previous LSTM hidden states via the attention summation. Thus the LSTM doesn’t need to carry every piece of information towards its last hidden state. Instead, each LSTM hidden state is only expected to provide shorter term context information around each word, while the higher level semantics, which requires longer term dependency, can be picked up directly by the attention mechanism. This setting reliefs the burden of LSTM to carry on long term dependencies. Our experiments also support that, as we observed that our model has a bigger advantage when the contents are longer. Further more, the notion of summing up elements in the attention mechanism is very primitive, it can be something more complex than that, which will allow more operations on the hidden states of LSTM. ",
+        "bbox": [
+            174,
+            262,
+            825,
+            387
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The model is able to encode any sequence with variable length into a fixed size representation, without suffering from long-term dependency problems. This brings a lot of scalability to the model: without any modification, it can be applied directly to longer contents like paragraphs, articles, etc. Though this is beyond the focus of this paper, it remains an interesting direction to explore as a future work. ",
+        "bbox": [
+            174,
+            393,
+            825,
+            463
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "As a downside of our proposed model, the current training method heavily relies on downstream applications, thus we are not able to train it in an unsupervised way. The major obstacle towards enabling unsupervised learning in this model is that during decoding, we don’t know as prior how the different rows in the embedding should be divided and reorganized. Exploring all those possible divisions by using a neural network could easily end up with overfitting. Although we can still do unsupervised learning on the proposed model by using a sequential decoder on top of the sentence embedding, it merits more to find some other structures as a decoder. ",
+        "bbox": [
+            174,
+            470,
+            825,
+            568
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            585,
+            326,
+            598
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The authors would like to acknowledge the developers of Theano (Theano Development Team, 2016) and Lasagne. The first author would also like to thank IBM Watson for providing resources, fundings and valuable discussions to make this project possible, and Caglar Gulcehre for helpful discussions. ",
+        "bbox": [
+            176,
+            609,
+            825,
+            664
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            686,
+            285,
+            702
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yoshua Bengio, Rejean Ducharme, and Pascal Vincent. A neural probabilistic language model. In ´ Advances in Neural Information Processing Systems, pp. 932–938, 2001. ",
+        "bbox": [
+            174,
+            710,
+            825,
+            739
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Samuel R Bowman, Gabor Angeli, Christopher Potts, and Christopher D Manning. A large annotated corpus for learning natural language inference. arXiv preprint arXiv:1508.05326, 2015. ",
+        "bbox": [
+            173,
+            750,
+            821,
+            779
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Samuel R Bowman, Jon Gauthier, Abhinav Rastogi, Raghav Gupta, Christopher D Manning, and Christopher Potts. A fast unified model for parsing and sentence understanding. arXiv preprint arXiv:1603.06021, 2016. ",
+        "bbox": [
+            174,
+            789,
+            823,
+            830
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jianpeng Cheng, Li Dong, and Mirella Lapata. Long short-term memory-networks for machine reading. In Conference on Empirical Methods in Natural Language Processing (EMNLP). Association for Computational Linguistics, 2016. ",
+        "bbox": [
+            174,
+            842,
+            823,
+            885
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Junyoung Chung, Caglar Gulcehre, KyungHyun Cho, and Yoshua Bengio. Empirical evaluation of gated recurrent neural networks on sequence modeling. arXiv preprint arXiv:1412.3555, 2014. ",
+        "bbox": [
+            176,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Cicero dos Santos and Maira Gatti. Deep convolutional neural networks for sentiment analysis of short texts. In Proceedings of COLING 2014, the 25th International Conference on Computational Linguistics: Technical Papers, pp. 69–78, 2014. ",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Cicero dos Santos, Ming Tan, Bing Xiang, and Bowen Zhou. Attentive pooling networks. arXiv preprint arXiv:1602.03609, 2016. ",
+        "bbox": [
+            171,
+            156,
+            823,
+            185
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Minwei Feng, Bing Xiang, Michael R. Glass, Lidan Wang, and Bowen Zhou. Applying deep learning to answer selection: a study and an open task. In 2015 IEEE Workshop on Automatic Speech Recognition and Understanding, ASRU 2015, Scottsdale, AZ, USA, December 13-17, 2015, pp. 813–820, 2015. ",
+        "bbox": [
+            173,
+            195,
+            825,
+            251
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Felix Hill, Kyunghyun Cho, and Anna Korhonen. Learning distributed representations of sentences from unlabelled data. In Proceedings of the 2016 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, pp. 1367– 1377, San Diego, California, June 2016. Association for Computational Linguistics. URL http: //www.aclweb.org/anthology/N16-1162. ",
+        "bbox": [
+            173,
+            262,
+            825,
+            333
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural computation, 9(8): 1735–1780, 1997. ",
+        "bbox": [
+            171,
+            343,
+            823,
+            371
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nal Kalchbrenner, Edward Grefenstette, and Phil Blunsom. A convolutional neural network for modelling sentences. arXiv preprint arXiv:1404.2188, 2014. ",
+        "bbox": [
+            173,
+            382,
+            823,
+            411
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yoon Kim. Convolutional neural networks for sentence classification. arXiv preprint arXiv:1408.5882, 2014. ",
+        "bbox": [
+            174,
+            421,
+            823,
+            449
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ryan Kiros, Yukun Zhu, Ruslan R Salakhutdinov, Richard Zemel, Raquel Urtasun, Antonio Torralba, and Sanja Fidler. Skip-thought vectors. In Advances in neural information processing systems, pp. 3294–3302, 2015. ",
+        "bbox": [
+            174,
+            459,
+            825,
+            503
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Quoc V Le and Tomas Mikolov. Distributed representations of sentences and documents. In ICML, volume 14, pp. 1188–1196, 2014. ",
+        "bbox": [
+            173,
+            512,
+            823,
+            542
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ji Young Lee and Franck Dernoncourt. Sequential short-text classification with recurrent and convolutional neural networks. arXiv preprint arXiv:1603.03827, 2016. ",
+        "bbox": [
+            171,
+            551,
+            823,
+            582
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Peng Li, Wei Li, Zhengyan He, Xuguang Wang, Ying Cao, Jie Zhou, and Wei Xu. Dataset and neural recurrent sequence labeling model for open-domain factoid question answering. arXiv preprint arXiv:1607.06275, 2016. ",
+        "bbox": [
+            173,
+            590,
+            823,
+            633
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Wang Ling, Lin Chu-Cheng, Yulia Tsvetkov, and Silvio Amir. Not all contexts are created equal: Better word representations with variable attention. In Proceedings of the 2015 Conference on Empirical Methods in Natural Language Processing, pp. 1367–1372, Lisbon, Portugal, September 2015. Association for Computational Linguistics. ",
+        "bbox": [
+            173,
+            643,
+            825,
+            700
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yang Liu, Chengjie Sun, Lei Lin, and Xiaolong Wang. Learning natural language inference using bidirectional LSTM model and inner-attention. CoRR, abs/1605.09090, 2016a. ",
+        "bbox": [
+            174,
+            710,
+            821,
+            739
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yang Liu, Chengjie Sun, Lei Lin, and Xiaolong Wang. Learning natural language inference using bidirectional lstm model and inner-attention. arXiv preprint arXiv:1605.09090, 2016b. ",
+        "bbox": [
+            173,
+            750,
+            823,
+            779
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Mingbo Ma, Liang Huang, Bing Xiang, and Bowen Zhou. Dependency-based convolutional neural networks for sentence embedding. In Proceedings of the 53rd Annual Meeting of the Association for Computational Linguistics and the 7th International Joint Conference on Natural Language Processing, volume 2, pp. 174–179, 2015. ",
+        "bbox": [
+            174,
+            789,
+            825,
+            845
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Horia Margarit and Raghav Subramaniam. A batch-normalized recurrent network for sentiment classification. In Advances in Neural Information Processing Systems, 2016. ",
+        "bbox": [
+            169,
+            856,
+            823,
+            885
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Roland Memisevic. Learning to relate images. IEEE transactions on pattern analysis and machine intelligence, 35(8):1829–1846, 2013. ",
+        "bbox": [
+            173,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tomas Mikolov, Kai Chen, Greg Corrado, and Jeffrey Dean. Efficient estimation of word representations in vector space. arXiv preprint arXiv:1301.3781, 2013. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Lili Mou, Rui Men, Ge Li, Yan Xu, Lu Zhang, Rui Yan, and Zhi Jin. Natural language inference by tree-based convolution and heuristic matching. arXiv preprint arXiv:1512.08422, 2015a. ",
+        "bbox": [
+            171,
+            140,
+            821,
+            170
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Lili Mou, Hao Peng, Ge Li, Yan Xu, Lu Zhang, and Zhi Jin. Discriminative neural sentence modeling by tree-based convolution. In Proceedings of the 2015 Conference on Empirical Methods in Natural Language Processing, pp. 2315–2325, Lisbon, Portugal, September 2015b. Association for Computational Linguistics. URL http://aclweb.org/anthology/D15-1279. ",
+        "bbox": [
+            173,
+            178,
+            825,
+            236
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Tsendsuren Munkhdalai and Hong Yu. Neural tree indexers for text understanding. arXiv preprint arXiv:1607.04492, 2016a. ",
+        "bbox": [
+            171,
+            244,
+            825,
+            272
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Tsendsuren Munkhdalai and Hong Yu. Neural semantic encoders. arXiv preprint arXiv:1607.04315, 2016b. ",
+        "bbox": [
+            174,
+            281,
+            821,
+            310
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Hamid Palangi, Li Deng, Yelong Shen, Jianfeng Gao, Xiaodong He, Jianshu Chen, Xinying Song, and Rabab Ward. Deep sentence embedding using long short-term memory networks: Analysis and application to information retrieval. IEEE/ACM Transactions on Audio, Speech, and Language Processing, 24(4):694–707, 2016. ",
+        "bbox": [
+            173,
+            319,
+            825,
+            376
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ankur P. Parikh, Oscar Tackstrom, Dipanjan Das, and Jakob Uszkoreit. A decomposable attention model for natural language inference. In Proceedings of EMNLP, 2016. ",
+        "bbox": [
+            173,
+            385,
+            823,
+            414
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jeffrey Pennington, Richard Socher, and Christopher D Manning. Glove: Global vectors for word representation. In EMNLP, volume 14, pp. 1532–43, 2014. ",
+        "bbox": [
+            173,
+            422,
+            823,
+            452
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Richard Socher, Jeffrey Pennington, Eric H. Huang, Andrew Y. Ng, and Christopher D. Manning. Semi-supervised recursive autoencoders for predicting sentiment distributions. In Proceedings of the 2011 Conference on Empirical Methods in Natural Language Processing, pp. 151–161, Edinburgh, Scotland, UK., July 2011. Association for Computational Linguistics. URL http: //www.aclweb.org/anthology/D11-1014. ",
+        "bbox": [
+            173,
+            460,
+            825,
+            531
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Richard Socher, Alex Perelygin, Jean Y Wu, Jason Chuang, Christopher D Manning, Andrew $\\mathrm { \\Upsilon { Y g } }$ , and Christopher Potts. Recursive deep models for semantic compositionality over a sentiment treebank. In Proceedings of the conference on empirical methods in natural language processing (EMNLP), volume 1631, pp. 1642. Citeseer, 2013. ",
+        "bbox": [
+            173,
+            540,
+            825,
+            597
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Kai Sheng Tai, Richard Socher, and Christopher D. Manning. Improved semantic representations from tree-structured long short-term memory networks. In Proceedings of ACL, pp. 1556–1566, 2015. ",
+        "bbox": [
+            174,
+            604,
+            823,
+            647
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ming Tan, Cicero dos Santos, Bing Xiang, and Bowen Zhou. Improved representation learning for question answer matching. In Proceedings of ACL, pp. 464–473, Berlin, Germany, August 2016. Association for Computational Linguistics. URL http://www.aclweb.org/anthology/ P16-1044. ",
+        "bbox": [
+            174,
+            656,
+            825,
+            713
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Theano Development Team. Theano: A {Python} framework for fast computation of mathematical expressions. arXiv e-prints, abs/1605.0, 2016. URL http://arxiv.org/abs/1605. 02688. ",
+        "bbox": [
+            174,
+            722,
+            825,
+            765
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ivan Vendrov, Ryan Kiros, Sanja Fidler, and Raquel Urtasun. Order-embeddings of images and language. arXiv preprint arXiv:1511.06361, 2015. ",
+        "bbox": [
+            171,
+            773,
+            825,
+            803
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Wenpeng Yin and Hinrich Schutze. Convolutional neural network for paraphrase identification. ¨ In Proceedings of the 2015 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, pp. 901–911, 2015. ",
+        "bbox": [
+            174,
+            811,
+            825,
+            854
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            279,
+            118
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A PRUNED MLP FOR STRUCTURED MATRIX SENTENCE EMBEDDING ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            136,
+            763,
+            154
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "As a side effect of having multiple vectors to represent a sentence, the matrix sentence embedding is usually several times larger than vector sentence embeddings. This results in needing more parameters in the subsequent fully connected layer, which connects every hidden units to every units in the matrix sentence embedding. Actually in the example shown in Figure 1, this fully connected layer takes around $90 \\%$ percent of the parameters. See Table 4. In this appendix we are going to introduce a weight pruning method which, by utilizing the 2D structure of matrix embedding, is able to drastically reduce the number of parameters in the fully connected hidden layer. ",
+        "bbox": [
+            173,
+            170,
+            825,
+            267
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Inheriting the notation used in the main paper, let the matrix embedding $M$ has a shape of $r$ by $u$ , and let the fully connected hidden layer has $b$ units. The normal fully connected hidden layer will require each hidden unit to be connected to every unit in the matrix embedding, as shown in Figure 1. This ends up with $r \\times u \\times b$ parameters in total. ",
+        "bbox": [
+            174,
+            275,
+            825,
+            330
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "However there are 2-D structures in the matrix embedding, which we should make use of. Each row $\\mathbf { \\dot { \\phi } } m _ { i }$ in Figure 1) in the matrix is computed from a weighted sum of LSTM hidden states, which means they share some similarities ",
+        "bbox": [
+            174,
+            337,
+            825,
+            378
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "To reflect these similarity in the fully connected layer, we split the hidden states into $r$ equally sized groups, with each group having $p$ units. The $i$ -th group is only fully connected to the $i$ -th row in the matrix representation. All connections that connects the $i$ -th group hidden units to other rows of the matrix are pruned away. In this way, Simillarity between different rows of matrix embedding are reflected as symmetry of connecting type in the hidden layer. As a result, the hidden layer can be interperated as also having a 2-D structute, with the number $( r )$ and size $( p )$ of groups as its two dimensions (The $M ^ { v }$ in Figure 6). When the total number of hidden units are the same (i.e., $r \\times p = b ,$ ), this process prunes away $( r - 1 ) / r$ of weight values, which is a fairly large portion when $r$ is large. ",
+        "bbox": [
+            173,
+            386,
+            825,
+            484
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/e429249761e9fa370a75158c97648271293e9bfbedb48b479ee3d18088cd066e.jpg",
+        "image_caption": [
+            "Figure 6: Hidden layer with pruned weight connections. $M$ is the matrix sentence embedding, $M ^ { v }$ and $M ^ { h }$ are the structured hidden representation computed by pruned weights. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            236,
+            508,
+            759,
+            724
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/2d9382fa257c4f65ac7dd75f65e49c0d28165a5a78fb62b7f301264fc2466709.jpg",
+        "table_caption": [
+            "Table 4: Model Size Comparison Before and After Pruning "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>Hidden layer</td><td> Softmax</td><td>Other Parts</td><td>Total</td><td>Accuracy</td></tr><tr><td>Yelp, Original, b=3000</td><td>54M</td><td>15K</td><td>1.3M</td><td>55.3M</td><td>64.21%</td></tr><tr><td>Yelp,Pruned, p=150, q=10</td><td>2.7M</td><td>52.5K</td><td>1.3M</td><td>4.1M</td><td>63.86%</td></tr><tr><td>Age, Original, b=4000</td><td>72M</td><td>20K</td><td>1.3M</td><td>73.2M</td><td>80.45%</td></tr><tr><td>Age,Pruned, p=25, q=20</td><td>822K</td><td>63.75K</td><td>1.3M</td><td>2.1M</td><td>77.32%</td></tr><tr><td>SNLI, Original, b=4000 SNLI, Pruned, p=300, q=10</td><td>72M 5.6M</td><td>12K 45K</td><td>22.9M 22.9M</td><td>95.0M 28.6M</td><td>84.43% 83.16%</td></tr></table>",
+        "bbox": [
+            176,
+            813,
+            820,
+            916
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "On the other dimension, another form of similarity exists too. For each vector representation $m _ { i }$ in $M$ , the $j$ -th element $m _ { i j }$ is a weighted sum of an LSTM hidden unit at different time steps. And for a certain $j$ -th element in all vector representations, they are summed up from a same LSTM hidden unit. We can also reflect this similarity into the symmetry of weight connections by using the same pruning method we did above. Thus we will have another 2-D structured hidden states sized $u$ -by- $q$ , noted as $M ^ { h }$ in Figure 6. ",
+        "bbox": [
+            173,
+            138,
+            825,
+            222
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Table 4 takes the model we use for yelp dataset as a concrete example, and compared the number of parameters in each part of the model, both before and after pruning. We can see the above pruning method drastically reduces the model size. Note that the $p$ and $q$ in this structure can be adjusted freely as hyperparameters. Also, we can continue the corresponding pruning process on top of $M ^ { v }$ and ${ \\dot { M } } ^ { h }$ over and over again, and end up with having a stack of structured hidden layers, just like stacking fully connected layers. ",
+        "bbox": [
+            174,
+            229,
+            825,
+            313
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "The subsequent softmax layer will be fully connected to both $M _ { v }$ and $M _ { h }$ , i.e., each unit in the softmax layer is connected to all units in $M _ { v }$ and $M _ { h }$ . This is not a problem since the speed of softmax is largely dependent of the number of softmax units, which is not changed.In addition, for applications like sentiment analysis and textural entailment, the softmax layer is so tiny that only contains several units. ",
+        "bbox": [
+            174,
+            319,
+            825,
+            390
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Experimental results in the three datasets has shown that, this pruning mechanism lowers performances a bit, but still allows all three models to perform comparable or better than other models compared in the paper. ",
+        "bbox": [
+            174,
+            397,
+            825,
+            439
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "B DETAILED STRUCTURE OF THE MODEL FOR SNLI DATASET ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            464,
+            707,
+            481
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "In Section 2 we tested our matrix sentence embedding model for the textual entailment task on the SNLI dataset. Different from the former two tasks, the textual entailment task consists of a pair of sentences as input. We propose to use a set of multiplicative interactions to combine the two matrix embeddings extracted for each sentence. The form of multiplicative interaction is inspired by Factored Gated Autoencoder (Memisevic, 2013). ",
+        "bbox": [
+            174,
+            500,
+            826,
+            541
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/22b6eb1c3efb70e442f8931e24c4aef61dec1d1f63c6ed017e9593cfd00e10ca.jpg",
+        "image_caption": [
+            "Figure 7: Model structure used for textual entailment task. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            238,
+            569,
+            759,
+            895
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "The overall structure of our model for SNLI is dipicted in Figure 7. For both hypothesis and premise, we extract their embeddings $M _ { h }$ and $M _ { p }$ in the figure) independently, with a same LSTM and attention mechanism. The parameters of this part of model are shared (rectangles with dashed orange line in the figure). ",
+        "bbox": [
+            174,
+            138,
+            825,
+            194
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Comparing the two matrix embeddings corresponds to the green dashed rectangle part in the figure, which computes a single matrix embedding $( F _ { r } )$ as the factor of semantic relation between the two sentences. To represent the relation between $M _ { h }$ and $M _ { p }$ , $F _ { r }$ can be connected to $M _ { h }$ and $M _ { p }$ through a three-way multiplicative interaction. In a three-way multiplicative interaction, the value of anyone of $F _ { r }$ , $M _ { h }$ and $M _ { p }$ is a function of the product of the others. This type of connection is originally introduced to extract relation between images (Memisevic, 2013). Since here we are just computing the factor of relations $( F _ { r } )$ from $M _ { h }$ and $M _ { p }$ , it corresponds to the encoder part in the Factored Gated Autoencoder in Memisevic (2013). We call it Gated Encoder in Figure 7. ",
+        "bbox": [
+            174,
+            202,
+            825,
+            313
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "First we multiply each row in the matrix embedding by a different weight matrix. Repeating it over all rows, corresponds to a batched dot product between a 2-D matrix and a 3-D weight tensor. Inheriting the name in (Memisevic, 2013), we call the resulting matrix as factor. Doing the batched dot for both hypothesis embedding and premise embedding, we have $F _ { h }$ and $F _ { p }$ , respectively. ",
+        "bbox": [
+            174,
+            319,
+            825,
+            376
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "equation",
+        "img_path": "images/67e1f41e9f285a3d3c04d1ea485d4050f69ded8d9e66358f2189814267796a7d.jpg",
+        "text": "$$\n\\begin{array} { r } { F _ { h } = b a t c h e d d o t ( M _ { h } , W _ { f h } ) } \\\\ { F _ { p } = b a t c h e d d o t ( M _ { p } , W _ { f p } ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            400,
+            395,
+            598,
+            434
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Here $W _ { f h }$ and $W _ { f p }$ are the two weight tensors for hypothesis embedding and premise embedding. ",
+        "bbox": [
+            174,
+            441,
+            820,
+            457
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "The factor of the relation $( F _ { r } )$ is just an element-wise product of $F _ { h }$ and $F _ { p }$ (the triangle in the middle of Figure 7): ",
+        "bbox": [
+            173,
+            463,
+            823,
+            492
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "equation",
+        "img_path": "images/86fb3fd99db25c8ef0c7bc0295b73ae986fa88568f0829d221f6ce5af3bc11fd.jpg",
+        "text": "$$\nF _ { r } = F _ { h } \\odot F _ { p }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            449,
+            512,
+            549,
+            529
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Here $\\odot$ stands for element-wise product. After the $F _ { r }$ layer, we then use an MLP with softmax output to classify the relation into different categlories. ",
+        "bbox": [
+            171,
+            539,
+            823,
+            568
+        ],
+        "page_idx": 14
+    }
+]

parse/train/HJy_5Mcll/HJy_5Mcll.md

@@ -0,0 +1,213 @@
+# ENET: A DEEP NEURAL NETWORK ARCHITECTURE FOR REAL-TIME SEMANTIC SEGMENTATION
+
+Adam Paszke   
+Faculty of Mathematics, Informatics and Mechanics   
+University of Warsaw, Poland   
+a.paszke@students.mimuw.edu.pl
+
+# Abhishek Chaurasia, Sangpil Kim & Eugenio Culurciello
+
+Electrical and Computer Engineering Purdue University, USA aabhish, sangpilkim, euge@purdue.edu
+
+# ABSTRACT
+
+The ability to perform pixel-wise semantic segmentation in real-time is of paramount importance in practical mobile applications. Recent deep neural networks aimed at this task have the disadvantage of requiring a large number of floating point operations and have long run-times that hinder their usability. In this paper, we propose a novel deep neural network architecture named ENet (efficient neural network), created specifically for tasks requiring low latency operation. ENet is up to $1 8 \times$ faster, requires $7 5 \times$ less FLOPs, has $7 9 \times$ less parameters, and provides similar or better accuracy to existing models. We have tested it on CamVid, Cityscapes and SUN datasets and report on comparisons with existing state-of-the-art methods, and the trade-offs between accuracy and processing time of a network. We present performance measurements of the proposed architecture on embedded systems and suggest possible software improvements that could make ENet even faster.
+
+# 1 INTRODUCTION
+
+Recent interest in augmented reality wearables, home-automation devices, and self-driving vehicles has created a strong need for semantic-segmentation (or visual scene-understanding) algorithms that can operate in real-time on low-power mobile devices. These algorithms label each and every pixel in the image with one of the object classes. In recent years, the availability of larger datasets and computationally-powerful machines have helped deep convolutional neural networks (CNNs) (LeCun & Bengio (1998); Krizhevsky et al. (2012); Simonyan & Zisserman (2014a); Szegedy et al. (2015a)) surpass the performance of many conventional computer vision algorithms (Shotton et al. (2009); Perronnin et al. (2010); van de Sande et al. (2011)). Even though CNNs are increasingly successful at classification and categorization tasks, they provide coarse spatial results when applied to pixel-wise labeling of large images. Therefore, they are often cascaded with other algorithms to refine the results, such as color based segmentation (Farabet et al. (2013)) or conditional random fields (Chen et al. (2014)), to name a few.
+
+In order to both spatially classify and finely segment images, several neural network architectures have been proposed, such as SegNet (Badrinarayanan et al. (2015a;b)) or fully convolutional networks (Long et al. (2015)). All these works are based on a VGG16 (Simonyan & Zisserman (2014b)) architecture, which is a very large model designed for multi-class classification. These references use models with a large number of parameters, and slow inference time. In these conditions, they become unusable for many mobile or battery-powered applications, which require processing images at rates higher than 10 fps.
+
+In this paper, we propose a new neural network architecture optimized for high-accuracy and also fast inference. In our work, beside neural network processing, we chose not to use any other post-processing steps, in order to focus on the intrinsic performance of an end-to-end CNN approach.
+
+In Section 3 we propose a fast and compact encoder-decoder architecture named ENet. It has been designed according to rules and ideas that have appeared in the literature recently, all of which we discuss in Section 4. Performance of the proposed network has been tested on Cityscapes (Cordts et al. (2016)) and CamVid (Brostow et al. (2008)) for driving scenario, whereas SUN dataset (Song et al. (2015)) has been used for testing our network in an indoor situation. We benchmark it on NVIDIA Jetson TX1 Embedded Systems Module as well as on an NVIDIA Titan X GPU. The results can be found in Section 5.
+
+# 2 RELATED WORK
+
+Semantic segmentation is important in fully understanding the content of images, find target objects and segment them. This technique is of utmost importance in applications such as driving and augmented reality. Moreover, real-time operation is a must for these applications, and therefore, designing CNNs carefully is vital. Contemporary computer vision applications extensively use deep neural networks, now one of the most widely used techniques for many different tasks, including semantic segmentation. This work presents a fully trainable neural network architecture, and therefore we aim to compare to other literature that performs the large majority of inference in the same way.
+
+State-of-the-art scen-parsing CNNs use two separate neural network architectures combined together: an encoder and a decoder. Inspired by probabilistic auto-encoders (Ranzato et al. (2007); Ngiam et al. (2011)), encoder-decoder network architecture have been introduced in SegNet-basic (Badrinarayanan et al. (2015a)), and further improved in SegNet (Badrinarayanan et al. (2015b)). The encoder is a vanilla CNN (such as VGG16 from Simonyan & Zisserman (2014b)) which is trained to classify the input, while the decoder is used to upsample the output of the encoder (Long et al. (2015); Noh et al. (2015); Zheng et al. (2015); Eigen & Fergus (2015); Hong et al. (2015)). However, these networks are slow during inference due to their large architectures and numerous parameters. Unlike in Noh et al. (2015), fully connected layers of VGG16 were discarded in the latest incarnation of SegNet, in order to reduce the number of operations and memory footprint, making it the smallest of these networks. Still, none of them can operate in real-time.
+
+Other existing architectures use simpler classifiers and then cascade it with Conditional Random Field (CRF) as a post-processing step (Chen et al. (2014); Sturgess et al. (2009)). As explained in Badrinarayanan et al. (2015b), these techniques use onerous post-processing steps and often fail to label the classes that occupy fewer number of pixels in a frame. CNNs can be combined with recurrent neural networks (Zheng et al. (2015)) for better performance, but suffers from further speed degradation. Also, one has to keep in mind that RNN, used as a post-processing step, can be used in conjunction with any other technique, including the one presented in this work.
+
+# 3 NETWORK ARCHITECTURE
+
+The architecture of our network is presented in Table 1. It is divided into several stages, as highlighted by horizontal lines in the table and the first digit after each block name. Output sizes are reported for an example input image resolution of $5 1 2 \times 5 1 2$ . We adopt a view of ResNets (He et al. (2015b)) that describes them as having a single main branch and extensions with convolutional filters that separate from it, and then merge back with an element-wise addition, as shown in Figure 1b. Just as in the original paper, we refer to these as bottleneck modules. They consist of three convolutional layers: a $1 \times 1$ projection that reduces the dimensionality, a main convolutional layer (conv in Figure 1b), and a $1 \times 1$ expansion. If the bottleneck is downsampling, a max pooling layer is added to the main branch. We zero pad the activations, to match the number of feature maps. Also, the first $1 \times 1$ projection is replaced with a $2 \times 2$ convolution with stride 2 in both dimensions. conv is either a regular, dilated or full convolution (also known as deconvolution or fractionally strided convolution) with $3 \times 3$ filters. Sometimes we replace it with asymmetric convolution i.e. a sequence of $5 \times 1$ and $1 \times 5$ convolutions. For the regularizer, we use Spatial Dropout (Tompson et al. (2015)), with $p = 0 . 0 1$ before bottleneck2.0, and $p = 0 . 1$ afterwards.
+
+The initial stage contains a single block, that is presented in Figure 1a. Stage 1 consists of 5 bottleneck blocks, while stage 2 and 3 have the same structure, with the exception that stage 3 does not downsample the input at the beginning (we omit the 0th bottleneck). These three first stages are the encoder. Stage 4 and 5 belong to the decoder.
+
+![](images/3d811125fc485f27b800c8976f19705f72633a395c9c3be4441ef0eb0a1d69a4.jpg)  
+Figure 1: (a) ENet initial block. MaxPooling is performed with non-overlapping $2 \times 2$ windows, and the convolution has 13 filters, which sums up to 16 feature maps after concatenation. This is heavily inspired by Szegedy et al. (2015b). (b) ENet bottleneck module. conv is either a regular, dilated, or full convolution (also known as deconvolution) with $3 \times 3$ filters, or a $5 \times 5$ convolution decomposed into two asymmetric ones.
+
+We did not use bias terms in any of the projections, in order to reduce the number of kernel calls and overall memory operations, as cuDNN (Chetlur et al. (2014)) uses separate kernels for convolutions and bias addition. This choice didn’t have any impact on the accuracy. Between each convolutional layer and following non-linearity we use Batch Normalization (Ioffe & Szegedy (2015)). In the decoder max pooling is replaced with max unpooling, and padding is replaced with spatial convolution without bias. We did not use unpooling information in the last upsampling module, because the initial block operated on the 3 channels of the input frame, while the final output has $C$ feature maps (the number of object classes). Also, for performance reasons, we decided to place only a bare full convolution as last module of the network, which alone takes up a sizeable portion of the decoder processing time.
+
+Table 1: ENet architecture. Output sizes are given for an example input of $5 1 2 \times 5 1 2$ .   
+
+<table><tr><td>Name</td><td>Type</td><td>Output size</td></tr><tr><td>initial</td><td></td><td>16 × 256× 256</td></tr><tr><td>bottleneck1.0</td><td>downsampling</td><td>64× 128 ×128</td></tr><tr><td>4× bottleneck1.x</td><td></td><td>64 × 128 × 128</td></tr><tr><td>bottleneck2.0</td><td>downsampling</td><td>128 ×64× 64</td></tr><tr><td>bottleneck2.1</td><td></td><td>128 × 64× 64</td></tr><tr><td>bottleneck2.2</td><td>dilated 2</td><td>128×64×64</td></tr><tr><td>bottleneck2.3</td><td>asymmetric 5</td><td>128×64×64</td></tr><tr><td>bottleneck2.4</td><td>dilated 4</td><td>128 × 64× 64</td></tr><tr><td>bottleneck2.5</td><td></td><td>128 × 64× 64</td></tr><tr><td>bottleneck2.6</td><td>dilated 8</td><td>128 × 64× 64</td></tr><tr><td>bottleneck2.7</td><td>asymmetric 5</td><td>128 ×64×64</td></tr><tr><td>bottleneck2.8</td><td>dilated 16</td><td>128×64×64</td></tr><tr><td colspan="3">Repeat section 2,without bottleneck2.0</td></tr><tr><td>bottleneck4.0</td><td>upsampling</td><td>64 × 128 × 128</td></tr><tr><td>bottleneck4.1</td><td></td><td>64×128×128</td></tr><tr><td>bottleneck4.2</td><td></td><td>64 × 128 × 128</td></tr><tr><td>bottleneck5.0</td><td>upsampling</td><td>16 × 256 × 256</td></tr><tr><td>bottleneck5.1</td><td></td><td>16 × 256× 256</td></tr><tr><td>fullconv</td><td></td><td>C × 512 × 512</td></tr></table>
+
+# 4 DESIGN CHOICES
+
+In this section we will discuss our most important experimental results and intuitions, that have shaped the final architecture of ENet.
+
+Feature map resolution: Downsampling images during semantic segmentation has two main drawbacks. Firstly, reducing feature map resolution implies loss of spatial information like exact edge shape. Secondly, full pixel segmentation requires that the output has the same resolution as the input. This implies that strong downsampling will require equally strong upsampling, which increase model size and computational cost. The first issue has been addressed in Long et al. (2015) by adding the feature maps produced by encoder, and in SegNet (Badrinarayanan et al. (2015a)) by saving the elements index from the corresponding encoder max-pooling module. We followed the SegNet approach, because it allows to reduce memory requirements, but we found that using a strong downsampling still reduces the final accuracy.
+
+However, downsampling has one big advantage. Filters operating on downsampled images have a bigger receptive field, that allows them to gather more context. This is especially important when trying to differentiate between classes occupying a small portion of the overall image, as, for example, rider and pedestrian in a road scene. It is just not enough that the network learns how people look, the context in which they appear is important as well. At the end, we have found that it is better to use dilated convolutions for the purpose of extending context information (Yu & Koltun (2015)).
+
+Early downsampling: One crucial intuition to achieving good performance and real-time operation is realizing that processing large input frames is very expensive. This might sound very obvious, however many popular architectures (Hong et al. (2015); Badrinarayanan et al. (2015b)) do not pay much attention towards optimization of early stages of network, which are often the most expensive.
+
+ENet first two blocks heavily reduce the input size, and use only a small set of feature maps. The idea behind it, is that visual information is highly redundant in space, and thus can be compressed into a more efficient representation. Also, our intuition is that the initial network layers should not be used specifilly only for classification. Instead, they should rather act as good feature extractors and preprocess the input for later portions of the network. This insight worked well in our experiments. Increasing the number of feature maps from 16 to 32 did not improve the accuracy on Cityscapes dataset (Cordts et al. (2016)).
+
+Decoder size: In this work we would like to provide a different view on encoder-decoder architectures than the one presented in Badrinarayanan et al. (2015b). SegNet is a very symmetric architecture, as the encoder is an exact mirror of the encoder. Instead, our architecture consists of a large encoder, and a small decoder. This is motivated by the idea that the encoder should be able to work in a similar fashion to original classification architectures, i.e. to operate on smaller resolution data and provide for information processing and filtering. Instead, the role of the the decoder, is only to upsample the output of the encoder, fine-tuning the details.
+
+Nonlinear operations: He et al. (2016) report that it is beneficial to use ReLU and Batch Normalization layers before convolutions. We tried applying these ideas to ENet, but this had a detrimental effect on accuracy. Investigating its cause we replaced all ReLUs in the network with PReLUs (He et al. (2015a)), which use an additional parameter per feature map, with the goal of learning the negative slope of non-linearities. We expected that in layers where identity is a preferable transfer function, PReLU weights will have values around 1, and conversely, values around 0 if ReLU is preferable. Results of this experiment can be seen in Figure 2.
+
+The first layers weights exhibit a large variance and are slightly biased towards positive values, while in the later portions of the encoder they settle to recurring pattern. All layers in the main branch behave nearly exactly like regular ReLUs, while the weights inside bottleneck modules are negative i.e. the function inverts and scales down negative values. We hypothesize that identity did not work out well in our architecture because of its limited depth. We hypothesize that the reason why such lossy functions are learned is that He et al. (2016) uses networks that are hundreds of layers deep, while our network uses fewer layers, and it needs to quickly filter out information. It is notable that the decoder weights become much more positive and learn functions closer to identity. This confirms our intuitions that the decoder is used only to fine-tune the upsampled output.
+
+Information-preserving dimensionality changes: As stated earlier, it is necessary to downsample the input early, but aggressive dimensionality reduction can also hinder the information flow. A very good approach to this problem has been presented in Szegedy et al. (2015b). However, pooling after a convolution, in case of increasing feature map depth, is computationally expensive. Therefore, we prefer to perform pooling operation in parallel with convolution of stride 2, and concatenate resulting feature maps. This technique allowed us to speed up inference time of the initial block 10 times.
+
+Additionally, we have found one problem in the original ResNet architecture. When downsampling, the first $1 \times 1$ projection of the convolutional branch is performed with a stride of 2 in both dimensions, which effectively discards $7 5 \%$ of the input. Increasing the filter size to $2 \times 2$ allows to take the full input into consideration, and thus improves the information flow and accuracy. Of course, it makes these layers $4 \times$ more computationally expensive, however there are so few of these in ENet, that the overhead is not noticeable.
+
+![](images/8ee4cf5e3cab0eb753a0beb93ff4d6ee95b858dcca5a326251df16b36b1dba7e.jpg)  
+Figure 2: PReLU weight distribution vs network depth. Blue line is the weights mean, while an area between maximum and minimum weight is grayed out. Each vertical dotted line corresponds to a PReLU in the main branch and marks the boundary between each of bottleneck blocks. The gray vertical line at 67th module is placed at encoder-decoder border.
+
+Factorizing filters: It has been shown that convolutional weights have a fair amount of redundancy, and each $n \times n$ convolution can be decomposed into two smaller asymmetric convolutions: one with a $n \times 1$ filter followed by a $1 \times n$ filter (Jin et al. (2014); Szegedy et al. (2015b)). We have used asymmetric convolutions with $n = 5$ in our network, so cost of these two operations is similar to a single $3 \times 3$ convolution. This allowed to increase the variety of functions learned by each block and increase the receptive field.
+
+Sequence of operations used in the bottleneck module (projection, convolution, projection) can be seen as decomposing one large convolutional layer into a series of smaller and simpler low-rank approximation operations. Such factorization allows for large speedups and reduction in number of parameters, making them less redundant (Jin et al. (2014)).
+
+Dilated convolutions: As argued above, it is very important for the network to have a wide receptive field, so it can perform classification by taking a bigger portion of the image (context) into account. We wanted to avoid overly downsampling the feature maps, and decided to use dilated convolutions (Yu & Koltun (2015)) to improve our model. We have used them inside several bottleneck modules, in particular the ones that operate on the smallest resolutions. These gave a significant accuracy boost, by raising IoU on Cityscapes by around 4 percentage points, with no additional cost. We obtained the best accuracy when we interleaved them with other bottleneck modules (both regular and asymmetric), instead of arranging them in sequence, as has been done in Yu & Koltun (2015).
+
+Regularization: Most pixel-wise segmentation datasets are relatively small (on order of $1 0 ^ { 3 }$ images), so such expressive models as neural networks quickly begin to overfit them. In initial experiments, we used L2 weight decay with little success. Then, inspired by Huang et al. (2016), we have tried stochastic depth, which increased accuracy. However it became apparent that dropping branches (i.e. setting their output to 0) is in fact a special case of applying Spatial Dropout (Tompson et al. (2015)), where either all of the channels, or none of them are ignored, instead of selecting a random subset. We placed Spatial Dropout at the end of convolutional branches, right before the addition, and it turned out to work much better than stochastic depth.
+
+# 5 RESULTS
+
+We benchmarked the performance of ENet on three different datasets to demonstrate real-time and accurate for practical applications. We tested on CamVid and Cityscapes datasets of road scenes, and SUN RGB-D dataset of indoor scenes. We set SegNet (Badrinarayanan et al. (2015b)) as a baseline since it is one of the fastest segmentation model available, that also requires less memory to operate than plain CNNs. All our models, training, testing and performance evaluation scripts were written using the Torch7 machine-learning library. To compare results, we use class average accuracy and intersection-over-union (IoU) metrics.
+
+# 5.1 PERFORMANCE ANALYSIS
+
+We report results on inference speed on widely used NVIDIA Titan X GPU as well as on NVIDIA TX1 embedded system module. ENet was designed to achieve more than 10 fps on the NVIDIA TX1 board with an input image size $6 4 0 \times 3 6 0$ (W,H), which is adequate for practical road scene parsing applications. For inference we merge batch normalization and dropout layers into the convolutional filters, to speed up all networks.
+
+Table 2: Performance comparison. Image size is $\mathrm { W } \times \mathrm { H }$   
+
+<table><tr><td rowspan="3">Model</td><td colspan="6">NVIDIA TX1</td><td colspan="6">NVIDIA Titan X</td></tr><tr><td colspan="2">480×320</td><td colspan="2">640×360</td><td colspan="2">1280×720</td><td colspan="2">640×360</td><td colspan="2">1280×720</td><td colspan="2">1920×1080</td></tr><tr><td>ms</td><td>fps</td><td>ms</td><td>fps</td><td>ms</td><td>fps</td><td>ms</td><td>fps</td><td>ms</td><td>fps</td><td>ms</td><td>fps</td></tr><tr><td>SegNet</td><td>757</td><td>1.3</td><td>1251</td><td>0.8</td><td>-</td><td>1</td><td>69</td><td>14.6</td><td>289</td><td>3.5</td><td>637</td><td>1.6</td></tr><tr><td>ENet</td><td>47</td><td>21.1</td><td>69</td><td>14.6</td><td>262</td><td>3.8</td><td>7</td><td>135.4</td><td>21</td><td>46.8</td><td>46</td><td>21.6</td></tr></table>
+
+Inference time: Table 2 compares inference time for a single input frame of varying resolution. We also report the number of frames per second that can be processed. Dashes indicate that we could not obtain a measurement, due to lack of memory. ENet is significantly faster than competing architectures, providing high frame rates for real-time applications and allowing for practical use of very deep neural network models with encoder-decoder architecture.
+
+Table 3: Hardware requirements. FLOPs are estimated for an input of $3 \times 6 4 0 \times 3 6 0$ (C,W,H).   
+
+<table><tr><td></td><td>GFLOPs</td><td>Parameters</td><td>Model size (fp16)</td></tr><tr><td>SegNet</td><td>286.03</td><td>29.46M</td><td>56.2 MB</td></tr><tr><td>ENet</td><td>3.83</td><td>0.37M</td><td>0.7 MB</td></tr></table>
+
+Hardware requirements: Table 3 reports a comparison of number of operations and parameters used by different models. ENet efficiency is evident in the much low number of operations per frame and overall parameters. Please note that we report storage required to store the models in half precision floating point format. ENet has so few parameters that it can be saved into a file of just 0.7MB, which makes it possible to fit the whole network in an extremely fast on-chip memory in embedded processors. This alleviates the need for model compression (Han et al. (2015)), making it possible to use general purpose code for neural network computation. However, if one needs to operate under incredibly strict memory constraints, these techniques can still be applied to ENet as well.
+
+Software limitations: One of the most important techniques that has allowed us to reach these levels of performance is convolutional layer factorization. However, we have found one surprising drawback. Although applying this method allowed us to greatly reduce the number of floating point operations and parameters, it also increased the number of individual kernels calls, making each of them smaller.
+
+We have found that some of these operations become so cheap, that the cost of GPU kernel launch starts to outweigh the cost of the actual computation. Also, because kernels do not have access to values that have been kept in registers by previous ones, they have to load all data from global memory at launch, and save it when their work is finished. This means that using a higher number of kernels, increases the number of memory operations, because feature maps have to be constantly saved and reloaded. This becomes especially apparent in case of non-linear operations. In ENet, PReLUs consume more than a quarter of inference time. Since they are only simple point-wise operations and very easy to parallelize, we hypothesize it is caused by the aforementioned data movement.
+
+These are serious limitations, however they could be resolved by performing kernel fusion in existing software i.e. create kernels that apply non-linearities to results of convolutions directly, or perform a number of smaller convolutions in one call. This improvement in GPU libraries, such as CuDNN, could increase the speed and efficiency of our network even further.
+
+# 5.2 BENCHMARKS
+
+During training we have used the Adam optimization algorithm (Kingma & Ba (2014)). It allowed ENet to converge very quickly and on every dataset we haver used training took only 3-4 hours on Titan X. Training of ENet was performed in two stages: first we train only the encoder to categorize downsampled regions of the input image, then we appended the decoder and train the network to perform upsampling and pixel-wise categorization. in this work, a learning rate of $5 \mathrm { e } { - 4 }$ and L2 weight decay of $2 \mathrm { e } { - 4 }$ , along with batch size of 10 consistently provided the best results. For categorization, we have used a custom class weighing scheme defined as wclass = 1ln(c+pclass) . In contrast to the inverse class probability weighing, the weights are bounded as the probability approaches 0. c is an additional hyper-parameter, which we set to 1.02 (i.e. we restrict the class weights to be in the interval of [1, 50]).
+
+Table 4: Cityscapes test set results   
+
+<table><tr><td>Model</td><td>Class IoU</td><td>Class iIoU</td><td>Category IoU</td><td>Category iIoU</td></tr><tr><td>SegNet</td><td>56.1</td><td>34.2</td><td>79.8</td><td>66.4</td></tr><tr><td>ENet</td><td>58.3</td><td>34.4</td><td>80.4</td><td>64.0</td></tr></table>
+
+Cityscapes: This dataset consists of 5000 fine-annotated images, out of which 2975 are available for training, 500 for validation, and the remaining 1525 have been selected as test set (Cordts et al. (2016)). Cityscapes was the most important benchmark for us, because of its outstanding quality and highly varying road scenarios, often featuring many pedestrians and cyclists. We trained on 19 classes that have been selected in the official evaluation scripts (Cordts et al. (2016)). It makes use of an additional metric called instance-level intersection over union metric (iIoU), which is IoU weighed by the average object size. As reported in Table 4, ENet outperforms SegNet in class IoU and iIoU, as well as in category IoU. ENet is currently the fastest model in the Cityscapes benchmark.
+
+Table 5: Results on CamVid test set of (1) SegNet-Basic, (2) SegNet, and (3) ENet   
+
+<table><tr><td>[apo</td><td>Buipling</td><td>2</td><td>S</td><td>8</td><td>S</td><td></td><td>rrrnsestd</td><td>geeee</td><td>P</td><td>xeeaaia</td><td>BTttreit</td><td>ae ssea</td><td>Grssero</td></tr><tr><td></td><td></td><td></td><td>91.2</td><td>82.7</td><td>36.9</td><td>93.3</td><td>55.0</td><td>47.5</td><td>44.8</td><td>74.1</td><td>16.0</td><td>62.9</td><td>n/a</td></tr><tr><td>1</td><td>75.0</td><td>84.6 87.3</td><td>92.4</td><td>82.1</td><td>20.5</td><td>97.2</td><td>57.1</td><td>49.3</td><td>27.5</td><td>84.4</td><td>30.7</td><td>65.2</td><td>55.6</td></tr><tr><td>23</td><td>88.8 74.7</td><td>77.8</td><td>95.1</td><td>82.4</td><td>51.0</td><td>95.1</td><td>67.2</td><td>51.7</td><td>35.4</td><td>86.7</td><td>34.1</td><td>68.3</td><td>51.3</td></tr></table>
+
+CamVid: Another automotive dataset, on which we have tested ENet, was CamVid. It contains 367 training and 233 testing images (Brostow et al. (2008)). There are eleven different classes such as building, tree, sky, car, road, etc. while the twelfth class contains unlabeled data, which we ignore while training. The original frame resolution for this dataset is $9 6 0 \times 7 2 0$ (W,H) but we downsampled the images to $4 8 0 \times 3 6 0$ before training. In Table 5 we compare the performance of ENet with existing state-of-the-art algorithms. ENet outperforms other models in six classes, which are difficult to learn because they correspond to smaller objects.
+
+Table 6: SUN RGB-D test set results   
+
+<table><tr><td>Model</td><td>Global avg.</td><td>Class avg.</td><td>Mean IoU</td></tr><tr><td>SegNet</td><td>70.3</td><td>35.6</td><td>26.3</td></tr><tr><td>ENet</td><td>59.5</td><td>32.6</td><td>19.7</td></tr></table>
+
+SUN RGB-D: The SUN dataset consists of 5285 training images and 5050 testing images with 37 indoor object classes. We did not make any use of depth information in this work and trained the network only on RGB data. In Table 6 we compare the performance of ENet with SegNet (Badrinarayanan et al. (2015b)), which is the only neural network model that reports accuracy on this dataset. Our results, though inferior in global average accuracy and IoU, are comparable in class average accuracy. Since global average accuracy and IoU are metrics that favor correct classification of classes occupying large image patches, researchers generally emphasize the importance of other metrics in case of semantic segmentation. One notable example is introduction of iIoU metric (Cordts et al. (2016)). Comparable result in class average accuracy indicates, that our network is capable of differentiating smaller objects nearly as well as SegNet. Moreover, the difference in accuracy should not overshadow the huge performance gap between these two networks. ENet can process the images in real-time, and is nearly $2 0 \times$ faster than SegNet on embedded platforms.
+
+![](images/a43847be877615b29500a3b4907152b197ca7fa458f0a9158c8621cd2ca44e97.jpg)  
+Figure 3: ENet predictions on popular benchmarks (rows top to down represent input image, ground truth, and ENet output respectively).
+
+# 6 CONCLUSION
+
+We have proposed a novel neural network architecture designed from the ground up specifically for semantic segmentation. Our main aim is to make efficient use of scarce resources available on embedded platforms, compared to fully fledged deep learning workstations. Our work provides large gains in this task, while matching and at times exceeding existing baseline models, that have an order of magnitude larger computational and memory requirements. The application of ENet on the NVIDIA TX1 hardware exemplifies real-time portable embedded solutions.
+
+Even though the main goal was to run the network on mobile devices, we have found that it is also very efficient on high end GPUs like NVIDIA Titan X. This may prove useful in data-center applications, where there is a need of processing large numbers of high resolution images. ENet allows to perform large-scale computations in a much faster and more efficient manner, which might lead to significant savings.
+
+# ACKNOWLEDGMENT
+
+This work is partly supported by the Office of Naval Research (ONR) grants N00014-12-1-0167, N00014-15-1-2791 and MURI N00014-10-1-0278. We gratefully acknowledge the support of NVIDIA Corporation with the donation of the TX1, Titan X, K40 GPUs used for this research.
+
+# REFERENCES
+
+Vijay Badrinarayanan, Ankur Handa, and Roberto Cipolla. Segnet: A deep convolutional encoderdecoder architecture for robust semantic pixel-wise labelling. arXiv preprint arXiv:1505.07293, 2015a.
+
+Vijay Badrinarayanan, Alex Kendall, and Roberto Cipolla. Segnet: A deep convolutional encoderdecoder architecture for image segmentation. arXiv preprint arXiv:1511.00561, 2015b.
+
+Gabriel J. Brostow, Jamie Shotton, Julien Fauqueur, and Roberto Cipolla. Segmentation and recognition using structure from motion point clouds. In ECCV (1), pp. 44–57, 2008.
+
+Liang-Chieh Chen, George Papandreou, Iasonas Kokkinos, Kevin Murphy, and Alan L Yuille. Semantic image segmentation with deep convolutional nets and fully connected crfs. arXiv preprint arXiv:1412.7062, 2014.
+
+Sharan Chetlur, Cliff Woolley, Philippe Vandermersch, Jonathan Cohen, John Tran, Bryan Catanzaro, and Evan Shelhamer. cudnn: Efficient primitives for deep learning. arXiv preprint arXiv:1410.0759, 2014.
+
+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 Proc. of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2016.
+
+David Eigen and Rob Fergus. Predicting depth, surface normals and semantic labels with a common multi-scale convolutional architecture. In Proceedings of the IEEE International Conference on Computer Vision, pp. 2650–2658, 2015.
+
+C. Farabet, C. Couprie, L. Najman, and Y. LeCun. Learning hierarchical features for scene labeling. IEEE Transactions on Pattern Analysis and Machine Intelligence, 35(8):1915–1929, Aug 2013. ISSN 0162-8828.
+
+Song Han, Huizi Mao, and William J. Dally. Deep compression: Compressing deep neural network with pruning, trained quantization and huffman coding. arXiv preprint arXiv:1510.00149, 2015.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Delving deep into rectifiers: Surpassing human-level performance on imagenet classification. pp. 1026–1034, 2015a.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. arXiv preprint arXiv:1512.03385, 2015b.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Identity mappings in deep residual networks. arXiv preprint arXiv:1603.05027, 2016.
+
+Seunghoon Hong, Hyeonwoo Noh, and Bohyung Han. Decoupled deep neural network for semisupervised semantic segmentation. In Advances in Neural Information Processing Systems, pp. 1495–1503, 2015.
+
+Gao Huang, Yu Sun, Zhuang Liu, Daniel Sedra, and Kilian Weinberger. Deep networks with stochastic depth. arXiv preprint arXiv:1603.09382, 2016.
+
+Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. arXiv preprint arXiv:1502.03167, 2015.
+
+Jonghoon Jin, Aysegul Dundar, and Eugenio Culurciello. Flattened convolutional neural networks for feedforward acceleration. arXiv preprint arXiv:1412.5474, 2014.
+
+Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
+
+Alex Krizhevsky, Ilya Sutskever, and Geoffrey E. Hinton. Imagenet classification with deep convolutional neural networks. In Advances in Neural Information Processing Systems 25, pp. 1097–1105. 2012.
+
+Yann LeCun and Yoshua Bengio. Convolutional networks for images, speech, and time series. The handbook of brain theory and neural networks, pp. 255–258, 1998.
+
+Jonathan Long, Evan Shelhamer, and Trevor Darrell. Fully convolutional networks for semantic segmentation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 3431–3440, 2015.
+
+Jiquan Ngiam, Aditya Khosla, Mingyu Kim, Juhan Nam, Honglak Lee, and Andrew Y Ng. Multimodal deep learning. In Proceedings of the 28th international conference on machine learning (ICML-11), pp. 689–696, 2011.
+
+Hyeonwoo Noh, Seunghoon Hong, and Bohyung Han. Learning deconvolution network for semantic segmentation. In Proceedings of the IEEE International Conference on Computer Vision, pp. 1520–1528, 2015.
+
+F. Perronnin, Y. Liu, J. Sánchez, and H. Poirier. Large-scale image retrieval with compressed fisher vectors. In Computer Vision and Pattern Recognition (CVPR), 2010 IEEE Conference on, pp. 3384–3391, 2010.
+
+Marc Aurelio Ranzato, Fu Jie Huang, Y-Lan Boureau, and Yann LeCun. Unsupervised learning of invariant feature hierarchies with applications to object recognition. In Computer Vision and Pattern Recognition, 2007. CVPR’07. IEEE Conference on, pp. 1–8, 2007.
+
+Jamie Shotton, John Winn, Carsten Rother, and Antonio Criminisi. Textonboost for image understanding: Multi-class object recognition and segmentation by jointly modeling texture, layout, and context. Int. Journal of Computer Vision (IJCV), January 2009.
+
+Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. arXiv preprint arXiv:1409.1556, 2014a.
+
+Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. arXiv preprint arXiv:1409.1556, 2014b.
+
+Shuran Song, Samuel P Lichtenberg, and Jianxiong Xiao. Sun rgb-d: A rgb-d scene understanding benchmark suite. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 567–576, 2015.
+
+Paul Sturgess, Karteek Alahari, Lubor Ladicky, and Philip HS Torr. Combining appearance and structure from motion features for road scene understanding. In BMVC 2012-23rd British Machine Vision Conference, 2009.
+
+Christian Szegedy, Wei Liu, Yangqing Jia, Pierre Sermanet, Scott Reed, Dragomir Anguelov, Dumitru Erhan, Vincent Vanhoucke, and Andrew Rabinovich. Going deeper with convolutions. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 1–9, 2015a.
+
+Christian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jonathon Shlens, and Zbigniew Wojna. Rethinking the inception architecture for computer vision. arXiv preprint arXiv:1512.00567, 2015b.
+
+Jonathan Tompson, Ross Goroshin, Arjun Jain, Yann LeCun, and Christoph Bregler. Efficient object localization using convolutional networks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 648–656, 2015.
+
+K. E. A. van de Sande, J. R. R. Uijlings, T. Gevers, and A. W. M. Smeulders. Segmentation as selective search for object recognition. In IEEE International Conference on Computer Vision, 2011.
+
+Fisher Yu and Vladlen Koltun. Multi-scale context aggregation by dilated convolutions. arXiv preprint arXiv:1511.07122, 2015.
+
+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 Proceedings of the IEEE International Conference on Computer Vision, pp. 1529–1537, 2015.

parse/train/HJy_5Mcll/HJy_5Mcll_content_list.json

@@ -0,0 +1,1146 @@
+[
+    {
+        "type": "text",
+        "text": "ENET: A DEEP NEURAL NETWORK ARCHITECTURE FOR REAL-TIME SEMANTIC SEGMENTATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            823,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Adam Paszke   \nFaculty of Mathematics, Informatics and Mechanics   \nUniversity of Warsaw, Poland   \na.paszke@students.mimuw.edu.pl ",
+        "bbox": [
+            184,
+            170,
+            526,
+            226
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abhishek Chaurasia, Sangpil Kim & Eugenio Culurciello ",
+        "text_level": 1,
+        "bbox": [
+            184,
+            247,
+            584,
+            262
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Electrical and Computer Engineering Purdue University, USA aabhish, sangpilkim, euge@purdue.edu ",
+        "bbox": [
+            184,
+            263,
+            537,
+            303
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            340,
+            544,
+            354
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The ability to perform pixel-wise semantic segmentation in real-time is of paramount importance in practical mobile applications. Recent deep neural networks aimed at this task have the disadvantage of requiring a large number of floating point operations and have long run-times that hinder their usability. In this paper, we propose a novel deep neural network architecture named ENet (efficient neural network), created specifically for tasks requiring low latency operation. ENet is up to $1 8 \\times$ faster, requires $7 5 \\times$ less FLOPs, has $7 9 \\times$ less parameters, and provides similar or better accuracy to existing models. We have tested it on CamVid, Cityscapes and SUN datasets and report on comparisons with existing state-of-the-art methods, and the trade-offs between accuracy and processing time of a network. We present performance measurements of the proposed architecture on embedded systems and suggest possible software improvements that could make ENet even faster. ",
+        "bbox": [
+            233,
+            369,
+            766,
+            549
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            573,
+            336,
+            588
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recent interest in augmented reality wearables, home-automation devices, and self-driving vehicles has created a strong need for semantic-segmentation (or visual scene-understanding) algorithms that can operate in real-time on low-power mobile devices. These algorithms label each and every pixel in the image with one of the object classes. In recent years, the availability of larger datasets and computationally-powerful machines have helped deep convolutional neural networks (CNNs) (LeCun & Bengio (1998); Krizhevsky et al. (2012); Simonyan & Zisserman (2014a); Szegedy et al. (2015a)) surpass the performance of many conventional computer vision algorithms (Shotton et al. (2009); Perronnin et al. (2010); van de Sande et al. (2011)). Even though CNNs are increasingly successful at classification and categorization tasks, they provide coarse spatial results when applied to pixel-wise labeling of large images. Therefore, they are often cascaded with other algorithms to refine the results, such as color based segmentation (Farabet et al. (2013)) or conditional random fields (Chen et al. (2014)), to name a few. ",
+        "bbox": [
+            174,
+            603,
+            825,
+            768
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In order to both spatially classify and finely segment images, several neural network architectures have been proposed, such as SegNet (Badrinarayanan et al. (2015a;b)) or fully convolutional networks (Long et al. (2015)). All these works are based on a VGG16 (Simonyan & Zisserman (2014b)) architecture, which is a very large model designed for multi-class classification. These references use models with a large number of parameters, and slow inference time. In these conditions, they become unusable for many mobile or battery-powered applications, which require processing images at rates higher than 10 fps. ",
+        "bbox": [
+            174,
+            777,
+            825,
+            875
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we propose a new neural network architecture optimized for high-accuracy and also fast inference. In our work, beside neural network processing, we chose not to use any other post-processing steps, in order to focus on the intrinsic performance of an end-to-end CNN approach. ",
+        "bbox": [
+            176,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In Section 3 we propose a fast and compact encoder-decoder architecture named ENet. It has been designed according to rules and ideas that have appeared in the literature recently, all of which we discuss in Section 4. Performance of the proposed network has been tested on Cityscapes (Cordts et al. (2016)) and CamVid (Brostow et al. (2008)) for driving scenario, whereas SUN dataset (Song et al. (2015)) has been used for testing our network in an indoor situation. We benchmark it on NVIDIA Jetson TX1 Embedded Systems Module as well as on an NVIDIA Titan X GPU. The results can be found in Section 5. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            200
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            220,
+            341,
+            236
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Semantic segmentation is important in fully understanding the content of images, find target objects and segment them. This technique is of utmost importance in applications such as driving and augmented reality. Moreover, real-time operation is a must for these applications, and therefore, designing CNNs carefully is vital. Contemporary computer vision applications extensively use deep neural networks, now one of the most widely used techniques for many different tasks, including semantic segmentation. This work presents a fully trainable neural network architecture, and therefore we aim to compare to other literature that performs the large majority of inference in the same way. ",
+        "bbox": [
+            174,
+            251,
+            825,
+            349
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "State-of-the-art scen-parsing CNNs use two separate neural network architectures combined together: an encoder and a decoder. Inspired by probabilistic auto-encoders (Ranzato et al. (2007); Ngiam et al. (2011)), encoder-decoder network architecture have been introduced in SegNet-basic (Badrinarayanan et al. (2015a)), and further improved in SegNet (Badrinarayanan et al. (2015b)). The encoder is a vanilla CNN (such as VGG16 from Simonyan & Zisserman (2014b)) which is trained to classify the input, while the decoder is used to upsample the output of the encoder (Long et al. (2015); Noh et al. (2015); Zheng et al. (2015); Eigen & Fergus (2015); Hong et al. (2015)). However, these networks are slow during inference due to their large architectures and numerous parameters. Unlike in Noh et al. (2015), fully connected layers of VGG16 were discarded in the latest incarnation of SegNet, in order to reduce the number of operations and memory footprint, making it the smallest of these networks. Still, none of them can operate in real-time. ",
+        "bbox": [
+            174,
+            356,
+            825,
+            508
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Other existing architectures use simpler classifiers and then cascade it with Conditional Random Field (CRF) as a post-processing step (Chen et al. (2014); Sturgess et al. (2009)). As explained in Badrinarayanan et al. (2015b), these techniques use onerous post-processing steps and often fail to label the classes that occupy fewer number of pixels in a frame. CNNs can be combined with recurrent neural networks (Zheng et al. (2015)) for better performance, but suffers from further speed degradation. Also, one has to keep in mind that RNN, used as a post-processing step, can be used in conjunction with any other technique, including the one presented in this work. ",
+        "bbox": [
+            174,
+            516,
+            825,
+            613
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3 NETWORK ARCHITECTURE ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            633,
+            428,
+            648
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The architecture of our network is presented in Table 1. It is divided into several stages, as highlighted by horizontal lines in the table and the first digit after each block name. Output sizes are reported for an example input image resolution of $5 1 2 \\times 5 1 2$ . We adopt a view of ResNets (He et al. (2015b)) that describes them as having a single main branch and extensions with convolutional filters that separate from it, and then merge back with an element-wise addition, as shown in Figure 1b. Just as in the original paper, we refer to these as bottleneck modules. They consist of three convolutional layers: a $1 \\times 1$ projection that reduces the dimensionality, a main convolutional layer (conv in Figure 1b), and a $1 \\times 1$ expansion. If the bottleneck is downsampling, a max pooling layer is added to the main branch. We zero pad the activations, to match the number of feature maps. Also, the first $1 \\times 1$ projection is replaced with a $2 \\times 2$ convolution with stride 2 in both dimensions. conv is either a regular, dilated or full convolution (also known as deconvolution or fractionally strided convolution) with $3 \\times 3$ filters. Sometimes we replace it with asymmetric convolution i.e. a sequence of $5 \\times 1$ and $1 \\times 5$ convolutions. For the regularizer, we use Spatial Dropout (Tompson et al. (2015)), with $p = 0 . 0 1$ before bottleneck2.0, and $p = 0 . 1$ afterwards. ",
+        "bbox": [
+            173,
+            662,
+            825,
+            858
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The initial stage contains a single block, that is presented in Figure 1a. Stage 1 consists of 5 bottleneck blocks, while stage 2 and 3 have the same structure, with the exception that stage 3 does not downsample the input at the beginning (we omit the 0th bottleneck). These three first stages are the encoder. Stage 4 and 5 belong to the decoder. ",
+        "bbox": [
+            174,
+            864,
+            823,
+            920
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/3d811125fc485f27b800c8976f19705f72633a395c9c3be4441ef0eb0a1d69a4.jpg",
+        "image_caption": [
+            "Figure 1: (a) ENet initial block. MaxPooling is performed with non-overlapping $2 \\times 2$ windows, and the convolution has 13 filters, which sums up to 16 feature maps after concatenation. This is heavily inspired by Szegedy et al. (2015b). (b) ENet bottleneck module. conv is either a regular, dilated, or full convolution (also known as deconvolution) with $3 \\times 3$ filters, or a $5 \\times 5$ convolution decomposed into two asymmetric ones. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            228,
+            99,
+            751,
+            285
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We did not use bias terms in any of the projections, in order to reduce the number of kernel calls and overall memory operations, as cuDNN (Chetlur et al. (2014)) uses separate kernels for convolutions and bias addition. This choice didn’t have any impact on the accuracy. Between each convolutional layer and following non-linearity we use Batch Normalization (Ioffe & Szegedy (2015)). In the decoder max pooling is replaced with max unpooling, and padding is replaced with spatial convolution without bias. We did not use unpooling information in the last upsampling module, because the initial block operated on the 3 channels of the input frame, while the final output has $C$ feature maps (the number of object classes). Also, for performance reasons, we decided to place only a bare full convolution as last module of the network, which alone takes up a sizeable portion of the decoder processing time. ",
+        "bbox": [
+            174,
+            404,
+            485,
+            680
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "table",
+        "img_path": "images/72ff3d428e386a18bcf0d7ac8a4e16d31026bb72fd000f71085c8e1506a66ed7.jpg",
+        "table_caption": [
+            "Table 1: ENet architecture. Output sizes are given for an example input of $5 1 2 \\times 5 1 2$ . "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Name</td><td>Type</td><td>Output size</td></tr><tr><td>initial</td><td></td><td>16 × 256× 256</td></tr><tr><td>bottleneck1.0</td><td>downsampling</td><td>64× 128 ×128</td></tr><tr><td>4× bottleneck1.x</td><td></td><td>64 × 128 × 128</td></tr><tr><td>bottleneck2.0</td><td>downsampling</td><td>128 ×64× 64</td></tr><tr><td>bottleneck2.1</td><td></td><td>128 × 64× 64</td></tr><tr><td>bottleneck2.2</td><td>dilated 2</td><td>128×64×64</td></tr><tr><td>bottleneck2.3</td><td>asymmetric 5</td><td>128×64×64</td></tr><tr><td>bottleneck2.4</td><td>dilated 4</td><td>128 × 64× 64</td></tr><tr><td>bottleneck2.5</td><td></td><td>128 × 64× 64</td></tr><tr><td>bottleneck2.6</td><td>dilated 8</td><td>128 × 64× 64</td></tr><tr><td>bottleneck2.7</td><td>asymmetric 5</td><td>128 ×64×64</td></tr><tr><td>bottleneck2.8</td><td>dilated 16</td><td>128×64×64</td></tr><tr><td colspan=\"3\">Repeat section 2,without bottleneck2.0</td></tr><tr><td>bottleneck4.0</td><td>upsampling</td><td>64 × 128 × 128</td></tr><tr><td>bottleneck4.1</td><td></td><td>64×128×128</td></tr><tr><td>bottleneck4.2</td><td></td><td>64 × 128 × 128</td></tr><tr><td>bottleneck5.0</td><td>upsampling</td><td>16 × 256 × 256</td></tr><tr><td>bottleneck5.1</td><td></td><td>16 × 256× 256</td></tr><tr><td>fullconv</td><td></td><td>C × 512 × 512</td></tr></table>",
+        "bbox": [
+            498,
+            448,
+            823,
+            762
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "4 DESIGN CHOICES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            704,
+            349,
+            719
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section we will discuss our most important experimental results and intuitions, that have shaped the final architecture of ENet. ",
+        "bbox": [
+            174,
+            738,
+            485,
+            780
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Feature map resolution: Downsampling images during semantic segmentation has two main drawbacks. Firstly, reducing feature map resolution implies loss of spatial information like exact edge shape. Secondly, full pixel segmentation requires that the output has the same resolution as the input. This implies that strong downsampling will require equally strong upsampling, which increase model size and computational cost. The first issue has been addressed in Long et al. (2015) by adding the feature maps produced by encoder, and in SegNet (Badrinarayanan et al. (2015a)) by saving the elements index from the corresponding encoder max-pooling module. We followed the SegNet approach, because it allows to reduce memory requirements, but we found that using a strong downsampling still reduces the final accuracy. ",
+        "bbox": [
+            173,
+            799,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "However, downsampling has one big advantage. Filters operating on downsampled images have a bigger receptive field, that allows them to gather more context. This is especially important when trying to differentiate between classes occupying a small portion of the overall image, as, for example, rider and pedestrian in a road scene. It is just not enough that the network learns how people look, the context in which they appear is important as well. At the end, we have found that it is better to use dilated convolutions for the purpose of extending context information (Yu & Koltun (2015)). ",
+        "bbox": [
+            174,
+            103,
+            825,
+            188
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Early downsampling: One crucial intuition to achieving good performance and real-time operation is realizing that processing large input frames is very expensive. This might sound very obvious, however many popular architectures (Hong et al. (2015); Badrinarayanan et al. (2015b)) do not pay much attention towards optimization of early stages of network, which are often the most expensive. ",
+        "bbox": [
+            174,
+            205,
+            825,
+            262
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "ENet first two blocks heavily reduce the input size, and use only a small set of feature maps. The idea behind it, is that visual information is highly redundant in space, and thus can be compressed into a more efficient representation. Also, our intuition is that the initial network layers should not be used specifilly only for classification. Instead, they should rather act as good feature extractors and preprocess the input for later portions of the network. This insight worked well in our experiments. Increasing the number of feature maps from 16 to 32 did not improve the accuracy on Cityscapes dataset (Cordts et al. (2016)). ",
+        "bbox": [
+            174,
+            268,
+            825,
+            366
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Decoder size: In this work we would like to provide a different view on encoder-decoder architectures than the one presented in Badrinarayanan et al. (2015b). SegNet is a very symmetric architecture, as the encoder is an exact mirror of the encoder. Instead, our architecture consists of a large encoder, and a small decoder. This is motivated by the idea that the encoder should be able to work in a similar fashion to original classification architectures, i.e. to operate on smaller resolution data and provide for information processing and filtering. Instead, the role of the the decoder, is only to upsample the output of the encoder, fine-tuning the details. ",
+        "bbox": [
+            174,
+            385,
+            825,
+            483
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Nonlinear operations: He et al. (2016) report that it is beneficial to use ReLU and Batch Normalization layers before convolutions. We tried applying these ideas to ENet, but this had a detrimental effect on accuracy. Investigating its cause we replaced all ReLUs in the network with PReLUs (He et al. (2015a)), which use an additional parameter per feature map, with the goal of learning the negative slope of non-linearities. We expected that in layers where identity is a preferable transfer function, PReLU weights will have values around 1, and conversely, values around 0 if ReLU is preferable. Results of this experiment can be seen in Figure 2. ",
+        "bbox": [
+            174,
+            501,
+            825,
+            598
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The first layers weights exhibit a large variance and are slightly biased towards positive values, while in the later portions of the encoder they settle to recurring pattern. All layers in the main branch behave nearly exactly like regular ReLUs, while the weights inside bottleneck modules are negative i.e. the function inverts and scales down negative values. We hypothesize that identity did not work out well in our architecture because of its limited depth. We hypothesize that the reason why such lossy functions are learned is that He et al. (2016) uses networks that are hundreds of layers deep, while our network uses fewer layers, and it needs to quickly filter out information. It is notable that the decoder weights become much more positive and learn functions closer to identity. This confirms our intuitions that the decoder is used only to fine-tune the upsampled output. ",
+        "bbox": [
+            174,
+            606,
+            825,
+            731
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Information-preserving dimensionality changes: As stated earlier, it is necessary to downsample the input early, but aggressive dimensionality reduction can also hinder the information flow. A very good approach to this problem has been presented in Szegedy et al. (2015b). However, pooling after a convolution, in case of increasing feature map depth, is computationally expensive. Therefore, we prefer to perform pooling operation in parallel with convolution of stride 2, and concatenate resulting feature maps. This technique allowed us to speed up inference time of the initial block 10 times. ",
+        "bbox": [
+            174,
+            750,
+            825,
+            833
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Additionally, we have found one problem in the original ResNet architecture. When downsampling, the first $1 \\times 1$ projection of the convolutional branch is performed with a stride of 2 in both dimensions, which effectively discards $7 5 \\%$ of the input. Increasing the filter size to $2 \\times 2$ allows to take the full input into consideration, and thus improves the information flow and accuracy. Of course, it makes these layers $4 \\times$ more computationally expensive, however there are so few of these in ENet, that the overhead is not noticeable. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            922
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/8ee4cf5e3cab0eb753a0beb93ff4d6ee95b858dcca5a326251df16b36b1dba7e.jpg",
+        "image_caption": [
+            "Figure 2: PReLU weight distribution vs network depth. Blue line is the weights mean, while an area between maximum and minimum weight is grayed out. Each vertical dotted line corresponds to a PReLU in the main branch and marks the boundary between each of bottleneck blocks. The gray vertical line at 67th module is placed at encoder-decoder border. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            282,
+            99,
+            714,
+            258
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Factorizing filters: It has been shown that convolutional weights have a fair amount of redundancy, and each $n \\times n$ convolution can be decomposed into two smaller asymmetric convolutions: one with a $n \\times 1$ filter followed by a $1 \\times n$ filter (Jin et al. (2014); Szegedy et al. (2015b)). We have used asymmetric convolutions with $n = 5$ in our network, so cost of these two operations is similar to a single $3 \\times 3$ convolution. This allowed to increase the variety of functions learned by each block and increase the receptive field. ",
+        "bbox": [
+            174,
+            359,
+            825,
+            443
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Sequence of operations used in the bottleneck module (projection, convolution, projection) can be seen as decomposing one large convolutional layer into a series of smaller and simpler low-rank approximation operations. Such factorization allows for large speedups and reduction in number of parameters, making them less redundant (Jin et al. (2014)). ",
+        "bbox": [
+            174,
+            450,
+            825,
+            506
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Dilated convolutions: As argued above, it is very important for the network to have a wide receptive field, so it can perform classification by taking a bigger portion of the image (context) into account. We wanted to avoid overly downsampling the feature maps, and decided to use dilated convolutions (Yu & Koltun (2015)) to improve our model. We have used them inside several bottleneck modules, in particular the ones that operate on the smallest resolutions. These gave a significant accuracy boost, by raising IoU on Cityscapes by around 4 percentage points, with no additional cost. We obtained the best accuracy when we interleaved them with other bottleneck modules (both regular and asymmetric), instead of arranging them in sequence, as has been done in Yu & Koltun (2015). ",
+        "bbox": [
+            174,
+            525,
+            825,
+            637
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Regularization: Most pixel-wise segmentation datasets are relatively small (on order of $1 0 ^ { 3 }$ images), so such expressive models as neural networks quickly begin to overfit them. In initial experiments, we used L2 weight decay with little success. Then, inspired by Huang et al. (2016), we have tried stochastic depth, which increased accuracy. However it became apparent that dropping branches (i.e. setting their output to 0) is in fact a special case of applying Spatial Dropout (Tompson et al. (2015)), where either all of the channels, or none of them are ignored, instead of selecting a random subset. We placed Spatial Dropout at the end of convolutional branches, right before the addition, and it turned out to work much better than stochastic depth. ",
+        "bbox": [
+            174,
+            656,
+            825,
+            767
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "5 RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            792,
+            281,
+            808
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We benchmarked the performance of ENet on three different datasets to demonstrate real-time and accurate for practical applications. We tested on CamVid and Cityscapes datasets of road scenes, and SUN RGB-D dataset of indoor scenes. We set SegNet (Badrinarayanan et al. (2015b)) as a baseline since it is one of the fastest segmentation model available, that also requires less memory to operate than plain CNNs. All our models, training, testing and performance evaluation scripts were written using the Torch7 machine-learning library. To compare results, we use class average accuracy and intersection-over-union (IoU) metrics. ",
+        "bbox": [
+            174,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "5.1 PERFORMANCE ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            397,
+            117
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We report results on inference speed on widely used NVIDIA Titan X GPU as well as on NVIDIA TX1 embedded system module. ENet was designed to achieve more than 10 fps on the NVIDIA TX1 board with an input image size $6 4 0 \\times 3 6 0$ (W,H), which is adequate for practical road scene parsing applications. For inference we merge batch normalization and dropout layers into the convolutional filters, to speed up all networks. ",
+        "bbox": [
+            174,
+            130,
+            825,
+            200
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/7a789caa9858d519d99d8cc96eae991c69b32ca9b1653db564c1982c57cb02b9.jpg",
+        "table_caption": [
+            "Table 2: Performance comparison. Image size is $\\mathrm { W } \\times \\mathrm { H }$ "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"3\">Model</td><td colspan=\"6\">NVIDIA TX1</td><td colspan=\"6\">NVIDIA Titan X</td></tr><tr><td colspan=\"2\">480×320</td><td colspan=\"2\">640×360</td><td colspan=\"2\">1280×720</td><td colspan=\"2\">640×360</td><td colspan=\"2\">1280×720</td><td colspan=\"2\">1920×1080</td></tr><tr><td>ms</td><td>fps</td><td>ms</td><td>fps</td><td>ms</td><td>fps</td><td>ms</td><td>fps</td><td>ms</td><td>fps</td><td>ms</td><td>fps</td></tr><tr><td>SegNet</td><td>757</td><td>1.3</td><td>1251</td><td>0.8</td><td>-</td><td>1</td><td>69</td><td>14.6</td><td>289</td><td>3.5</td><td>637</td><td>1.6</td></tr><tr><td>ENet</td><td>47</td><td>21.1</td><td>69</td><td>14.6</td><td>262</td><td>3.8</td><td>7</td><td>135.4</td><td>21</td><td>46.8</td><td>46</td><td>21.6</td></tr></table>",
+        "bbox": [
+            181,
+            244,
+            818,
+            332
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Inference time: Table 2 compares inference time for a single input frame of varying resolution. We also report the number of frames per second that can be processed. Dashes indicate that we could not obtain a measurement, due to lack of memory. ENet is significantly faster than competing architectures, providing high frame rates for real-time applications and allowing for practical use of very deep neural network models with encoder-decoder architecture. ",
+        "bbox": [
+            174,
+            357,
+            825,
+            428
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/00edabfc016dc026479158b1fbf246abada01ea7bae01cc69ea74fb33ba4b052.jpg",
+        "table_caption": [
+            "Table 3: Hardware requirements. FLOPs are estimated for an input of $3 \\times 6 4 0 \\times 3 6 0$ (C,W,H). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>GFLOPs</td><td>Parameters</td><td>Model size (fp16)</td></tr><tr><td>SegNet</td><td>286.03</td><td>29.46M</td><td>56.2 MB</td></tr><tr><td>ENet</td><td>3.83</td><td>0.37M</td><td>0.7 MB</td></tr></table>",
+        "bbox": [
+            308,
+            473,
+            687,
+            532
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Hardware requirements: Table 3 reports a comparison of number of operations and parameters used by different models. ENet efficiency is evident in the much low number of operations per frame and overall parameters. Please note that we report storage required to store the models in half precision floating point format. ENet has so few parameters that it can be saved into a file of just 0.7MB, which makes it possible to fit the whole network in an extremely fast on-chip memory in embedded processors. This alleviates the need for model compression (Han et al. (2015)), making it possible to use general purpose code for neural network computation. However, if one needs to operate under incredibly strict memory constraints, these techniques can still be applied to ENet as well. ",
+        "bbox": [
+            173,
+            558,
+            825,
+            683
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Software limitations: One of the most important techniques that has allowed us to reach these levels of performance is convolutional layer factorization. However, we have found one surprising drawback. Although applying this method allowed us to greatly reduce the number of floating point operations and parameters, it also increased the number of individual kernels calls, making each of them smaller. ",
+        "bbox": [
+            174,
+            700,
+            825,
+            770
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We have found that some of these operations become so cheap, that the cost of GPU kernel launch starts to outweigh the cost of the actual computation. Also, because kernels do not have access to values that have been kept in registers by previous ones, they have to load all data from global memory at launch, and save it when their work is finished. This means that using a higher number of kernels, increases the number of memory operations, because feature maps have to be constantly saved and reloaded. This becomes especially apparent in case of non-linear operations. In ENet, PReLUs consume more than a quarter of inference time. Since they are only simple point-wise operations and very easy to parallelize, we hypothesize it is caused by the aforementioned data movement. ",
+        "bbox": [
+            174,
+            776,
+            825,
+            888
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "These are serious limitations, however they could be resolved by performing kernel fusion in existing software i.e. create kernels that apply non-linearities to results of convolutions directly, or perform a number of smaller convolutions in one call. This improvement in GPU libraries, such as CuDNN, could increase the speed and efficiency of our network even further. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.2 BENCHMARKS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            148,
+            315,
+            162
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "During training we have used the Adam optimization algorithm (Kingma & Ba (2014)). It allowed ENet to converge very quickly and on every dataset we haver used training took only 3-4 hours on Titan X. Training of ENet was performed in two stages: first we train only the encoder to categorize downsampled regions of the input image, then we appended the decoder and train the network to perform upsampling and pixel-wise categorization. in this work, a learning rate of $5 \\mathrm { e } { - 4 }$ and L2 weight decay of $2 \\mathrm { e } { - 4 }$ , along with batch size of 10 consistently provided the best results. For categorization, we have used a custom class weighing scheme defined as wclass = 1ln(c+pclass) . In contrast to the inverse class probability weighing, the weights are bounded as the probability approaches 0. c is an additional hyper-parameter, which we set to 1.02 (i.e. we restrict the class weights to be in the interval of [1, 50]). ",
+        "bbox": [
+            173,
+            174,
+            826,
+            318
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/d987775f8dbbc3aa83961b21629350d354b078b4bd08d25487180f30111b40f9.jpg",
+        "table_caption": [
+            "Table 4: Cityscapes test set results "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Class IoU</td><td>Class iIoU</td><td>Category IoU</td><td>Category iIoU</td></tr><tr><td>SegNet</td><td>56.1</td><td>34.2</td><td>79.8</td><td>66.4</td></tr><tr><td>ENet</td><td>58.3</td><td>34.4</td><td>80.4</td><td>64.0</td></tr></table>",
+        "bbox": [
+            282,
+            359,
+            712,
+            415
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Cityscapes: This dataset consists of 5000 fine-annotated images, out of which 2975 are available for training, 500 for validation, and the remaining 1525 have been selected as test set (Cordts et al. (2016)). Cityscapes was the most important benchmark for us, because of its outstanding quality and highly varying road scenarios, often featuring many pedestrians and cyclists. We trained on 19 classes that have been selected in the official evaluation scripts (Cordts et al. (2016)). It makes use of an additional metric called instance-level intersection over union metric (iIoU), which is IoU weighed by the average object size. As reported in Table 4, ENet outperforms SegNet in class IoU and iIoU, as well as in category IoU. ENet is currently the fastest model in the Cityscapes benchmark. ",
+        "bbox": [
+            173,
+            435,
+            826,
+            547
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/83a7acd7002c9f15db1c2831a28a481eba7a0c2108cb64d22bfe72fc12384259.jpg",
+        "table_caption": [
+            "Table 5: Results on CamVid test set of (1) SegNet-Basic, (2) SegNet, and (3) ENet "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>[apo</td><td>Buipling</td><td>2</td><td>S</td><td>8</td><td>S</td><td></td><td>rrrnsestd</td><td>geeee</td><td>P</td><td>xeeaaia</td><td>BTttreit</td><td>ae ssea</td><td>Grssero</td></tr><tr><td></td><td></td><td></td><td>91.2</td><td>82.7</td><td>36.9</td><td>93.3</td><td>55.0</td><td>47.5</td><td>44.8</td><td>74.1</td><td>16.0</td><td>62.9</td><td>n/a</td></tr><tr><td>1</td><td>75.0</td><td>84.6 87.3</td><td>92.4</td><td>82.1</td><td>20.5</td><td>97.2</td><td>57.1</td><td>49.3</td><td>27.5</td><td>84.4</td><td>30.7</td><td>65.2</td><td>55.6</td></tr><tr><td>23</td><td>88.8 74.7</td><td>77.8</td><td>95.1</td><td>82.4</td><td>51.0</td><td>95.1</td><td>67.2</td><td>51.7</td><td>35.4</td><td>86.7</td><td>34.1</td><td>68.3</td><td>51.3</td></tr></table>",
+        "bbox": [
+            179,
+            589,
+            818,
+            696
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "CamVid: Another automotive dataset, on which we have tested ENet, was CamVid. It contains 367 training and 233 testing images (Brostow et al. (2008)). There are eleven different classes such as building, tree, sky, car, road, etc. while the twelfth class contains unlabeled data, which we ignore while training. The original frame resolution for this dataset is $9 6 0 \\times 7 2 0$ (W,H) but we downsampled the images to $4 8 0 \\times 3 6 0$ before training. In Table 5 we compare the performance of ENet with existing state-of-the-art algorithms. ENet outperforms other models in six classes, which are difficult to learn because they correspond to smaller objects. ",
+        "bbox": [
+            173,
+            718,
+            825,
+            818
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/d53e8174a235b52a6f9ff28d87fa5a00b7dcbbbdaf85314aee5a132b03ac8b24.jpg",
+        "table_caption": [
+            "Table 6: SUN RGB-D test set results "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Global avg.</td><td>Class avg.</td><td>Mean IoU</td></tr><tr><td>SegNet</td><td>70.3</td><td>35.6</td><td>26.3</td></tr><tr><td>ENet</td><td>59.5</td><td>32.6</td><td>19.7</td></tr></table>",
+        "bbox": [
+            341,
+            859,
+            655,
+            915
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "SUN RGB-D: The SUN dataset consists of 5285 training images and 5050 testing images with 37 indoor object classes. We did not make any use of depth information in this work and trained the network only on RGB data. In Table 6 we compare the performance of ENet with SegNet (Badrinarayanan et al. (2015b)), which is the only neural network model that reports accuracy on this dataset. Our results, though inferior in global average accuracy and IoU, are comparable in class average accuracy. Since global average accuracy and IoU are metrics that favor correct classification of classes occupying large image patches, researchers generally emphasize the importance of other metrics in case of semantic segmentation. One notable example is introduction of iIoU metric (Cordts et al. (2016)). Comparable result in class average accuracy indicates, that our network is capable of differentiating smaller objects nearly as well as SegNet. Moreover, the difference in accuracy should not overshadow the huge performance gap between these two networks. ENet can process the images in real-time, and is nearly $2 0 \\times$ faster than SegNet on embedded platforms. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            270
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/a43847be877615b29500a3b4907152b197ca7fa458f0a9158c8621cd2ca44e97.jpg",
+        "image_caption": [
+            "Figure 3: ENet predictions on popular benchmarks (rows top to down represent input image, ground truth, and ENet output respectively). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            250,
+            290,
+            764,
+            558
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            632,
+            318,
+            648
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We have proposed a novel neural network architecture designed from the ground up specifically for semantic segmentation. Our main aim is to make efficient use of scarce resources available on embedded platforms, compared to fully fledged deep learning workstations. Our work provides large gains in this task, while matching and at times exceeding existing baseline models, that have an order of magnitude larger computational and memory requirements. The application of ENet on the NVIDIA TX1 hardware exemplifies real-time portable embedded solutions. ",
+        "bbox": [
+            174,
+            670,
+            825,
+            752
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Even though the main goal was to run the network on mobile devices, we have found that it is also very efficient on high end GPUs like NVIDIA Titan X. This may prove useful in data-center applications, where there is a need of processing large numbers of high resolution images. ENet allows to perform large-scale computations in a much faster and more efficient manner, which might lead to significant savings. ",
+        "bbox": [
+            174,
+            760,
+            825,
+            830
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGMENT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            856,
+            318,
+            867
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "This work is partly supported by the Office of Naval Research (ONR) grants N00014-12-1-0167, N00014-15-1-2791 and MURI N00014-10-1-0278. We gratefully acknowledge the support of NVIDIA Corporation with the donation of the TX1, Titan X, K40 GPUs used for this research. ",
+        "bbox": [
+            176,
+            882,
+            825,
+            922
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            287,
+            117
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Vijay Badrinarayanan, Ankur Handa, and Roberto Cipolla. Segnet: A deep convolutional encoderdecoder architecture for robust semantic pixel-wise labelling. arXiv preprint arXiv:1505.07293, 2015a. ",
+        "bbox": [
+            176,
+            126,
+            826,
+            167
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Vijay Badrinarayanan, Alex Kendall, and Roberto Cipolla. Segnet: A deep convolutional encoderdecoder architecture for image segmentation. arXiv preprint arXiv:1511.00561, 2015b. ",
+        "bbox": [
+            171,
+            176,
+            825,
+            207
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Gabriel J. Brostow, Jamie Shotton, Julien Fauqueur, and Roberto Cipolla. Segmentation and recognition using structure from motion point clouds. In ECCV (1), pp. 44–57, 2008. ",
+        "bbox": [
+            171,
+            215,
+            825,
+            244
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Liang-Chieh Chen, George Papandreou, Iasonas Kokkinos, Kevin Murphy, and Alan L Yuille. Semantic image segmentation with deep convolutional nets and fully connected crfs. arXiv preprint arXiv:1412.7062, 2014. ",
+        "bbox": [
+            176,
+            253,
+            823,
+            296
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sharan Chetlur, Cliff Woolley, Philippe Vandermersch, Jonathan Cohen, John Tran, Bryan Catanzaro, and Evan Shelhamer. cudnn: Efficient primitives for deep learning. arXiv preprint arXiv:1410.0759, 2014. ",
+        "bbox": [
+            174,
+            305,
+            825,
+            347
+        ],
+        "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 Proc. of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2016. ",
+        "bbox": [
+            174,
+            356,
+            826,
+            412
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "David Eigen and Rob Fergus. Predicting depth, surface normals and semantic labels with a common multi-scale convolutional architecture. In Proceedings of the IEEE International Conference on Computer Vision, pp. 2650–2658, 2015. ",
+        "bbox": [
+            174,
+            421,
+            825,
+            465
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "C. Farabet, C. Couprie, L. Najman, and Y. LeCun. Learning hierarchical features for scene labeling. IEEE Transactions on Pattern Analysis and Machine Intelligence, 35(8):1915–1929, Aug 2013. ISSN 0162-8828. ",
+        "bbox": [
+            173,
+            473,
+            826,
+            517
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Song Han, Huizi Mao, and William J. Dally. Deep compression: Compressing deep neural network with pruning, trained quantization and huffman coding. arXiv preprint arXiv:1510.00149, 2015. ",
+        "bbox": [
+            174,
+            525,
+            825,
+            555
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Delving deep into rectifiers: Surpassing human-level performance on imagenet classification. pp. 1026–1034, 2015a. ",
+        "bbox": [
+            171,
+            564,
+            823,
+            593
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. arXiv preprint arXiv:1512.03385, 2015b. ",
+        "bbox": [
+            173,
+            602,
+            823,
+            631
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Identity mappings in deep residual networks. arXiv preprint arXiv:1603.05027, 2016. ",
+        "bbox": [
+            171,
+            640,
+            825,
+            669
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Seunghoon Hong, Hyeonwoo Noh, and Bohyung Han. Decoupled deep neural network for semisupervised semantic segmentation. In Advances in Neural Information Processing Systems, pp. 1495–1503, 2015. ",
+        "bbox": [
+            174,
+            678,
+            825,
+            719
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Gao Huang, Yu Sun, Zhuang Liu, Daniel Sedra, and Kilian Weinberger. Deep networks with stochastic depth. arXiv preprint arXiv:1603.09382, 2016. ",
+        "bbox": [
+            171,
+            729,
+            825,
+            758
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. arXiv preprint arXiv:1502.03167, 2015. ",
+        "bbox": [
+            173,
+            767,
+            825,
+            797
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jonghoon Jin, Aysegul Dundar, and Eugenio Culurciello. Flattened convolutional neural networks for feedforward acceleration. arXiv preprint arXiv:1412.5474, 2014. ",
+        "bbox": [
+            173,
+            805,
+            823,
+            834
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014. ",
+        "bbox": [
+            173,
+            843,
+            825,
+            872
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky, Ilya Sutskever, and Geoffrey E. Hinton. Imagenet classification with deep convolutional neural networks. In Advances in Neural Information Processing Systems 25, pp. 1097–1105. 2012. ",
+        "bbox": [
+            176,
+            881,
+            826,
+            922
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun and Yoshua Bengio. Convolutional networks for images, speech, and time series. The handbook of brain theory and neural networks, pp. 255–258, 1998. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            133
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jonathan Long, Evan Shelhamer, and Trevor Darrell. Fully convolutional networks for semantic segmentation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 3431–3440, 2015. ",
+        "bbox": [
+            173,
+            140,
+            823,
+            184
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jiquan Ngiam, Aditya Khosla, Mingyu Kim, Juhan Nam, Honglak Lee, and Andrew Y Ng. Multimodal deep learning. In Proceedings of the 28th international conference on machine learning (ICML-11), pp. 689–696, 2011. ",
+        "bbox": [
+            173,
+            193,
+            823,
+            236
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hyeonwoo Noh, Seunghoon Hong, and Bohyung Han. Learning deconvolution network for semantic segmentation. In Proceedings of the IEEE International Conference on Computer Vision, pp. 1520–1528, 2015. ",
+        "bbox": [
+            173,
+            244,
+            828,
+            286
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "F. Perronnin, Y. Liu, J. Sánchez, and H. Poirier. Large-scale image retrieval with compressed fisher vectors. In Computer Vision and Pattern Recognition (CVPR), 2010 IEEE Conference on, pp. 3384–3391, 2010. ",
+        "bbox": [
+            173,
+            295,
+            826,
+            338
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Marc Aurelio Ranzato, Fu Jie Huang, Y-Lan Boureau, and Yann LeCun. Unsupervised learning of invariant feature hierarchies with applications to object recognition. In Computer Vision and Pattern Recognition, 2007. CVPR’07. IEEE Conference on, pp. 1–8, 2007. ",
+        "bbox": [
+            173,
+            347,
+            825,
+            390
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jamie Shotton, John Winn, Carsten Rother, and Antonio Criminisi. Textonboost for image understanding: Multi-class object recognition and segmentation by jointly modeling texture, layout, and context. Int. Journal of Computer Vision (IJCV), January 2009. ",
+        "bbox": [
+            173,
+            398,
+            826,
+            441
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. arXiv preprint arXiv:1409.1556, 2014a. ",
+        "bbox": [
+            174,
+            450,
+            823,
+            479
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. arXiv preprint arXiv:1409.1556, 2014b. ",
+        "bbox": [
+            173,
+            488,
+            825,
+            517
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Shuran Song, Samuel P Lichtenberg, and Jianxiong Xiao. Sun rgb-d: A rgb-d scene understanding benchmark suite. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 567–576, 2015. ",
+        "bbox": [
+            176,
+            525,
+            823,
+            569
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Paul Sturgess, Karteek Alahari, Lubor Ladicky, and Philip HS Torr. Combining appearance and structure from motion features for road scene understanding. In BMVC 2012-23rd British Machine Vision Conference, 2009. ",
+        "bbox": [
+            174,
+            577,
+            823,
+            619
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Christian Szegedy, Wei Liu, Yangqing Jia, Pierre Sermanet, Scott Reed, Dragomir Anguelov, Dumitru Erhan, Vincent Vanhoucke, and Andrew Rabinovich. Going deeper with convolutions. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 1–9, 2015a. ",
+        "bbox": [
+            176,
+            628,
+            825,
+            672
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Christian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jonathon Shlens, and Zbigniew Wojna. Rethinking the inception architecture for computer vision. arXiv preprint arXiv:1512.00567, 2015b. ",
+        "bbox": [
+            171,
+            680,
+            825,
+            710
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jonathan Tompson, Ross Goroshin, Arjun Jain, Yann LeCun, and Christoph Bregler. Efficient object localization using convolutional networks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 648–656, 2015. ",
+        "bbox": [
+            173,
+            717,
+            825,
+            762
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "K. E. A. van de Sande, J. R. R. Uijlings, T. Gevers, and A. W. M. Smeulders. Segmentation as selective search for object recognition. In IEEE International Conference on Computer Vision, 2011. ",
+        "bbox": [
+            173,
+            770,
+            826,
+            813
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Fisher Yu and Vladlen Koltun. Multi-scale context aggregation by dilated convolutions. arXiv preprint arXiv:1511.07122, 2015. ",
+        "bbox": [
+            173,
+            820,
+            823,
+            851
+        ],
+        "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 Proceedings of the IEEE International Conference on Computer Vision, pp. 1529–1537, 2015. ",
+        "bbox": [
+            176,
+            859,
+            825,
+            902
+        ],
+        "page_idx": 9
+    }
+]

parse/train/HkYhZDqxg/HkYhZDqxg.md

@@ -0,0 +1,314 @@
+# TREE-STRUCTURED DECODING WITH DOUBLYRECURRENT NEURAL NETWORKS
+
+David Alvarez-Melis & Tommi S. Jaakkola Computer Science and Artificial Intelligence Lab MIT {davidam,tommi}@csail.mit.edu
+
+# ABSTRACT
+
+We propose a neural network architecture for generating tree-structured objects from encoded representations. The core of the method is a doubly recurrent neural network model comprised of separate width and depth recurrences that are combined inside each cell (node) to generate an output. The topology of the tree is modeled explicitly together with the content. That is, in response to an encoded vector representation, co-evolving recurrences are used to realize the associated tree and the labels for the nodes in the tree. We test this architecture in an encoderdecoder framework, where we train a network to encode a sentence as a vector, and then generate a tree structure from it. The experimental results show the effectiveness of this architecture at recovering latent tree structure in sequences and at mapping sentences to simple functional programs.
+
+# 1 INTRODUCTION
+
+Recurrent neural networks have become extremely popular for modeling structured data. Key to their success is their ability to learn long-range temporal dependencies, their flexibility, and ease of customization. These architectures are naturally suited for modeling sequences since the underlying state evolution resulting from successive operations follows an inherently linear order (Williams & Zipser, 1995; Hochreiter & Schmidhuber, 1997). Indeed, they have been successfully adapted to language modeling (Zaremba et al., 2015), machine translation (Sutskever et al., 2014) and conversational agents (Vinyals & Le, 2015), among other applications.
+
+Although sequences arise frequently in practice, other structures such as trees or graphs do not naturally conform to a linear ordering. For example, natural language sentences or associated parse trees, programs, hierarchical structures in biology, or molecules are not inherently linear structures. While sentences in natural language can be modeled as if they were linear sequences, the underlying process is compositional (Frege, 1892). Models that construct sentences compositionally should derive an advantage from adopting a more appropriate inductive bias.
+
+The flexibility and success of recurrent neural networks in modeling and generating sequential data has prompted efforts to adapt them to non-sequential data too. Recent work has focused on the application of neural architectures to hierarchical structures, albeit in limited ways. Much of this work has assumed that either the full tree structure is given (Socher et al., 2012; Tai et al., 2015) or at least the nodes are (Socher & Lin, 2011; Chen & Manning, 2014; Kiperwasser & Goldberg, 2016). In the former scenario, the network aggregates the node information in a manner that is coherent with a given tree structure while, in the latter, generation is reduced to an attachment problem, i.e., sequentially deciding which pairs of nodes to join with an edge until a tree is formed.
+
+The full problem of decoding with structure, i.e., generating a tree-structured object with node labels from a given vector representation, has remained largely unexplored until recently. Recent efforts to adapt RNNs to this context have so far remained relatively close to their sequential counterparts. For example, in order to capture depth and branching in the tree, one can introduce special tokens (Dong & Lapata, 2016) or use alternating RNNs coupled with external classifiers to predict branching (Zhang et al., 2016).
+
+In this work, we propose a novel architecture tailored specifically to tree-structured decoding. At the heart of our approach is a doubly-recurrent (breadth and depth-wise recurrent) neural network which separately models the flow of information between parent and children nodes, and between siblings. Each of these relationships is modeled with a recurrent module whose hidden states are updated upon observing node labels. Every node in the tree receives two hidden states, which are then combined and used to predict a label for that node. Besides maintaining separate but simultaneous fraternal and paternal recurrences, the proposed architecture departs from previous methods in that it explicitly models tree topology. Each node in the network has modules that predict, based on the cell state, whether the node is terminal, both in terms of depth and width. Decoupling these decisions from the label prediction allows for a more concise formulation, which does not require artificial tokens to be added to the tree to simulate branching.
+
+We test this novel architecture in various encoder-decoder frameworks, coupling it with sequential encoders to predict tree structure from encoded vector representations of sequences. The experimental results show the effectiveness of this approach at recovering latent structure in flattened string representations of trees (Section 4.1) and at mapping from natural language descriptions of simple programs to abstract syntax trees (Section 4.2). In addition, we show that even for sequence-tosequence tasks such as machine translation, the proposed architecture exhibits desirable properties, such as invariance to structural changes and coarse-to-fine generation (Section 4.3).
+
+To summarize, the main contributions of this paper are as follows:
+
+• We propose a novel neural network architecture specifically tailored to tree-structured decoding, which maintains separate depth and width recurrent states and combines them to obtain hidden states for every node in the tree. We equip this novel architecture with a mechanism to predict tree topology explicitly (as opposed to implicitly by adding nodes with special tokens). We show experimentally that the proposed method is capable of recovering trees from encoded representations and that it outperforms state-of-the-art methods in a task consisting of mapping sentences to simple functional programs.
+
+# 2 RELATED WORK
+
+Recursive Neural Networks. Recursive neural networks (Socher & Lin, 2011; Socher et al., 2012) were proposed to model data with hierarchical structures, such as parsed scenes and natural language sentences. Though they have been most successfully applied to encoding objects when their treestructured representation is given (Socher et al., 2013), the original formulation by Socher & Lin (2011) also considered using them to predict the structure (edges), albeit for the case where nodes are given. Thus, besides their limited applicability due to their assumption of binary trees, recursive neural networks are not useful for fully generating trees from scratch.
+
+Tree-structured encoders. The Tree-LSTM of Tai et al. (2015) is a generalization of long shortterm memory networks (Hochreiter & Schmidhuber, 1997) to tree-structured inputs. Their model constructs a sentence representation bottom-up, obtaining at every step the representation of a node in the tree from those of its children. In this sense, this model can be seen as a generalization of recursive neural networks to trees with degree potentially greater than two, with the additional longrange dependency modeling provided by LSTMs. They propose two methods for aggregating the states of the children, depending on the type of underlying tree: N-ary trees or trees with unknown and potentially unbounded branching factor. TreeLSTMs have shown promising results for compositional encoding of structured data, though by construction they cannot be used for decoding, since they operate on a given tree structure.
+
+Tree-structured decoders. Proposed only very recently, most tree-structured decoders rely on stacked on intertwined RNNs, and use heuristic methods for topological decisions during generation. Closest to our method is the Top-down Tree LSTM of Zhang et al. (2016), which generates a tree from an encoded representation. Their method relies on 4 independent LSTMs, which act in alternation—as opposed to simultaneously in our approach—yielding essentially a standard LSTM that changes the weights it uses based on the position of the current node. In addition, their method provides children with asymmetric parent input: “younger” children receive information from the parent state only through the previous sibling’s state. Though most of their experiments focus on the case where the nodes are given, they mention how to use their method for full prediction by introducing additional binary classifiers which predict which of the four LSTMs is to be used. These classifiers are trained in isolation after the main architecture has been trained. Contrary to this approach, our method can be trained end-to-end in only one pass, has a simpler formulation and explicitly incorporates topological prediction as part of the functioning of each neuron.
+
+A similar approach is proposed by Dong & Lapata (2016). They propose SEQ2TREE, an encoderdecoder architecture that maps sentences to tree structures. For the decoder, they rely on hierarchical use of an LSTM, similar to Tai et al. (2015), but in the opposite direction: working top-down from the root of the tree. To decide when to change levels in the hierarchy, they augment the training trees with nonterminal nodes labeled with a special token $< n >$ , which when generated during decoding trigger the branching out into a lower level in the tree. Similar to our method, they feed nodes with hidden representations of their parent and sibling, but they do so by concatenating both states and running them through a single recurrent unit, as opposed to our method, where these two sources of information are handled separately. A further difference is that our approach does not require artificial nodes with special tokens to be added to the tree, resulting in smaller trees.
+
+Hierarchical Neural Networks for Parsing. Neural networks have also been recently introduced to the problem of natural language parsing (Chen & Manning, 2014; Kiperwasser & Goldberg, 2016). In this problem, the task is to predict a parse tree over a given sentence. For this, Kiperwasser & Goldberg (2016) use recurrent neural networks as a building block, and compose them recursively to obtain a tree-structured encoder. Starting from the leaves (words) they predict a parse tree with a projective bottom-up strategy, which sequentially updates the encoded vector representation of the tree and uses it to guide edge-attaching decisions. Though conceptually similar to our approach, their method relies on having access to the nodes of the tree (words) and only predicts its topology, so—similar to recursive neural networks—it cannot be used for a fully generative decoding.
+
+# 3 DOUBLY RECURRENT NEURAL NETWORKS
+
+Generating a tree-structured object from scratch using only an encoded representation poses several design challenges. First, one must decide in which order to generate the tree. If the nodes on the decoder side were given (such as in parsing), it would be possible to generate a tree bottom-up from these nodes (e.g. as Kiperwasser & Goldberg 2016 do). In the setting we are interested in, however, not even the nodes are known when decoding, so the natural choice is a top-down decoder, which starting from an encoded representation generates the root of the tree and then recursively generates the children (if any) of every node.
+
+The second challenge arises from the asymmetric hierarchical nature of trees. Unlike the sequenceto-sequence setting where encoding and decoding can be achieved with analogous procedures, when dealing with tree-structured data these two involve significantly different operations. For example, an encoder that processes a tree bottom-up using information of a node’s children to obtain its representation cannot be simply reversed and used as a decoder, since when generating the tree top-down, nodes have to be generated before their children are.
+
+An additional design constraint comes from deciding what information to feed to each node. For sequences, the choice is obvious: a node should receive information from the node preceding or succeeding it (or both), i.e. there is a one-dimensional flow of information. In trees, there is an evident flow of information from parent to children (or vice-versa), but when generating nodes in a top-down order it seems unnatural to generate children in isolation: the label of one of them will likely influence what the states of the other children might be. For example, in the case of parse trees, generating a verb will reduce the chances of other verbs occurring in that branch.
+
+With these considerations in mind, we propose an architecture tailored to tree decoding from scratch: top-down, recursive and doubly-recurrent, i.e. where both the ancestral (parent-to-children) and fraternal (sibling-to-sibling) flows of information are modeled with recurrent modules. Thus, the building block of a doubly recurrent neural network (DRNN) is a cell with two types of input states, one coming from its parent, updated and passed on to its descendants, and another one received from its previous sibling,1 updated and passed on to the next one. We model the flow of information in the two directions with separate recurrent modules.
+
+Formally, let $\mathcal { T } = \{ \mathcal { V } , \mathcal { E } , \mathcal { X } \} _ { \mathrm { ~ \scriptsize ~ . ~ } }$ be a connected labeled tree, where $\nu$ is the set of nodes, $\mathcal { E }$ the set of edges and $\mathcal { X }$ are node labels.2 Let $g ^ { a }$ and $g ^ { f }$ be functions which apply one step of the two separate RNNs. For a node $i \in \mathcal V$ with parent $p ( i )$ and previous sibling $s ( i )$ , the ancestral and fraternal hidden states are updated via
+
+$$
+\begin{array} { r } { \mathbf h _ { i } ^ { a } = g ^ { a } ( \mathbf h _ { p ( i ) } ^ { a } , \mathbf x _ { p ( i ) } ) } \\ { \mathbf h _ { i } ^ { f } = g ^ { f } ( \mathbf h _ { s ( i ) } ^ { f } , \mathbf x _ { s ( i ) } ) } \end{array}
+$$
+
+where $\mathbf { x } _ { s ( j ) } , \mathbf { x } _ { p ( i ) }$ are the vectors representing the previous sibling’s and parent’s values, respectively. Once the hidden depth and width states have been updated with these observed labels, they are combined to obtain a predictive hidden state:
+
+$$
+\mathbf { h } _ { i } ^ { ( p r e d ) } = \operatorname { t a n h } \left( \mathbf { U } ^ { f } \mathbf { h } _ { i } ^ { f } + \mathbf { U } ^ { a } \mathbf { h } _ { i } ^ { a } \right)
+$$
+
+where $\mathbf { U } ^ { f } \in \mathbb { R } ^ { n \times D _ { f } }$ and $\mathbf { U } ^ { a } \in \mathbb { R } ^ { n \times D _ { a } }$ are learnable parameters. This state contains combined information of the node’s neighborhood in the tree, and is used to predict a label for it. In its simplest form, the network could compute the output of node $i$ by sampling from distribution
+
+$$
+\mathbf { o } _ { i } = \mathrm { s o f t m a x } ( \mathbf { W } \mathbf { h } _ { i } ^ { ( p r e d ) } )
+$$
+
+In the next section, we propose a slight modification to (4) whereby topological information is included in the computation of cell outputs. After the node’s output symbol $\mathbf { x } _ { i }$ has been obtained by sampling from $\mathbf { o } _ { i }$ , the cell passes $\mathbf { h } _ { i } ^ { a }$ to all its children and ${ \bf { h } } _ { i } ^ { f }$ to the next sibling (if any), enabling them to apply Eqs (1) and (2) to realize their states. This procedure continues recursively, until termination conditions (explained in the next section) cause it to halt.
+
+# 3.1 TOPOLOGICAL PREDICTION
+
+As mentioned before, the central issue with free-form tree construction is to predict the topology of the tree. When constructing the tree top-down, for each node we need to decide: (i) whether it is a leaf node (and thus it should not produce offspring) and (ii) whether there should be additional siblings produced after it. Answering these two questions for every node allows us to construct a tree from scratch and eventual stop growing it.
+
+Sequence decoders typically rely on special tokens to terminate generation (Sutskever et al., 2014). The token is added to the vocabulary and treated as a regular word. During training, the examples are padded with this token at the end of the sequence, and during testing, generation of this token signals termination. These ideas has been adopted by most tree decoders (Dong & Lapata, 2016). There are two important downsides of using a padding strategy for topology prediction in trees. First, the size of the tree can grow considerably. While in the sequence framework only one stopping token is needed, a tree with $n$ nodes might need up to $O ( n )$ padding nodes to be added. This can have important effects in training speed. The second reason is that a single stopping token selected competitively with other tokens requires one to continually update the associated parameters in response to any changes in the distribution over ordinary tokens so as to maintain topological control.
+
+Based on these observations, we propose an alternative approach to stopping, in which topological decisions are made explicitly (as opposed to implicitly, with stopping tokens). For this, we use the predictive hidden state of the node $\mathbf { \bar { h } } ^ { ( p r e d ) }$ with a projection and sigmoid activation:
+
+$$
+p _ { i } ^ { a } = \sigma ( \mathbf { u } ^ { a } \cdot \mathbf { h } _ { i } ^ { ( p r e d ) } )
+$$
+
+The value $p _ { i } ^ { a } \in [ 0 , 1 ]$ is interpreted as the probability that node $i$ has children. Analogously, we can obtain a probability of stopping fraternal branch growth after the current node as follows:
+
+$$
+p _ { i } ^ { f } = \sigma ( \mathbf { u } ^ { f } \cdot \mathbf { h } _ { i } ^ { ( p r e d ) } )
+$$
+
+![](images/6812630ce984fe637e971c92890ea45b3726d69cb63be9c40c8f16aaf6c9cc03.jpg)  
+Figure 1: Left: A cell of the doubly-recurrent neural network corresponding to node $i$ with parent $p$ and sibling $s$ . Right: Structure-unrolled DRNN network in an encoder-decoder setting. The nodes are labeled in the order in which they are generated. Solid (dashed) lines indicate ancestral (fraternal) connections. Crossed arrows indicate production halted by the topology modules.
+
+Note that these stopping strategies depart from the usual padding methods in a fundamental property: the decision to stop is made before instead of in conjunction with the label prediction. The rationale behind this is that the label of a node will likely be influenced not only by its context, but also by the type of node (terminal or non-terminal) where it is to be assigned. This is the case in language, for example, where syntactic constraints restrict the type of words that can be found in terminal nodes. For this purpose, we include the topological information as inputs to the label prediction layer. Thus, (4) takes the form
+
+$$
+\mathbf { o } _ { i } = \mathrm { s o f t m a x } ( \mathbf { W } \mathbf { h } _ { i } ^ { ( p r e d ) } + \alpha _ { i } \mathbf { v } ^ { a } + \varphi _ { i } \mathbf { v } ^ { f } )
+$$
+
+where $\alpha _ { i } , \varphi _ { i } \in \{ 0 , 1 \}$ are binary variables indicating the topological decisions and $\mathbf { v } ^ { a } , \mathbf { v } ^ { f }$ are learnable offset parameters. During training, we use gold-truth values in (7), i.e. $\alpha _ { i } = 1$ if node $i$ has children and $\varphi _ { i } = 1$ if it has a succeeding sibling. During testing, these values are obtained from $p ^ { a } , p ^ { f }$ by sampling or beam-search. A schematic representation of the internal structure of a DRNN cell and the flow of information in a tree are shown in Figure 1.
+
+# 3.2 TRAINING DRNNS
+
+We train DRNNs with (reverse) back-propagation through structure (BPTS) (Goller & Kuechler, 1996). In the forward pass, node outputs are computed in a top-down fashion on the structureunrolled version of the network, following the natural3 dependencies of the tree. We obtain error signal at the node level from the two types of prediction: label and topology. For the former, we compute cross-entropy loss of $\mathbf { o } _ { i }$ with respect to the true label of the node $\mathbf { x } _ { i }$ . For the topological values $p _ { i } ^ { a }$ and $p _ { i } ^ { f }$ we compute binary cross entropy loss with respect to gold topological indicators $\alpha _ { i } , \varphi _ { i } \in \{ 0 , 1 \}$ . In the backward pass, we proceed in the reverse (bottom-up) direction, feeding into every node the gradients received from child and sibling nodes and computing internally gradients with respect to both topology and label prediction. Further details on the backpropagation flow are provided in the Appendix.
+
+Note that the way BPTS is computed implies and underlying decoupled loss function
+
+$$
+{ \mathcal { L } } ( { \widehat { \mathbf { x } } } ) = \sum _ { i \in \mathcal { V } } { \mathcal { L } } ^ { l a b e l } ( \mathbf { x } _ { i } , { \widehat { \mathbf { x } } } _ { i } ) + { \mathcal { L } } ^ { t o p o } ( \mathbf { p } _ { i } , { \widehat { \mathbf { p } } } _ { i } )
+$$
+
+The decoupled nature of this loss allows us to weigh these two objectives differently, to emphasize either topology or label prediction accuracy. Investigating the effect of this is left for future work.
+
+![](images/fa6bf02ca4eb87925feb86a96cfa41b88c2eb0fa6f09d54cf324aab88035b0f8.jpg)  
+Figure 2: Trees generated by the DRNN decoder trained on subset of size $N$ of the synthetic dataset, for a test example with description “ROOT B W F J V”.
+
+As is common with sequence generation, during training we perform teacher forcing: after predicting the label of a node and its corresponding loss, we replace it with its gold value, so that children and siblings receive the correct label for that node. Analogously, we obtain the probabilities $p ^ { a }$ and $p ^ { f }$ , compute their loss, and replace them for ground truth variables $\alpha _ { i } , \varphi _ { i }$ for all downstream computations. Addressing this exposure bias by mixing ground truth labels with model predictions during training (Venkatraman et al., 2015) or by incremental hybrid losses (Ranzato et al., 2016) is left as an avenue for future work.
+
+# 4 EXPERIMENTS
+
+# 4.1 SYNTHETIC TREE RECOVERY
+
+In our first set of experiments we evaluate the effectiveness of the proposed architecture to recover trees from flattened string representations. For this, we first generate a toy dataset consisting of simple labeled trees. To isolate the effect of label content from topological prediction, we take a small vocabulary consisting of the 26 letters of the English alphabet. We generate trees in a top-down fashion, conditioning the label and topology of every node on the state of its ancestors and siblings. For simplicity, we use a Markovian assumption on these dependencies, modeling the probability of a node’s label as depending only on the label of its parent and the last sibling generated before it (if any). Conditioned on these two inputs, we model the label of the node as coming from a multinomial distribution over the alphabet with a dirichlet prior. To generate the topology of the tree, we model the probability of a node having children and a next-sibling as depending only on its label and the depth of the tree. For each tree we generate a string representation by traversing it in breadth-first preorder, starting from the root. The labels of the nodes are concatenated into a string in the order in which they were visited, resulting in a string of $| \tau |$ symbols. We create a dataset of 5,000 trees with this procedure, and split it randomly into train, validation and test sets (with a $8 0 \% , 1 0 \% , 1 0 \%$ split). Further details on the construction of this dataset are provided in the Appendix.
+
+The task consists of learning a mapping from strings to trees, and using this learned mapping to recover the tree structure of the test set examples, given only their flattened representation. To do so, we use an encoder-decoder framework, where the strings are mapped to a fixed-size vector representation using a recurrent neural network. For the decoder, we use a DRNN with LSTM modules, which given the encoded representation generates a tree. We choose hyper-parameters with cross-validation. Full training details are provided in the Appendix.
+
+Measuring performance only in terms of exact recovery would likely yield near-zero accuracies for most trees. Instead, we opt for a finer-grained metric of tree similarity that gives partial credit for correctly predicted subtrees. Treating tree generation as a retrieval problem, we evaluate the quality of the predicted tree in terms of the precision and recall of recovering nodes and edges present in the gold tree. Thus, we penalize both missing and superfluous components. As baseline, we induce a probabilistic context-free grammar (PCFG) on the full training data and use it to parse the test sentences. Note that unlike the DRNN, this parser has direct access to the sentence representation and thus its task is only to infer the tree structure on top of it, so this is indeed a strong baseline.
+
+Figure 3 shows the results on the test set. Training on the full data yields node and edge retrieval F1-Scores of $7 5 \%$ and $7 1 \%$ , respectively, the latter considerably above the baseline.4 This $4 \%$ gap can be explained by correct nodes being generated in the wrong part of the tree, as in the example in
+
+![](images/52d37a6efb263a4c5b33630089f95cc5893e7e3496a04c264b290de2d64d54cc.jpg)  
+Figure 3: Left: F1-Score for models trained on randomly sampled subsets of varying size, averaged over 5 repetitions. Right: Node (first column) and edge (second) precision as a function of tree size.
+
+![](images/7b875204bc878bbfd26edbb3ab21a5df5bdab181ce0989b8dea5b0b05d98929c.jpg)  
+Figure 4: Node and edge precision as a function of tree depth (left figure) and width (right).
+
+Figure 2. The second plot in Figure 3 shows that although small trees are recovered more accurately, precision decays slowly with tree size, with depth accounting for the largest effect (Figure 4).
+
+# 4.2 MAPPING SENTENCES TO FUNCTIONAL PROGRAMS
+
+Tree structures arise naturally in the context of programs. A typical compiler takes human-readable source code (expressed as sequences of characters) and transforms it into an executable abstract syntax tree (AST). Source code, however, is already semi-structured. Mapping natural language sentences directly into executable programs is an open problem, which has received considerable interest in the natural language processing community (Kate et al., 2005; Branavan et al., 2009).
+
+The IFTTT dataset (Quirk et al., 2015) is a simple testbed for language-to-program mapping. It consists of if-this-then-that programs (called recipes) crawled from the IFTTT website5, paired with natural language descriptions of their purpose. The recipes consist of a trigger and an action, each defined in terms of a channel (e.g. “Facebook”), a function (e.g. “Post a status update”) and potentially arguments and parameters. An example of a recipe and its description are shown in Figure 5. The data is user-generated and extremely noisy, which makes the task significantly challenging.
+
+![](images/0f9ce1e2f1525e67ee95093f4be26f483a821b88a8a13e1cfd8b46e3af4990bf.jpg)  
+Figure 5: Example recipe from the IFTTT dataset. The description (above) is a user-generated natural language explanation of the if-this-then-that program (below).
+
+Table 1: Results on the IFTTT task. Left: non-English and unintelligible examples removed (2,262 recipes). Right: examples for which at least $^ { 3 + }$ humans agree with gold (758 recipes).   
+
+<table><tr><td>Method</td><td>Channel</td><td>+Func</td><td>F1</td></tr><tr><td>retrieval</td><td>36.8</td><td>25.4</td><td>49.0</td></tr><tr><td>phrasal</td><td>27.8</td><td>16.4</td><td>39.9</td></tr><tr><td>sync</td><td>26.7</td><td>15.4</td><td>37.6</td></tr><tr><td>classifier</td><td>64.8</td><td>47.2</td><td>56.5</td></tr><tr><td>posclass</td><td>67.2</td><td>50.4</td><td>57.7</td></tr><tr><td>SEQ2SEQ</td><td>68.8</td><td>50.5</td><td>60.3</td></tr><tr><td>SEQ2TREE</td><td>69.6</td><td>51.4</td><td>60.4</td></tr><tr><td>GRU-DRNN</td><td>70.1</td><td>51.2</td><td>62.7</td></tr><tr><td>LSTM-DRNN</td><td>74.9</td><td>54.3</td><td>65.2</td></tr></table>
+
+<table><tr><td>Method</td><td>Channel</td><td>+Func</td><td>F1</td></tr><tr><td>retrieval</td><td>43.3</td><td>32.3</td><td>56.2</td></tr><tr><td>phrasal</td><td>37.2</td><td>23.5</td><td>45.5</td></tr><tr><td>sync</td><td>36.5</td><td>23.5</td><td>45.5</td></tr><tr><td>classifier</td><td>79.3</td><td>66.2</td><td>65.0</td></tr><tr><td>posclass</td><td>81.4</td><td>71.0</td><td>66.5</td></tr><tr><td>SEQ2SEQ</td><td>87.8</td><td>75.2</td><td>73.7</td></tr><tr><td>SEQ2TREE</td><td>89.7</td><td>78.4</td><td>74.2</td></tr><tr><td>GRU-DRNN</td><td>89.9</td><td>77.6</td><td>74.1</td></tr><tr><td>LSTM-DRNN</td><td>90.1</td><td>78.2</td><td>77.4</td></tr></table>
+
+We approach this task using an encoder-decoder framework. We use a standard RNN encoder, either an LSTM or a GRU (Cho et al., 2014), to map the sentence to a vector representation, and we use a DRNN decoder to generate the AST representation of the recipe. We use the original data split, which consists of 77,495 training, 5,171 development and 4,294 test examples. For evaluation, we use the same metrics as Quirk et al. (2015), who note that computing exact accuracy on such a noisy dataset is problematic, and instead propose to evaluate the generated AST in terms of F1-score on the set of recovered productions. In addition, they compute accuracy at the channel level (i.e. when both channels are predicted correctly) and at the function level (both channels and both functions predicted correctly).
+
+We compare our methods against the various extraction and phrased-based machine translation baselines of Quirk et al. (2015) and the the methods of Dong & Lapata (2016): SEQ2SEQ, a sequenceto-sequence model trained on flattened representations of the AST, and SEQ2TREE, a token-driven hierarchical RNN. Following these two works, we report results on two noise-filtered subsets of the data: one with all non-English and unintelligible recipes removed and the other one with recipes for which at least three humans agreed with the gold AST. The results are shown in Table 1. In both subsets, DRNNs perform on par or above previous approaches, with LSTM-DRNN achieving significantly better results. The improvement is particularly evident in terms of F1-score, which is the only metric used by previous approaches that measures global tree reconstruction accuracy. To better understand the quality of the predicted trees beyond the function level (i.e. (b) in Figure 5), we computed node accuracy on the arguments level. Our best performing model, LSTM-DRNN, achieves a Macro F1 score of $51 \%$ (0.71 precision, 0.40 recall) over argument nodes, which shows that the model is reasonably successful at predicting structure even beyond depth three. The best performing alternative model, SEQ2TREE, achieves a corresponding F1 score of $46 \%$ .
+
+# 4.3 MACHINE TRANSLATION
+
+In our last set of experiments, we offer a qualitative evaluation DRNNs in the context of machine translation. Obtaining state-of-the-art results in machine translation requires highly-optimized architectures and large parallel corpora. This is not our goal. Instead, we investigate whether decoding with structure can bring benefits to a task traditionally approached as a sequence-to-sequence problem. For this reason, we consider a setting with limited data: a subset of the WMT14 dataset consisting of about 50K English French sentence pairs (see the Appendix for details) along with dependency parses of the target (English) side.
+
+We train a sequence-to-tree model using an LSTM encoder and a DRNN decoder as in the previous experiments. A slight modification here is that we distinguish left and right children in the tree, using two symmetric width-modules $g _ { L } ^ { f } , g _ { R } ^ { f }$ that produce children from the parent outwards. With this, children are lexically ordered, and therefore trees can be easily and un-ambiguously projected back into sentences. We compare our model against a sequence-to-sequence architecture of similar complexity (in terms of number of parameters) trained on the same data using the optimized OpenNMT library (Klein et al., 2017). For decoding, we use a simple best-of-k sampling scheme for our model, and beam search for the SEQ2SEQ models.
+
+![](images/9465c0cc274f78abfc2b883af117a313f8ec839f97253b62a455ebde7c7598c6.jpg)  
+Figure 6: Likelihood change under target structural perturbation.
+
+Table 2: Translations at different resolutions (size constraints imposed during decoding) for two example sentences.   
+
+<table><tr><td>Source</td><td>“ produit différentes réponses qui changent avec le temps selon nos expériences et nos relations ”</td><td>“je ne sais jamais quoi dire dans ces cas la&quot;</td></tr><tr><td>SEQ2SEQ:</td><td></td><td></td></tr><tr><td>l=1</td><td>a</td><td>I</td></tr><tr><td>l=4</td><td>with the different actions</td><td>Ido</td></tr><tr><td>=8</td><td>with the different actions who change with</td><td>I do not know what to say</td></tr><tr><td>DRNN:</td><td></td><td></td></tr><tr><td>d=1</td><td>answers</td><td>know</td></tr><tr><td>d=2</td><td>different answers change</td><td>but i do not know</td></tr><tr><td>d=3</td><td>product the different answers change .</td><td>but i do not know to say</td></tr></table>
+
+First, we analyze the quality of translations as a function of the maximum allowed target sentence “size”. The notion of size for a sequence decoder is simply the length while for DRNN we use depth instead so as to tap into the inherent granularity at which sentences can be generated from this architecture. Two such examples are shown in Table 2. Since DRNN topology has been trained to mimic dependency parses top-down, the decoder tends to first generate the fundamental aspects of the sentence (verb, nouns), leaving less important refinements for deeper structures down in the tree. The sequence decoder, in contrast, is trained for left-to-right sequential generation, and thus produces less informative translations under max-length restrictions.
+
+In our second experiment we investigate the decoders’ ability to entertain natural paraphrases of sentences. If we keep the semantic content of a sentence fixed and only change its grammatical structure, it is desirable that the decoder would assign nearly the same likelihood to the new sentence. One way to assess this invariance is to compare the relative likelihood that the model assigns to the gold sentence in comparison to its paraphrase. To test this, we take 50 examples from the WMT test split and manually generate paraphrases with various types of structural alterations (see details in the Appendix). For each type of decoder, we measure the relative change (in absolute value) of the log-likelihood resulting from the perturbation. All the models we compare have similar standard deviation $( 4 0 \pm 2 0 )$ of log-likelihood scores over these examples, so the relative changes in the log-likelihood remain directly comparable. For each architecture we train two versions of different sizes, where the sizes are balanced in terms of the number of parameters across the architectures. The results in Figure 6 show that DRNN’s exhibit significantly lower log-likelihood change, suggesting that, as language models, they are more robust to natural structural variation than their SEQ2SEQ counterparts.
+
+# 5 DISCUSSION AND FUTURE WORK
+
+We have presented doubly recurrent neural networks, a natural extension of (sequential) recurrent architectures to tree-structured objects. This architecture models the information flow in a tree with two separate recurrent modules: one carrying ancestral information (received from parent and passed on to offspring) and the other carrying fraternal information (passed from sibling to sibling). The topology of the tree is modeled explicitly and separately from the label prediction, with modules that given the state of a node predict whether it has children and siblings.
+
+The experimental results show that the proposed method is able to predict reasonable tree structures from encoded vector representations. Despite the simple structure of the IFTTT trees, the results on that task suggest a promising direction of using DRNNs for generating programs or executable queries from natural language. On the other hand, the results on the toy machine translation task show that even when used to generate sequences, DRNN’s exhibit desirable properties, such as invariance over structural modifications and the ability to perform coarse-to-fine decoding. In order to truly use this architecture for machine translation, the approach must be scaled by resorting to batch processing in GPU. This is possible since forward and backward propagation are computed sequentially along tree traversal paths so that inputs and hidden states of parents and siblings can be grouped into tensors and operated in batch. We leave this as an avenue for future work.
+
+# ACKNOWLEDGEMENTS
+
+DA-M acknowledges support from a CONACYT fellowship. The authors would like to thank the anonymous reviewers for their constructive comments.
+
+REFERENCES   
+Srk Branavan, Harr Chen, Luke S. Zettlemoyer, and Regina Barzilay. Reinforcement learning for mapping instructions to actions. Proc. Jt. Conf. 47th Annu. Meet. ACL 4th Int. Jt. Conf. Nat. Lang. Process. AFNLP Vol. 1-Volume 1, (August):82–90, 2009. ISSN 1742206X. doi: 10.3115/ 1687878.1687892.   
+Danqi Chen and Christopher D Manning. A Fast and Accurate Dependency Parser using Neural Networks. Proc. 2014 Conf. Empir. Methods Nat. Lang. Process., (i):740–750, 2014. URL https://cs.stanford.edu/{˜}danqi/papers/emnlp2014.pdf.   
+Kyunghyun Cho, Bart van Merrienboer, Dzmitry Bahdanau, and Yoshua Bengio. On the Properties of Neural Machine Translation: Encoder–Decoder Approaches. Proc. SSST-8, Eighth Work. Syntax. Semant. Struct. Stat. Transl., pp. 103–111, 2014. URL http://arxiv.org/pdf/ 1409.1259v2.pdf.   
+Li Dong and Mirella Lapata. Language to Logical Form with Neural Attention. In ACL, pp. 33–43, 2016. doi: 10.18653/v1/P16-1004. URL http://arxiv.org/abs/1601.01280.   
+Gottlob Frege. Uber Sinn und Bedeutung. ¨ Zeitschrift fur Philos. und Philos. Krit. ¨ , (1):25–50, 1892.   
+Christoph Goller and Andreas Kuechler. Learning task-dependent distributed representations by backpropagation through structure. In Int. Conf. Neural Networks, pp. 347–352, 1996. ISBN 0-7803-3210-5. doi: 10.1109/ICNN.1996.548916.   
+Sepp Hochreiter and Jurgen Jurgen Schmidhuber. Long short-term memory. ¨ Neural Comput., 9(8): 1–32, 1997. ISSN 0899-7667. doi: 10.1162/neco.1997.9.8.1735.   
+Rj Kate, Yw Wong, and Rj Mooney. Learning to transform natural to formal languages. In Proc. Natl. Conf. Artif. Intell., volume 20, pp. 1062–1068, 2005. ISBN 1-57735-236-x. URL http: //www.aaai.org/Library/AAAI/2005/aaai05-168.php.   
+Diederik Kingma and Jimmy Ba. Adam: A Method for Stochastic Optimization. Int. Conf. Learn. Represent., pp. 1–13, 2014. URL http://arxiv.org/abs/1412.6980.   
+Eliyahu Kiperwasser and Yoav Goldberg. Easy-First Dependency Parsing with Hierarchical Tree LSTMs. TACL, 2016. URL https://www.transacl.org/ojs/index.php/tacl/ article/viewFile/798/208.   
+G. Klein, Y. Kim, Y. Deng, J. Senellart, and A. M. Rush. OpenNMT: Open-Source Toolkit for Neural Machine Translation. ArXiv e-prints, 2017.   
+Christopher D. Manning, Mihai Surdeanu, John Bauer, Jenny Finkel, Steven J. Bethard, and David McClosky. The Stanford CoreNLP natural language processing toolkit. In Association for Computational Linguistics (ACL) System Demonstrations, pp. 55–60, 2014. URL http://www.aclweb.org/anthology/P/P14/P14-5010.   
+Jeffrey Pennington, Richard Socher, and Christopher D Manning. GloVe: Global Vectors for Word Representation. In Proc. 2014 Conf. Empir. Methods Nat. Lang. Process., 2014.   
+Chris Quirk, Raymond Mooney, and Michel Galley. Language to Code: Learning Semantic Parsers for If-This-Then-That Recipes. ACL-IJCNLP, (July):878–888, 2015. URL http: //www.aclweb.org/anthology/P15-1085.   
+Marc’Aurelio Ranzato, Sumit Chopra, Michael Auli, and Wojciech Zaremba. Sequence Level Training with Recurrent Neural Networks. In ICLR, pp. 1–15, 2016. URL http://arxiv.org/ abs/1511.06732.   
+R Socher and Cc Lin. Parsing natural scenes and natural language with recursive neural networks. In EMNLP, pp. 129–136, 2011. ISBN 9781450306195. doi: 10.1007/978-3-540-87479-9.   
+Richard Socher, Brody Huval, Christopher D Manning, and Andrew Y Ng. Semantic Compositionality through Recursive Matrix-Vector Spaces. In EMNLP, number Mv, pp. 1201–1211, 2012. ISBN 9781937284435.   
+Richard Socher, Alex Perelygin, and Jy Wu. Recursive deep models for semantic compositionality over a sentiment treebank. Proc. . . . , pp. 1631–1642, 2013. ISSN 1932-6203. doi: 10.1371/ journal.pone.0073791.   
+Ilya Sutskever, Oriol Vinyals, and Quoc V. Le. Sequence to sequence learning with neural networks. In NIPS, pp. 9, 2014. ISBN 1409.3215. URL http://arxiv.org/abs/1409.3215.   
+Kai Sheng Tai, Richard Socher, and Christopher D. Manning. Improved Semantic Representations From Tree-Structured Long Short-Term Memory Networks. In Proc. 53rd Annu. Meet. Assoc. Comput. Linguist. 7th Int. Jt. Conf. Nat. Lang. Process., pp. 1556–1566, 2015. ISBN 9781941643723. URL http://arxiv.org/abs/1503.0075.   
+Arun Venkatraman, Martial Hebert, and J Andrew Bagnell. Improving Multi-step Prediction of Learned Time Series Models. Twenty-Ninth AAAI Conf. Artif. Intell., pp. 3024–3030, 2015.   
+Orioi Vinyals and Quoc V. Le. A Neural Conversational Model. arXiv, 37, 2015.   
+Ronald J. Williams and David Zipser. Gradient-based learning algorithms for recurrent networks and their computational complexity. Back-propagation Theory, Archit. Appl., pp. 433–486, 1995. doi: 10.1080/02673039508720837.   
+Wojciech Zaremba, Ilya Sutskever, and Oriol Vinyals. Recurrent Neural Network Regularization. ICLR, pp. 1–8, 2015. URL http://arxiv.org/abs/1409.2329.   
+Xingxing Zhang, Liang Lu, and Mirella Lapata. Top-down Tree Long Short-Term Memory Networks. In NAACL-HLT-2016, pp. 310–320, 2016.
+
+# A VARIATIONS ON TOPOLOGY PREDICTION
+
+Besides the topology prediction approach presented in Section 3.1, we experimented with two additional variations of the proposed doubly-recurrent neuron: (i) using tokens to trigger both depth and width termination (i.e. implicit topology prediction) and (ii) using tokens for width-stopping decision, but predict explicitly depth termination (single topology prediction). Recall that in the model proposed in Section 3.1 both decisions are explicit (double topology prediction). The neurons in each of these alternative formulations are depicted in Figure 7. In order to train these two alternative models, we add special stopping tokens to the vocabulary, and we pad the training with additional nodes labeled with this token. Besides requiring larger trees and resulting in slower training, we empirically observed alternatives (i) and (ii) to result in worse performance. We hypothesize that this has to do with the fact that when using token-based stopping, topological and label prediction decisions are confounded, which results in less efficient learning.
+
+![](images/fe0f0fd4871bdb513ab5a6aa190a48b889988b7899c6549f4b7c99f2085ed282.jpg)  
+Figure 7: A single unit in each of the three alternative versions of the doubly-recurrent neural network, for node $i$ with parent $p$ and sibling $s$ . Left: No explicit topology prediction, Middle: single (ancestral) topology prediction, Right: double (ancestral and fraternal) topology prediction. The top (left) incoming arrows represent the input and state received from the parent node (previous node, respectively).
+
+# B TRAINING DETAILS
+
+# B.1 BACKPROPAGATION WITH DRNN’S
+
+During training, we do the forward pass over the trees in breadth-first preorder, feeding into every node an ancestral and a fraternal state. For computational efficiency, before passing on the ancestral state to the offspring, we update it through the RNN using the current node’s label, so as to avoid repeating this step for every child node. After the forward pass is complete, we compute label (cross-entropy) and topological (binary cross-entropy) loss for every node. In the backward pass, we compute in this order:
+
+1. Gradient of the current node’s label prediction loss with respect to softmax layer parameters $\mathbf { W } , \mathbf { v } ^ { a } , \mathbf { v } ^ { f } \colon \nabla _ { \boldsymbol { \theta } } \mathcal { L } \big ( \mathbf { x } _ { i } , \widehat { \mathbf { x } } _ { i } \big )$ .   
+2. Gradients of topological prediction variable loss with respect to sigmoid layer parameters: $\nabla _ { \theta } \mathcal { L } ( p _ { i } ^ { a } , t _ { i } ^ { a } )$ and $\nabla _ { \theta } \mathcal { L } ( p _ { i } ^ { \dot { f } } , t _ { i } ^ { f } )$ .   
+3. Gradient of predictive state layer parameters with respect to $\mathbf { h } ^ { ( p r e d ) }$ .   
+4. Gradient of predicted ancestral and fraternal hidden states with respect to $g ^ { f }$ and $g ^ { a }$ ’s parameters.
+
+The gradients of the input ancestral and fraternal hidden states are then passed on to the previous sibling and parent. When nodes have more than one child, we combine gradients from multiple children by averaging them. This procedure is repeated until the root note is reached, after which a single (ancestral state) gradient is passed to the encoder.
+
+# B.2 MODEL SPECIFICATION AND TRAINING PARAMETERS
+
+The best parameters for all tasks are chosen by performance on the validation sets. We perform early stopping based on the validation loss. For the IFTTT task, we initialize word embeddings with pretrained GloVe vectors (Pennington et al., 2014). For both tasks we clip gradients when the absolute value of any element exceeds 5. We regularize with a small penalty $\rho$ on the $l _ { 2 }$ norm of the parameters. We train all methods with ADAM (Kingma & Ba, 2014), with initial learning rate chosen by cross-validation. The parameter configurations that yielded the best results and were used for the final models are shown in Table 3. Details about the four models used for the machine translation task are shown in Table 4.
+
+Table 3: Hyperparameter choice for DRNNs in the synthetic and IFTTT tasks   
+
+<table><tr><td>Task</td><td>Encoder</td><td>Dim</td><td>Batch</td><td>Learning Rate</td><td>Regularization p</td></tr><tr><td>synthetic</td><td>LSTM</td><td>50</td><td>20</td><td>0.05</td><td>1×10-5</td></tr><tr><td>IFTTT</td><td>GRU</td><td>150</td><td>35</td><td>0.06</td><td>1×10-4</td></tr><tr><td>IFTTT</td><td>LSTM</td><td>150</td><td>35</td><td>0.05</td><td>5×10-4</td></tr></table>
+
+Table 4: Models used in the machine translation task.   
+
+<table><tr><td>Model</td><td>Encoder</td><td>Decoder</td><td>Dim</td><td>RNN Layers</td><td>Batch</td></tr><tr><td>SEQ2SEQ (Small)</td><td>LSTM</td><td>LSTM</td><td>150</td><td>1</td><td>64</td></tr><tr><td>SEQ2SEQ (Large)</td><td>LSTM</td><td>LSTM</td><td>300</td><td>3</td><td>64</td></tr><tr><td>DRNN (Small)</td><td>LSTM</td><td>DRNN-GRU (Left-Right)</td><td>150</td><td>1</td><td>32</td></tr><tr><td>DRNN (Large)</td><td>LSTM</td><td>DRNN-GRU (Left-Right)</td><td>300</td><td>1</td><td>32</td></tr></table>
+
+# C DATASET DETAILS
+
+# C.1 SYNTHETIC TREE DATASET GENERATION
+
+We generate trees in a top-down fashion, conditioning the label and topology of every node on the state of its ancestors and siblings. For simplicity, we use a Markovian assumption on these dependencies, modeling the probability of a node’s label as depending only on the label of its parent $p ( i )$ and the last sibling $s ( i )$ generated before it (if any). Conditioned on these two inputs, we model the label of the node as coming from a multinomial distribution over the alphabet:
+
+$$
+\begin{array} { r } { P ( w _ { i } \mid \mathcal { T } ) = P ( w \mid w _ { p ( i ) } , w _ { s ( i ) } ) \sim \mathrm { M u l t i } \big ( \theta _ { w _ { p ( i ) } , w _ { s ( i ) } } \big ) } \end{array}
+$$
+
+where $\theta _ { w _ { p ( i ) } , w _ { s ( i ) } }$ are class probabilities drawn from a Dirichlet prior with parameter $\alpha _ { v }$ . On the other hand, we denote by $b _ { i } ^ { a }$ the binary variable indicating whether node $i$ has descendants, and by $b _ { i } ^ { f }$ that indicating whether it has an ensuing sibling. We model these variables as depending only on the label of the current node and its position in the tree:
+
+$$
+\begin{array} { r l } & { P ( b _ { i } ^ { a } \mid \mathcal { T } ) = P ( b _ { i } ^ { a } \mid w _ { i } , D _ { i } ) = \mathrm { B e r n o u l l i } ( p _ { w _ { i } } ^ { a } \cdot g ^ { a } ( D _ { i } ) ) } \\ & { P ( b _ { i } ^ { f } \mid \mathcal { T } ) = P ( b _ { i } ^ { f } \mid w _ { i } , W _ { i } ) = \mathrm { B e r n o u l l i } ( p _ { w _ { i } } ^ { f } \cdot g ^ { f } ( W _ { i } ) ) } \end{array}
+$$
+
+where $D _ { i }$ is the depth of node $i$ and $W _ { i }$ its width, defined as its position among the children of its parent $p ( i )$ . Intuitively, we want to make $P ( b _ { i } ^ { a } = 1 | \mathcal { T } )$ decrease as we go deeper and further along the branches of the tree, so as to control its growth. Thus, we model $g ^ { a }$ and $g ^ { f }$ as decreasing functions with geometric decay, namely $g ^ { a } ( D ) = ( \gamma ^ { a } ) ^ { D }$ and $g ^ { f } ( W ) = ( \gamma ^ { \breve { f } } ) ^ { W }$ , with $\gamma ^ { a } , \gamma ^ { f } \in ( 0 , \overline { { 1 } } )$ . For the label-conditioned branching probabilities $P ( b _ { i } ^ { a } \mid w _ { i } )$ and $P ( b _ { i } ^ { f } \mid w _ { i } )$ , we use Bernoulli distributions with probabilities drawn from beta priors with parameters $( \alpha ^ { a } , \beta ^ { a } )$ and $( \alpha ^ { f } , \beta ^ { f } )$ , respectively.
+
+In summary, we use the following generative procedure to grow the trees:
+
+1. For each $w _ { i } \in V$ , draw $p _ { w _ { i } } ^ { a } \sim \mathbf { B e t a } ( \alpha ^ { a } , \beta ^ { a } )$ and $p _ { w _ { i } } ^ { f } \sim \mathrm { B e t a } ( \alpha ^ { f } , \beta ^ { f } )$
+
+2. For each pair $( w _ { i } , w _ { j } )$ draw $\theta _ { w _ { i } , w _ { j } } \sim \operatorname { D i r } ( \alpha ^ { V } )$
+
+3. While there is an unlabeled non-terminal node $i$ do:
+
+• Sample a label for $i$ from $w ^ { * } \sim P ( w | w _ { p ( i ) } , w _ { s ( i ) } ) = \mathrm { M u l t i } \big ( \theta _ { w _ { p ( i ) } , w _ { s ( i ) } } \big ) .$ . • Draw $b _ { a } \sim P ( b ^ { a } | w ^ { * } , D ) = \operatorname { B e r n o u l l i } ( \gamma _ { a } ^ { D } \cdot p _ { w ( i ) } ^ { a } )$ , where $D$ is the current depth. If $b ^ { a } = 1$ , generate an node $k$ , set $p ( k ) = i$ , and add it to the queue. • Draw $b _ { a } \sim P ( b ^ { f } | w ^ { * } , D ) = \operatorname { B e r n o u l l i } ( \gamma _ { f } ^ { W } \cdot p _ { w ( i ) } ^ { f } )$ , where $W$ is the current width. If $b ^ { f } = 1$ , generate an node $k$ , set $s ( k ) = i$ , and add it to the queue.
+
+Note that this generative process does create a dependence between the topology and content of the trees (since the variables $b ^ { a }$ and $b ^ { f }$ depend on the content of the tree via their dependence on the label of their corresponding node). However, the actual process by which labels and topological decision is generated relies on separate mechanisms. This is natural assumption which is reasonable to expect in practice.
+
+The choice of prior parameters is done drawing inspiration from natural language parse trees. We want nodes to have low but diverse probabilities of generating children, so we seek a slow-decaying distribution with most mass allocated in values close to 0. For this, we use $( \alpha ^ { a } , \beta ^ { a } ) = ( 0 . 2 5 , 1 )$ . For sibling generation, we use $( \alpha ^ { f } , \beta ^ { f } ) = ( 7 , 2 )$ , which yields a distribution concentrated in values close to 1, so that nodes have on average a high and similar probability of producing siblings. Since we seek trees that are wider than they are deep, we use decay parameters $\gamma _ { a } = 0 . 6 , \gamma _ { f } = 0 . 9$ . Finally, we use a $\alpha _ { v } = 1 0 \cdot { \bf 1 }$ for the parent-sibling probability prior, favoring non-uniform interactions. Using this configuration, we generate 5000 sentence-tree pairs, which we split into training (4000 examples), validation (500) and test (500) sets. The characteristics of the trees in the dataset are summarized in Table 5.
+
+Table 5: Synthetic tree dataset statistics. Tree size is measured in number of nodes, depth is the largest path from the root node to a leaf and width is the maximum number of children for any node in the tree. The values reported correspond to means with one standard deviation in parentheses.   
+
+<table><tr><td>Fold</td><td>Examples</td><td>Size</td><td>Depth</td><td>Width</td></tr><tr><td>train</td><td>4000</td><td>3.94 (3.38)</td><td>1.42 (0.66)</td><td>2.89 (1.71)</td></tr><tr><td>dev</td><td>500</td><td>4.13 (3.21)</td><td>1.46 (0.67)</td><td>2.91 (1.76)</td></tr><tr><td>test</td><td>500</td><td>3.64 (3.21)</td><td>1.32 (0.61)</td><td>2.80 (1.71)</td></tr></table>
+
+# C.2 IFTTT
+
+The IFTTT dataset comes with a script to generate the data by crawling and parsing the recipes. Unfortunately, by the time we ran the script many recipes had been removed or changed. We therefore resorted to the original dataset used by Quirk et al. (2015). We converted these recipes into our tree format, assigning a node to each element in the first three levels (channels, functions and arguments, see figure 5). For the parameters level, many recipes have sentences instead of single tokens, so we broke these up creating one node per word. The last two layers are therefore the most topologically diverse, whereas the structure of the first two layers is constant (all trees have channels and functions). A very small fraction $( < 1 \%$ ) of trees that could not by parsed into our format was excluded from the dataset.
+
+Table 6 shows various statistics about the topological characteristics of the recipes in the IFTTT dataset. The middle columns show percentage of trees that contain nonempty arguments and parameters in trigger (IF) and action (THEN) branches. Almost all recipes have none empty arguments and parameters (and thus depth 4, excluding the root), and a lower percentage—but still a majority—has arguments and parameters on the trigger side too. The last two columns show tree statistics pertaining to the complexity of trees after conversion to our format. The distribution of tree sizes is mostly concentrated between 4 and 30 nodes, with a slow-decaying tail of examples above this range (see Figure 8).
+
+Table 6: IFTTT dataset statistics. The middle columns show percentage of trees that contain nonempty arguments and parameters in trigger (IF) and action (THEN) branches. The last column shows average (with standard deviation) tree size and depth.   
+
+<table><tr><td rowspan="2">Fold</td><td rowspan="2">Examples</td><td colspan="2">Has args.(%)</td><td colspan="2">Has params. (%)</td><td colspan="2">Tree Size</td></tr><tr><td>Trigger</td><td>Action</td><td>Trigger</td><td>Action</td><td>#Nodes</td><td>Depth</td></tr><tr><td>train</td><td>67,444</td><td>69.10</td><td>98.46</td><td>65.47</td><td>96.77</td><td>16.93 (31.71)</td><td>3.99 (.13)</td></tr><tr><td>dev</td><td>4,038</td><td>69.44</td><td>98.46</td><td>66.42</td><td>96.31</td><td>16.55 (8.75)</td><td>3.99 (.11)</td></tr><tr><td>test</td><td>3,725</td><td>68.38</td><td>98.66</td><td>65.64</td><td>97.50</td><td>16.43 (8.18)</td><td>3.99 (.12)</td></tr></table>
+
+![](images/55bb3887b04062049bbba8bac0910b7d247e0a696c4c881323bbf4b64de0fedf.jpg)  
+Figure 8: Tree size distribution in the IFTTT dataset.
+
+Regarding the content of the trees, the labels of the nodes in the first two levels (channels and functions) come from somewhat reduced vocabularies: 111 and 434 unique symbols for the trigger branch, respectively, and 157 and 85 for the action branch. The lower layers of the tree have a much more diverse vocabulary, with about 60K unique tokens in total. On the source side, the vocabulary over the sentence descriptions is large too, with about 30K unique tokens. The average sentence size is 6.07 tokens, with $80 \%$ of the sentences having at most 12 tokens.
+
+# C.3 MACHINE TRANSLATION
+
+Starting from a preprocessed6 $2 \%$ sub-selection of the English-French section of the WMT14 dataset, we further prune down the data by keeping only sentences of length between 5 and 20 words, and for which every word is within the 20K most frequent. The reason for this is to simplify the task by keeping only common words and avoiding out-of-vocabulary tokens. After this filtering, we are left with 53,607, 918 and 371 sentences for train, validation and test sets. After tokenizing, we obtain dependency parses for the target (English) sentences using the Stanford CoreNLP toolkit (Manning et al., 2014).
+
+For the perturbation experiments, we randomly selected 50 sentences from among those in the test that could be easily restructured without significantly altering their meaning. The type of alterations we perform are: subordinate clause swapping, alternative construction substitution, passive/active voice change. In doing this, we try to keep the number of added/deleted words to a minimum, to minimize vocabulary-induced likelihood variations. When inserting new words, be verify that they are contained in the original vocabulary of 20K words. In Table 7 we show a few examples of the source, original target and perturbed target sentences.
+
+Table 7: Example structural perturbations for likelihood robustness experiments.   
+
+<table><tr><td>source target perturbation</td><td>&quot;apres un accord de paix signe en 1992 elle est devenue un parti d opposition.&quot; “after a 1992 peace deal it became an opposition party.&quot; &quot;it became an opposition party after a 1992 peace deal.&quot;</td></tr><tr><td>source target perturbation</td><td>“cela représente environ 9 milliards de grains de mais.” “that&#x27;s about 9 billion individual kernels of corn.&quot; “this amounts to about 9 billion kernels of corn.&quot;</td></tr><tr><td>source target perturbation</td><td>“l&#x27;exercice de fonctions publiques est une question de service public.&quot; &quot;public office is about public service.&quot; &quot;the exercise of public functions is a matter of public service.</td></tr><tr><td>source target perturbation</td><td>“nous avons ainsi effectue depuis la fin de I&#x27;hiver dernier 64 interventions.” “hence we have carried out 64 operations since last winter.” “we have therefore carried out 64 operations since last winter.&quot;</td></tr><tr><td>source target perturbation</td><td>“on estime qu&#x27;un enfant sur 2OoO nés chaque année n&#x27;est ni un garcon ni une fille.&quot; “an estimated one in 2OoO children born each year is neither boy nor girl.&quot; “it is estimated that one in every 2OoO children born every year is neither a boy nor a girl.&quot;</td></tr></table>
+
+# D ADDITIONAL EXAMPLE GENERATED TREES
+
+![](images/6ba28271cf52cee43f0c4e3dd11a59ccb0005caae90ef97b95c7008d843db2a0.jpg)  
+(a) Encoder sentence input: “ROOT P R C”
+
+![](images/08ac7093d55b4ae55d9b93ce147a909d3a705737afac4a50d965b08cfa223ee9.jpg)  
+(b) Encoder sentence input: “ROOT Z T Y Q”
+
+![](images/8d5161627149fde344ba399ee222056bdf3e5d0f27180bd6677c1a398c106283.jpg)  
+(c) Encoder sentence input: “ROOT K T V”
+
+![](images/02c13889f526a643fe6f1c0153c559ca65cd2303de42436849d119efedbf9f52.jpg)  
+(d) Encoder sentence input: “ROOT Q F V R G D A”   
+Figure 9: Selected trees generated by the DRNN decoder from vector-encoded descriptions for test examples of the synthetic tree dataset. Trees in the same row correspond to predictions by models trained on randomly sampled subsets of size $N$ of the training split. We present cases for which the prediction is accurate (a,c) and cases for which it is not (b,d). Note how in (d) the model predicts many of the labels correctly, but confuses some of the dependencies (edges) in the tree.

parse/train/HkYhZDqxg/HkYhZDqxg_content_list.json

@@ -0,0 +1,1493 @@
+[
+    {
+        "type": "text",
+        "text": "TREE-STRUCTURED DECODING WITH DOUBLYRECURRENT NEURAL NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            99,
+            820,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "David Alvarez-Melis & Tommi S. Jaakkola Computer Science and Artificial Intelligence Lab MIT {davidam,tommi}@csail.mit.edu ",
+        "bbox": [
+            183,
+            169,
+            508,
+            227
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            262,
+            544,
+            277
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We propose a neural network architecture for generating tree-structured objects from encoded representations. The core of the method is a doubly recurrent neural network model comprised of separate width and depth recurrences that are combined inside each cell (node) to generate an output. The topology of the tree is modeled explicitly together with the content. That is, in response to an encoded vector representation, co-evolving recurrences are used to realize the associated tree and the labels for the nodes in the tree. We test this architecture in an encoderdecoder framework, where we train a network to encode a sentence as a vector, and then generate a tree structure from it. The experimental results show the effectiveness of this architecture at recovering latent tree structure in sequences and at mapping sentences to simple functional programs. ",
+        "bbox": [
+            233,
+            299,
+            764,
+            452
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            491,
+            336,
+            507
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recurrent neural networks have become extremely popular for modeling structured data. Key to their success is their ability to learn long-range temporal dependencies, their flexibility, and ease of customization. These architectures are naturally suited for modeling sequences since the underlying state evolution resulting from successive operations follows an inherently linear order (Williams & Zipser, 1995; Hochreiter & Schmidhuber, 1997). Indeed, they have been successfully adapted to language modeling (Zaremba et al., 2015), machine translation (Sutskever et al., 2014) and conversational agents (Vinyals & Le, 2015), among other applications. ",
+        "bbox": [
+            174,
+            526,
+            825,
+            625
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Although sequences arise frequently in practice, other structures such as trees or graphs do not naturally conform to a linear ordering. For example, natural language sentences or associated parse trees, programs, hierarchical structures in biology, or molecules are not inherently linear structures. While sentences in natural language can be modeled as if they were linear sequences, the underlying process is compositional (Frege, 1892). Models that construct sentences compositionally should derive an advantage from adopting a more appropriate inductive bias. ",
+        "bbox": [
+            174,
+            631,
+            825,
+            715
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The flexibility and success of recurrent neural networks in modeling and generating sequential data has prompted efforts to adapt them to non-sequential data too. Recent work has focused on the application of neural architectures to hierarchical structures, albeit in limited ways. Much of this work has assumed that either the full tree structure is given (Socher et al., 2012; Tai et al., 2015) or at least the nodes are (Socher & Lin, 2011; Chen & Manning, 2014; Kiperwasser & Goldberg, 2016). In the former scenario, the network aggregates the node information in a manner that is coherent with a given tree structure while, in the latter, generation is reduced to an attachment problem, i.e., sequentially deciding which pairs of nodes to join with an edge until a tree is formed. ",
+        "bbox": [
+            174,
+            722,
+            825,
+            833
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The full problem of decoding with structure, i.e., generating a tree-structured object with node labels from a given vector representation, has remained largely unexplored until recently. Recent efforts to adapt RNNs to this context have so far remained relatively close to their sequential counterparts. For example, in order to capture depth and branching in the tree, one can introduce special tokens (Dong & Lapata, 2016) or use alternating RNNs coupled with external classifiers to predict branching (Zhang et al., 2016). ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this work, we propose a novel architecture tailored specifically to tree-structured decoding. At the heart of our approach is a doubly-recurrent (breadth and depth-wise recurrent) neural network which separately models the flow of information between parent and children nodes, and between siblings. Each of these relationships is modeled with a recurrent module whose hidden states are updated upon observing node labels. Every node in the tree receives two hidden states, which are then combined and used to predict a label for that node. Besides maintaining separate but simultaneous fraternal and paternal recurrences, the proposed architecture departs from previous methods in that it explicitly models tree topology. Each node in the network has modules that predict, based on the cell state, whether the node is terminal, both in terms of depth and width. Decoupling these decisions from the label prediction allows for a more concise formulation, which does not require artificial tokens to be added to the tree to simulate branching. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            256
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We test this novel architecture in various encoder-decoder frameworks, coupling it with sequential encoders to predict tree structure from encoded vector representations of sequences. The experimental results show the effectiveness of this approach at recovering latent structure in flattened string representations of trees (Section 4.1) and at mapping from natural language descriptions of simple programs to abstract syntax trees (Section 4.2). In addition, we show that even for sequence-tosequence tasks such as machine translation, the proposed architecture exhibits desirable properties, such as invariance to structural changes and coarse-to-fine generation (Section 4.3). ",
+        "bbox": [
+            174,
+            263,
+            825,
+            361
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To summarize, the main contributions of this paper are as follows: ",
+        "bbox": [
+            174,
+            367,
+            606,
+            382
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• We propose a novel neural network architecture specifically tailored to tree-structured decoding, which maintains separate depth and width recurrent states and combines them to obtain hidden states for every node in the tree. We equip this novel architecture with a mechanism to predict tree topology explicitly (as opposed to implicitly by adding nodes with special tokens). We show experimentally that the proposed method is capable of recovering trees from encoded representations and that it outperforms state-of-the-art methods in a task consisting of mapping sentences to simple functional programs. ",
+        "bbox": [
+            215,
+            393,
+            825,
+            518
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            537,
+            344,
+            555
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Recursive Neural Networks. Recursive neural networks (Socher & Lin, 2011; Socher et al., 2012) were proposed to model data with hierarchical structures, such as parsed scenes and natural language sentences. Though they have been most successfully applied to encoding objects when their treestructured representation is given (Socher et al., 2013), the original formulation by Socher & Lin (2011) also considered using them to predict the structure (edges), albeit for the case where nodes are given. Thus, besides their limited applicability due to their assumption of binary trees, recursive neural networks are not useful for fully generating trees from scratch. ",
+        "bbox": [
+            174,
+            570,
+            825,
+            669
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Tree-structured encoders. The Tree-LSTM of Tai et al. (2015) is a generalization of long shortterm memory networks (Hochreiter & Schmidhuber, 1997) to tree-structured inputs. Their model constructs a sentence representation bottom-up, obtaining at every step the representation of a node in the tree from those of its children. In this sense, this model can be seen as a generalization of recursive neural networks to trees with degree potentially greater than two, with the additional longrange dependency modeling provided by LSTMs. They propose two methods for aggregating the states of the children, depending on the type of underlying tree: N-ary trees or trees with unknown and potentially unbounded branching factor. TreeLSTMs have shown promising results for compositional encoding of structured data, though by construction they cannot be used for decoding, since they operate on a given tree structure. ",
+        "bbox": [
+            174,
+            684,
+            825,
+            824
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Tree-structured decoders. Proposed only very recently, most tree-structured decoders rely on stacked on intertwined RNNs, and use heuristic methods for topological decisions during generation. Closest to our method is the Top-down Tree LSTM of Zhang et al. (2016), which generates a tree from an encoded representation. Their method relies on 4 independent LSTMs, which act in alternation—as opposed to simultaneously in our approach—yielding essentially a standard LSTM that changes the weights it uses based on the position of the current node. In addition, their method provides children with asymmetric parent input: “younger” children receive information from the parent state only through the previous sibling’s state. Though most of their experiments focus on the case where the nodes are given, they mention how to use their method for full prediction by introducing additional binary classifiers which predict which of the four LSTMs is to be used. These classifiers are trained in isolation after the main architecture has been trained. Contrary to this approach, our method can be trained end-to-end in only one pass, has a simpler formulation and explicitly incorporates topological prediction as part of the functioning of each neuron. ",
+        "bbox": [
+            174,
+            840,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            202
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "A similar approach is proposed by Dong & Lapata (2016). They propose SEQ2TREE, an encoderdecoder architecture that maps sentences to tree structures. For the decoder, they rely on hierarchical use of an LSTM, similar to Tai et al. (2015), but in the opposite direction: working top-down from the root of the tree. To decide when to change levels in the hierarchy, they augment the training trees with nonterminal nodes labeled with a special token $< n >$ , which when generated during decoding trigger the branching out into a lower level in the tree. Similar to our method, they feed nodes with hidden representations of their parent and sibling, but they do so by concatenating both states and running them through a single recurrent unit, as opposed to our method, where these two sources of information are handled separately. A further difference is that our approach does not require artificial nodes with special tokens to be added to the tree, resulting in smaller trees. ",
+        "bbox": [
+            174,
+            208,
+            825,
+            347
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Hierarchical Neural Networks for Parsing. Neural networks have also been recently introduced to the problem of natural language parsing (Chen & Manning, 2014; Kiperwasser & Goldberg, 2016). In this problem, the task is to predict a parse tree over a given sentence. For this, Kiperwasser & Goldberg (2016) use recurrent neural networks as a building block, and compose them recursively to obtain a tree-structured encoder. Starting from the leaves (words) they predict a parse tree with a projective bottom-up strategy, which sequentially updates the encoded vector representation of the tree and uses it to guide edge-attaching decisions. Though conceptually similar to our approach, their method relies on having access to the nodes of the tree (words) and only predicts its topology, so—similar to recursive neural networks—it cannot be used for a fully generative decoding. ",
+        "bbox": [
+            174,
+            367,
+            825,
+            493
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 DOUBLY RECURRENT NEURAL NETWORKS",
+        "text_level": 1,
+        "bbox": [
+            174,
+            520,
+            566,
+            535
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Generating a tree-structured object from scratch using only an encoded representation poses several design challenges. First, one must decide in which order to generate the tree. If the nodes on the decoder side were given (such as in parsing), it would be possible to generate a tree bottom-up from these nodes (e.g. as Kiperwasser & Goldberg 2016 do). In the setting we are interested in, however, not even the nodes are known when decoding, so the natural choice is a top-down decoder, which starting from an encoded representation generates the root of the tree and then recursively generates the children (if any) of every node. ",
+        "bbox": [
+            174,
+            554,
+            825,
+            651
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The second challenge arises from the asymmetric hierarchical nature of trees. Unlike the sequenceto-sequence setting where encoding and decoding can be achieved with analogous procedures, when dealing with tree-structured data these two involve significantly different operations. For example, an encoder that processes a tree bottom-up using information of a node’s children to obtain its representation cannot be simply reversed and used as a decoder, since when generating the tree top-down, nodes have to be generated before their children are. ",
+        "bbox": [
+            174,
+            659,
+            823,
+            742
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "An additional design constraint comes from deciding what information to feed to each node. For sequences, the choice is obvious: a node should receive information from the node preceding or succeeding it (or both), i.e. there is a one-dimensional flow of information. In trees, there is an evident flow of information from parent to children (or vice-versa), but when generating nodes in a top-down order it seems unnatural to generate children in isolation: the label of one of them will likely influence what the states of the other children might be. For example, in the case of parse trees, generating a verb will reduce the chances of other verbs occurring in that branch. ",
+        "bbox": [
+            174,
+            750,
+            825,
+            847
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "With these considerations in mind, we propose an architecture tailored to tree decoding from scratch: top-down, recursive and doubly-recurrent, i.e. where both the ancestral (parent-to-children) and fraternal (sibling-to-sibling) flows of information are modeled with recurrent modules. Thus, the building block of a doubly recurrent neural network (DRNN) is a cell with two types of input states, one coming from its parent, updated and passed on to its descendants, and another one received from its previous sibling,1 updated and passed on to the next one. We model the flow of information in the two directions with separate recurrent modules. ",
+        "bbox": [
+            174,
+            854,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Formally, let $\\mathcal { T } = \\{ \\mathcal { V } , \\mathcal { E } , \\mathcal { X } \\} _ { \\mathrm { ~ \\scriptsize ~ . ~ } }$ be a connected labeled tree, where $\\nu$ is the set of nodes, $\\mathcal { E }$ the set of edges and $\\mathcal { X }$ are node labels.2 Let $g ^ { a }$ and $g ^ { f }$ be functions which apply one step of the two separate RNNs. For a node $i \\in \\mathcal V$ with parent $p ( i )$ and previous sibling $s ( i )$ , the ancestral and fraternal hidden states are updated via ",
+        "bbox": [
+            173,
+            138,
+            825,
+            194
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2c3717df903b76c94ffb47fffdcc3ad06053f5e8c1d711813ab0b91a96848cee.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathbf h _ { i } ^ { a } = g ^ { a } ( \\mathbf h _ { p ( i ) } ^ { a } , \\mathbf x _ { p ( i ) } ) } \\\\ { \\mathbf h _ { i } ^ { f } = g ^ { f } ( \\mathbf h _ { s ( i ) } ^ { f } , \\mathbf x _ { s ( i ) } ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            424,
+            198,
+            571,
+            242
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbf { x } _ { s ( j ) } , \\mathbf { x } _ { p ( i ) }$ are the vectors representing the previous sibling’s and parent’s values, respectively. Once the hidden depth and width states have been updated with these observed labels, they are combined to obtain a predictive hidden state: ",
+        "bbox": [
+            174,
+            244,
+            825,
+            286
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fb97253dc02e509e3f15881588ed7cc8dcafc6e1861a9840dd6f49abfa9aa1cb.jpg",
+        "text": "$$\n\\mathbf { h } _ { i } ^ { ( p r e d ) } = \\operatorname { t a n h } \\left( \\mathbf { U } ^ { f } \\mathbf { h } _ { i } ^ { f } + \\mathbf { U } ^ { a } \\mathbf { h } _ { i } ^ { a } \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            382,
+            289,
+            614,
+            316
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbf { U } ^ { f } \\in \\mathbb { R } ^ { n \\times D _ { f } }$ and $\\mathbf { U } ^ { a } \\in \\mathbb { R } ^ { n \\times D _ { a } }$ are learnable parameters. This state contains combined information of the node’s neighborhood in the tree, and is used to predict a label for it. In its simplest form, the network could compute the output of node $i$ by sampling from distribution ",
+        "bbox": [
+            174,
+            319,
+            825,
+            363
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f4f04fdfca0507c11e6777337bde7de8fd34710e70fc0e1489168531da365a49.jpg",
+        "text": "$$\n\\mathbf { o } _ { i } = \\mathrm { s o f t m a x } ( \\mathbf { W } \\mathbf { h } _ { i } ^ { ( p r e d ) } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            411,
+            366,
+            584,
+            387
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In the next section, we propose a slight modification to (4) whereby topological information is included in the computation of cell outputs. After the node’s output symbol $\\mathbf { x } _ { i }$ has been obtained by sampling from $\\mathbf { o } _ { i }$ , the cell passes $\\mathbf { h } _ { i } ^ { a }$ to all its children and ${ \\bf { h } } _ { i } ^ { f }$ to the next sibling (if any), enabling them to apply Eqs (1) and (2) to realize their states. This procedure continues recursively, until termination conditions (explained in the next section) cause it to halt. ",
+        "bbox": [
+            174,
+            390,
+            825,
+            462
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 TOPOLOGICAL PREDICTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            478,
+            408,
+            492
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "As mentioned before, the central issue with free-form tree construction is to predict the topology of the tree. When constructing the tree top-down, for each node we need to decide: (i) whether it is a leaf node (and thus it should not produce offspring) and (ii) whether there should be additional siblings produced after it. Answering these two questions for every node allows us to construct a tree from scratch and eventual stop growing it. ",
+        "bbox": [
+            173,
+            505,
+            825,
+            574
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Sequence decoders typically rely on special tokens to terminate generation (Sutskever et al., 2014). The token is added to the vocabulary and treated as a regular word. During training, the examples are padded with this token at the end of the sequence, and during testing, generation of this token signals termination. These ideas has been adopted by most tree decoders (Dong & Lapata, 2016). There are two important downsides of using a padding strategy for topology prediction in trees. First, the size of the tree can grow considerably. While in the sequence framework only one stopping token is needed, a tree with $n$ nodes might need up to $O ( n )$ padding nodes to be added. This can have important effects in training speed. The second reason is that a single stopping token selected competitively with other tokens requires one to continually update the associated parameters in response to any changes in the distribution over ordinary tokens so as to maintain topological control. ",
+        "bbox": [
+            173,
+            580,
+            825,
+            720
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Based on these observations, we propose an alternative approach to stopping, in which topological decisions are made explicitly (as opposed to implicitly, with stopping tokens). For this, we use the predictive hidden state of the node $\\mathbf { \\bar { h } } ^ { ( p r e d ) }$ with a projection and sigmoid activation: ",
+        "bbox": [
+            174,
+            727,
+            821,
+            771
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/31e78841f69148fc653c6e2ee7a8731a7684362391783e326c682c1c7e734fdf.jpg",
+        "text": "$$\np _ { i } ^ { a } = \\sigma ( \\mathbf { u } ^ { a } \\cdot \\mathbf { h } _ { i } ^ { ( p r e d ) } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            428,
+            775,
+            570,
+            795
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The value $p _ { i } ^ { a } \\in [ 0 , 1 ]$ is interpreted as the probability that node $i$ has children. Analogously, we can obtain a probability of stopping fraternal branch growth after the current node as follows: ",
+        "bbox": [
+            173,
+            797,
+            826,
+            827
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9d93205b83dc3ab622fc6b4bd92dc951f3abbbdb3196d6a2f00cc103b26d56c1.jpg",
+        "text": "$$\np _ { i } ^ { f } = \\sigma ( \\mathbf { u } ^ { f } \\cdot \\mathbf { h } _ { i } ^ { ( p r e d ) } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            426,
+            829,
+            570,
+            851
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/6812630ce984fe637e971c92890ea45b3726d69cb63be9c40c8f16aaf6c9cc03.jpg",
+        "image_caption": [
+            "Figure 1: Left: A cell of the doubly-recurrent neural network corresponding to node $i$ with parent $p$ and sibling $s$ . Right: Structure-unrolled DRNN network in an encoder-decoder setting. The nodes are labeled in the order in which they are generated. Solid (dashed) lines indicate ancestral (fraternal) connections. Crossed arrows indicate production halted by the topology modules. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            102,
+            812,
+            281
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Note that these stopping strategies depart from the usual padding methods in a fundamental property: the decision to stop is made before instead of in conjunction with the label prediction. The rationale behind this is that the label of a node will likely be influenced not only by its context, but also by the type of node (terminal or non-terminal) where it is to be assigned. This is the case in language, for example, where syntactic constraints restrict the type of words that can be found in terminal nodes. For this purpose, we include the topological information as inputs to the label prediction layer. Thus, (4) takes the form ",
+        "bbox": [
+            173,
+            382,
+            825,
+            479
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8b036bb58c829377cc77f9e4691b35daa32ebca4333a0bea8efcf79b5ecbe7b2.jpg",
+        "text": "$$\n\\mathbf { o } _ { i } = \\mathrm { s o f t m a x } ( \\mathbf { W } \\mathbf { h } _ { i } ^ { ( p r e d ) } + \\alpha _ { i } \\mathbf { v } ^ { a } + \\varphi _ { i } \\mathbf { v } ^ { f } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            357,
+            487,
+            640,
+            508
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\alpha _ { i } , \\varphi _ { i } \\in \\{ 0 , 1 \\}$ are binary variables indicating the topological decisions and $\\mathbf { v } ^ { a } , \\mathbf { v } ^ { f }$ are learnable offset parameters. During training, we use gold-truth values in (7), i.e. $\\alpha _ { i } = 1$ if node $i$ has children and $\\varphi _ { i } = 1$ if it has a succeeding sibling. During testing, these values are obtained from $p ^ { a } , p ^ { f }$ by sampling or beam-search. A schematic representation of the internal structure of a DRNN cell and the flow of information in a tree are shown in Figure 1. ",
+        "bbox": [
+            174,
+            517,
+            825,
+            587
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 TRAINING DRNNS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            606,
+            348,
+            619
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We train DRNNs with (reverse) back-propagation through structure (BPTS) (Goller & Kuechler, 1996). In the forward pass, node outputs are computed in a top-down fashion on the structureunrolled version of the network, following the natural3 dependencies of the tree. We obtain error signal at the node level from the two types of prediction: label and topology. For the former, we compute cross-entropy loss of $\\mathbf { o } _ { i }$ with respect to the true label of the node $\\mathbf { x } _ { i }$ . For the topological values $p _ { i } ^ { a }$ and $p _ { i } ^ { f }$ we compute binary cross entropy loss with respect to gold topological indicators $\\alpha _ { i } , \\varphi _ { i } \\in \\{ 0 , 1 \\}$ . In the backward pass, we proceed in the reverse (bottom-up) direction, feeding into every node the gradients received from child and sibling nodes and computing internally gradients with respect to both topology and label prediction. Further details on the backpropagation flow are provided in the Appendix. ",
+        "bbox": [
+            173,
+            632,
+            825,
+            773
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Note that the way BPTS is computed implies and underlying decoupled loss function ",
+        "bbox": [
+            176,
+            780,
+            730,
+            795
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ac3b64ae4d5b4aeb2788a5b13d2c513a71dde2539123b9d0fa45fdebfff7cd37.jpg",
+        "text": "$$\n{ \\mathcal { L } } ( { \\widehat { \\mathbf { x } } } ) = \\sum _ { i \\in \\mathcal { V } } { \\mathcal { L } } ^ { l a b e l } ( \\mathbf { x } _ { i } , { \\widehat { \\mathbf { x } } } _ { i } ) + { \\mathcal { L } } ^ { t o p o } ( \\mathbf { p } _ { i } , { \\widehat { \\mathbf { p } } } _ { i } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            356,
+            803,
+            640,
+            837
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The decoupled nature of this loss allows us to weigh these two objectives differently, to emphasize either topology or label prediction accuracy. Investigating the effect of this is left for future work. ",
+        "bbox": [
+            174,
+            843,
+            823,
+            872
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/fa6bf02ca4eb87925feb86a96cfa41b88c2eb0fa6f09d54cf324aab88035b0f8.jpg",
+        "image_caption": [
+            "Figure 2: Trees generated by the DRNN decoder trained on subset of size $N$ of the synthetic dataset, for a test example with description “ROOT B W F J V”. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            103,
+            821,
+            179
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "As is common with sequence generation, during training we perform teacher forcing: after predicting the label of a node and its corresponding loss, we replace it with its gold value, so that children and siblings receive the correct label for that node. Analogously, we obtain the probabilities $p ^ { a }$ and $p ^ { f }$ , compute their loss, and replace them for ground truth variables $\\alpha _ { i } , \\varphi _ { i }$ for all downstream computations. Addressing this exposure bias by mixing ground truth labels with model predictions during training (Venkatraman et al., 2015) or by incremental hybrid losses (Ranzato et al., 2016) is left as an avenue for future work. ",
+        "bbox": [
+            174,
+            246,
+            825,
+            343
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            364,
+            326,
+            380
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 SYNTHETIC TREE RECOVERY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            396,
+            415,
+            410
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In our first set of experiments we evaluate the effectiveness of the proposed architecture to recover trees from flattened string representations. For this, we first generate a toy dataset consisting of simple labeled trees. To isolate the effect of label content from topological prediction, we take a small vocabulary consisting of the 26 letters of the English alphabet. We generate trees in a top-down fashion, conditioning the label and topology of every node on the state of its ancestors and siblings. For simplicity, we use a Markovian assumption on these dependencies, modeling the probability of a node’s label as depending only on the label of its parent and the last sibling generated before it (if any). Conditioned on these two inputs, we model the label of the node as coming from a multinomial distribution over the alphabet with a dirichlet prior. To generate the topology of the tree, we model the probability of a node having children and a next-sibling as depending only on its label and the depth of the tree. For each tree we generate a string representation by traversing it in breadth-first preorder, starting from the root. The labels of the nodes are concatenated into a string in the order in which they were visited, resulting in a string of $| \\tau |$ symbols. We create a dataset of 5,000 trees with this procedure, and split it randomly into train, validation and test sets (with a $8 0 \\% , 1 0 \\% , 1 0 \\%$ split). Further details on the construction of this dataset are provided in the Appendix. ",
+        "bbox": [
+            174,
+            421,
+            825,
+            628
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The task consists of learning a mapping from strings to trees, and using this learned mapping to recover the tree structure of the test set examples, given only their flattened representation. To do so, we use an encoder-decoder framework, where the strings are mapped to a fixed-size vector representation using a recurrent neural network. For the decoder, we use a DRNN with LSTM modules, which given the encoded representation generates a tree. We choose hyper-parameters with cross-validation. Full training details are provided in the Appendix. ",
+        "bbox": [
+            174,
+            636,
+            825,
+            719
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Measuring performance only in terms of exact recovery would likely yield near-zero accuracies for most trees. Instead, we opt for a finer-grained metric of tree similarity that gives partial credit for correctly predicted subtrees. Treating tree generation as a retrieval problem, we evaluate the quality of the predicted tree in terms of the precision and recall of recovering nodes and edges present in the gold tree. Thus, we penalize both missing and superfluous components. As baseline, we induce a probabilistic context-free grammar (PCFG) on the full training data and use it to parse the test sentences. Note that unlike the DRNN, this parser has direct access to the sentence representation and thus its task is only to infer the tree structure on top of it, so this is indeed a strong baseline. ",
+        "bbox": [
+            174,
+            727,
+            825,
+            838
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Figure 3 shows the results on the test set. Training on the full data yields node and edge retrieval F1-Scores of $7 5 \\%$ and $7 1 \\%$ , respectively, the latter considerably above the baseline.4 This $4 \\%$ gap can be explained by correct nodes being generated in the wrong part of the tree, as in the example in ",
+        "bbox": [
+            174,
+            844,
+            825,
+            887
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/52d37a6efb263a4c5b33630089f95cc5893e7e3496a04c264b290de2d64d54cc.jpg",
+        "image_caption": [
+            "Figure 3: Left: F1-Score for models trained on randomly sampled subsets of varying size, averaged over 5 repetitions. Right: Node (first column) and edge (second) precision as a function of tree size. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            104,
+            816,
+            217
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/7b875204bc878bbfd26edbb3ab21a5df5bdab181ce0989b8dea5b0b05d98929c.jpg",
+        "image_caption": [
+            "Figure 4: Node and edge precision as a function of tree depth (left figure) and width (right). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            280,
+            816,
+            378
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Figure 2. The second plot in Figure 3 shows that although small trees are recovered more accurately, precision decays slowly with tree size, with depth accounting for the largest effect (Figure 4). ",
+        "bbox": [
+            173,
+            435,
+            825,
+            464
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 MAPPING SENTENCES TO FUNCTIONAL PROGRAMS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            484,
+            566,
+            497
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Tree structures arise naturally in the context of programs. A typical compiler takes human-readable source code (expressed as sequences of characters) and transforms it into an executable abstract syntax tree (AST). Source code, however, is already semi-structured. Mapping natural language sentences directly into executable programs is an open problem, which has received considerable interest in the natural language processing community (Kate et al., 2005; Branavan et al., 2009). ",
+        "bbox": [
+            174,
+            511,
+            825,
+            580
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The IFTTT dataset (Quirk et al., 2015) is a simple testbed for language-to-program mapping. It consists of if-this-then-that programs (called recipes) crawled from the IFTTT website5, paired with natural language descriptions of their purpose. The recipes consist of a trigger and an action, each defined in terms of a channel (e.g. “Facebook”), a function (e.g. “Post a status update”) and potentially arguments and parameters. An example of a recipe and its description are shown in Figure 5. The data is user-generated and extremely noisy, which makes the task significantly challenging. ",
+        "bbox": [
+            173,
+            587,
+            825,
+            671
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/0f9ce1e2f1525e67ee95093f4be26f483a821b88a8a13e1cfd8b46e3af4990bf.jpg",
+        "image_caption": [
+            "Figure 5: Example recipe from the IFTTT dataset. The description (above) is a user-generated natural language explanation of the if-this-then-that program (below). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            238,
+            747,
+            764,
+            876
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/8c5dd9696cf2044c2430f51fa46d93a4ab86884ad33e535ca47d7c75c3ccca33.jpg",
+        "table_caption": [
+            "Table 1: Results on the IFTTT task. Left: non-English and unintelligible examples removed (2,262 recipes). Right: examples for which at least $^ { 3 + }$ humans agree with gold (758 recipes). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>Channel</td><td>+Func</td><td>F1</td></tr><tr><td>retrieval</td><td>36.8</td><td>25.4</td><td>49.0</td></tr><tr><td>phrasal</td><td>27.8</td><td>16.4</td><td>39.9</td></tr><tr><td>sync</td><td>26.7</td><td>15.4</td><td>37.6</td></tr><tr><td>classifier</td><td>64.8</td><td>47.2</td><td>56.5</td></tr><tr><td>posclass</td><td>67.2</td><td>50.4</td><td>57.7</td></tr><tr><td>SEQ2SEQ</td><td>68.8</td><td>50.5</td><td>60.3</td></tr><tr><td>SEQ2TREE</td><td>69.6</td><td>51.4</td><td>60.4</td></tr><tr><td>GRU-DRNN</td><td>70.1</td><td>51.2</td><td>62.7</td></tr><tr><td>LSTM-DRNN</td><td>74.9</td><td>54.3</td><td>65.2</td></tr></table>",
+        "bbox": [
+            196,
+            141,
+            480,
+            301
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/253d0b047c7f5f301e089a4758d96a0ea0be3508d8155fbe2e923801b639a664.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>Channel</td><td>+Func</td><td>F1</td></tr><tr><td>retrieval</td><td>43.3</td><td>32.3</td><td>56.2</td></tr><tr><td>phrasal</td><td>37.2</td><td>23.5</td><td>45.5</td></tr><tr><td>sync</td><td>36.5</td><td>23.5</td><td>45.5</td></tr><tr><td>classifier</td><td>79.3</td><td>66.2</td><td>65.0</td></tr><tr><td>posclass</td><td>81.4</td><td>71.0</td><td>66.5</td></tr><tr><td>SEQ2SEQ</td><td>87.8</td><td>75.2</td><td>73.7</td></tr><tr><td>SEQ2TREE</td><td>89.7</td><td>78.4</td><td>74.2</td></tr><tr><td>GRU-DRNN</td><td>89.9</td><td>77.6</td><td>74.1</td></tr><tr><td>LSTM-DRNN</td><td>90.1</td><td>78.2</td><td>77.4</td></tr></table>",
+        "bbox": [
+            519,
+            141,
+            802,
+            303
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We approach this task using an encoder-decoder framework. We use a standard RNN encoder, either an LSTM or a GRU (Cho et al., 2014), to map the sentence to a vector representation, and we use a DRNN decoder to generate the AST representation of the recipe. We use the original data split, which consists of 77,495 training, 5,171 development and 4,294 test examples. For evaluation, we use the same metrics as Quirk et al. (2015), who note that computing exact accuracy on such a noisy dataset is problematic, and instead propose to evaluate the generated AST in terms of F1-score on the set of recovered productions. In addition, they compute accuracy at the channel level (i.e. when both channels are predicted correctly) and at the function level (both channels and both functions predicted correctly). ",
+        "bbox": [
+            174,
+            330,
+            825,
+            457
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We compare our methods against the various extraction and phrased-based machine translation baselines of Quirk et al. (2015) and the the methods of Dong & Lapata (2016): SEQ2SEQ, a sequenceto-sequence model trained on flattened representations of the AST, and SEQ2TREE, a token-driven hierarchical RNN. Following these two works, we report results on two noise-filtered subsets of the data: one with all non-English and unintelligible recipes removed and the other one with recipes for which at least three humans agreed with the gold AST. The results are shown in Table 1. In both subsets, DRNNs perform on par or above previous approaches, with LSTM-DRNN achieving significantly better results. The improvement is particularly evident in terms of F1-score, which is the only metric used by previous approaches that measures global tree reconstruction accuracy. To better understand the quality of the predicted trees beyond the function level (i.e. (b) in Figure 5), we computed node accuracy on the arguments level. Our best performing model, LSTM-DRNN, achieves a Macro F1 score of $51 \\%$ (0.71 precision, 0.40 recall) over argument nodes, which shows that the model is reasonably successful at predicting structure even beyond depth three. The best performing alternative model, SEQ2TREE, achieves a corresponding F1 score of $46 \\%$ . ",
+        "bbox": [
+            173,
+            463,
+            825,
+            657
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.3 MACHINE TRANSLATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            678,
+            388,
+            693
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In our last set of experiments, we offer a qualitative evaluation DRNNs in the context of machine translation. Obtaining state-of-the-art results in machine translation requires highly-optimized architectures and large parallel corpora. This is not our goal. Instead, we investigate whether decoding with structure can bring benefits to a task traditionally approached as a sequence-to-sequence problem. For this reason, we consider a setting with limited data: a subset of the WMT14 dataset consisting of about 50K English French sentence pairs (see the Appendix for details) along with dependency parses of the target (English) side. ",
+        "bbox": [
+            173,
+            705,
+            825,
+            803
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We train a sequence-to-tree model using an LSTM encoder and a DRNN decoder as in the previous experiments. A slight modification here is that we distinguish left and right children in the tree, using two symmetric width-modules $g _ { L } ^ { f } , g _ { R } ^ { f }$ that produce children from the parent outwards. With this, children are lexically ordered, and therefore trees can be easily and un-ambiguously projected back into sentences. We compare our model against a sequence-to-sequence architecture of similar complexity (in terms of number of parameters) trained on the same data using the optimized OpenNMT library (Klein et al., 2017). For decoding, we use a simple best-of-k sampling scheme for our model, and beam search for the SEQ2SEQ models. ",
+        "bbox": [
+            174,
+            809,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/9465c0cc274f78abfc2b883af117a313f8ec839f97253b62a455ebde7c7598c6.jpg",
+        "image_caption": [
+            "Figure 6: Likelihood change under target structural perturbation. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            104,
+            383,
+            244
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/04870c696851a4c7893d4c81aa82d4fefbdf5db5fc42f0280948865fcf71745e.jpg",
+        "table_caption": [
+            "Table 2: Translations at different resolutions (size constraints imposed during decoding) for two example sentences. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Source</td><td>“ produit différentes réponses qui changent avec le temps selon nos expériences et nos relations ”</td><td>“je ne sais jamais quoi dire dans ces cas la&quot;</td></tr><tr><td>SEQ2SEQ:</td><td></td><td></td></tr><tr><td>l=1</td><td>a</td><td>I</td></tr><tr><td>l=4</td><td>with the different actions</td><td>Ido</td></tr><tr><td>=8</td><td>with the different actions who change with</td><td>I do not know what to say</td></tr><tr><td>DRNN:</td><td></td><td></td></tr><tr><td>d=1</td><td>answers</td><td>know</td></tr><tr><td>d=2</td><td>different answers change</td><td>but i do not know</td></tr><tr><td>d=3</td><td>product the different answers change .</td><td>but i do not know to say</td></tr></table>",
+        "bbox": [
+            405,
+            106,
+            818,
+            250
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "First, we analyze the quality of translations as a function of the maximum allowed target sentence “size”. The notion of size for a sequence decoder is simply the length while for DRNN we use depth instead so as to tap into the inherent granularity at which sentences can be generated from this architecture. Two such examples are shown in Table 2. Since DRNN topology has been trained to mimic dependency parses top-down, the decoder tends to first generate the fundamental aspects of the sentence (verb, nouns), leaving less important refinements for deeper structures down in the tree. The sequence decoder, in contrast, is trained for left-to-right sequential generation, and thus produces less informative translations under max-length restrictions. ",
+        "bbox": [
+            174,
+            315,
+            825,
+            426
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In our second experiment we investigate the decoders’ ability to entertain natural paraphrases of sentences. If we keep the semantic content of a sentence fixed and only change its grammatical structure, it is desirable that the decoder would assign nearly the same likelihood to the new sentence. One way to assess this invariance is to compare the relative likelihood that the model assigns to the gold sentence in comparison to its paraphrase. To test this, we take 50 examples from the WMT test split and manually generate paraphrases with various types of structural alterations (see details in the Appendix). For each type of decoder, we measure the relative change (in absolute value) of the log-likelihood resulting from the perturbation. All the models we compare have similar standard deviation $( 4 0 \\pm 2 0 )$ of log-likelihood scores over these examples, so the relative changes in the log-likelihood remain directly comparable. For each architecture we train two versions of different sizes, where the sizes are balanced in terms of the number of parameters across the architectures. The results in Figure 6 show that DRNN’s exhibit significantly lower log-likelihood change, suggesting that, as language models, they are more robust to natural structural variation than their SEQ2SEQ counterparts. ",
+        "bbox": [
+            174,
+            434,
+            825,
+            627
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 DISCUSSION AND FUTURE WORK ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            647,
+            485,
+            664
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We have presented doubly recurrent neural networks, a natural extension of (sequential) recurrent architectures to tree-structured objects. This architecture models the information flow in a tree with two separate recurrent modules: one carrying ancestral information (received from parent and passed on to offspring) and the other carrying fraternal information (passed from sibling to sibling). The topology of the tree is modeled explicitly and separately from the label prediction, with modules that given the state of a node predict whether it has children and siblings. ",
+        "bbox": [
+            174,
+            679,
+            823,
+            763
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The experimental results show that the proposed method is able to predict reasonable tree structures from encoded vector representations. Despite the simple structure of the IFTTT trees, the results on that task suggest a promising direction of using DRNNs for generating programs or executable queries from natural language. On the other hand, the results on the toy machine translation task show that even when used to generate sequences, DRNN’s exhibit desirable properties, such as invariance over structural modifications and the ability to perform coarse-to-fine decoding. In order to truly use this architecture for machine translation, the approach must be scaled by resorting to batch processing in GPU. This is possible since forward and backward propagation are computed sequentially along tree traversal paths so that inputs and hidden states of parents and siblings can be grouped into tensors and operated in batch. We leave this as an avenue for future work. ",
+        "bbox": [
+            174,
+            770,
+            825,
+            909
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGEMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            104,
+            334,
+            117
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "DA-M acknowledges support from a CONACYT fellowship. The authors would like to thank the anonymous reviewers for their constructive comments. ",
+        "bbox": [
+            174,
+            127,
+            823,
+            156
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES   \nSrk Branavan, Harr Chen, Luke S. Zettlemoyer, and Regina Barzilay. Reinforcement learning for mapping instructions to actions. Proc. Jt. Conf. 47th Annu. Meet. ACL 4th Int. Jt. Conf. Nat. Lang. Process. AFNLP Vol. 1-Volume 1, (August):82–90, 2009. ISSN 1742206X. doi: 10.3115/ 1687878.1687892.   \nDanqi Chen and Christopher D Manning. A Fast and Accurate Dependency Parser using Neural Networks. Proc. 2014 Conf. Empir. Methods Nat. Lang. Process., (i):740–750, 2014. URL https://cs.stanford.edu/{˜}danqi/papers/emnlp2014.pdf.   \nKyunghyun Cho, Bart van Merrienboer, Dzmitry Bahdanau, and Yoshua Bengio. On the Properties of Neural Machine Translation: Encoder–Decoder Approaches. Proc. SSST-8, Eighth Work. Syntax. Semant. Struct. Stat. Transl., pp. 103–111, 2014. URL http://arxiv.org/pdf/ 1409.1259v2.pdf.   \nLi Dong and Mirella Lapata. Language to Logical Form with Neural Attention. In ACL, pp. 33–43, 2016. doi: 10.18653/v1/P16-1004. URL http://arxiv.org/abs/1601.01280.   \nGottlob Frege. Uber Sinn und Bedeutung. ¨ Zeitschrift fur Philos. und Philos. Krit. ¨ , (1):25–50, 1892.   \nChristoph Goller and Andreas Kuechler. Learning task-dependent distributed representations by backpropagation through structure. In Int. Conf. Neural Networks, pp. 347–352, 1996. ISBN 0-7803-3210-5. doi: 10.1109/ICNN.1996.548916.   \nSepp Hochreiter and Jurgen Jurgen Schmidhuber. Long short-term memory. ¨ Neural Comput., 9(8): 1–32, 1997. ISSN 0899-7667. doi: 10.1162/neco.1997.9.8.1735.   \nRj Kate, Yw Wong, and Rj Mooney. Learning to transform natural to formal languages. In Proc. Natl. Conf. Artif. Intell., volume 20, pp. 1062–1068, 2005. ISBN 1-57735-236-x. URL http: //www.aaai.org/Library/AAAI/2005/aaai05-168.php.   \nDiederik Kingma and Jimmy Ba. Adam: A Method for Stochastic Optimization. Int. Conf. Learn. Represent., pp. 1–13, 2014. URL http://arxiv.org/abs/1412.6980.   \nEliyahu Kiperwasser and Yoav Goldberg. Easy-First Dependency Parsing with Hierarchical Tree LSTMs. TACL, 2016. URL https://www.transacl.org/ojs/index.php/tacl/ article/viewFile/798/208.   \nG. Klein, Y. Kim, Y. Deng, J. Senellart, and A. M. Rush. OpenNMT: Open-Source Toolkit for Neural Machine Translation. ArXiv e-prints, 2017.   \nChristopher D. Manning, Mihai Surdeanu, John Bauer, Jenny Finkel, Steven J. Bethard, and David McClosky. The Stanford CoreNLP natural language processing toolkit. In Association for Computational Linguistics (ACL) System Demonstrations, pp. 55–60, 2014. URL http://www.aclweb.org/anthology/P/P14/P14-5010.   \nJeffrey Pennington, Richard Socher, and Christopher D Manning. GloVe: Global Vectors for Word Representation. In Proc. 2014 Conf. Empir. Methods Nat. Lang. Process., 2014.   \nChris Quirk, Raymond Mooney, and Michel Galley. Language to Code: Learning Semantic Parsers for If-This-Then-That Recipes. ACL-IJCNLP, (July):878–888, 2015. URL http: //www.aclweb.org/anthology/P15-1085.   \nMarc’Aurelio Ranzato, Sumit Chopra, Michael Auli, and Wojciech Zaremba. Sequence Level Training with Recurrent Neural Networks. In ICLR, pp. 1–15, 2016. URL http://arxiv.org/ abs/1511.06732.   \nR Socher and Cc Lin. Parsing natural scenes and natural language with recursive neural networks. In EMNLP, pp. 129–136, 2011. ISBN 9781450306195. doi: 10.1007/978-3-540-87479-9.   \nRichard Socher, Brody Huval, Christopher D Manning, and Andrew Y Ng. Semantic Compositionality through Recursive Matrix-Vector Spaces. In EMNLP, number Mv, pp. 1201–1211, 2012. ISBN 9781937284435.   \nRichard Socher, Alex Perelygin, and Jy Wu. Recursive deep models for semantic compositionality over a sentiment treebank. Proc. . . . , pp. 1631–1642, 2013. ISSN 1932-6203. doi: 10.1371/ journal.pone.0073791.   \nIlya Sutskever, Oriol Vinyals, and Quoc V. Le. Sequence to sequence learning with neural networks. In NIPS, pp. 9, 2014. ISBN 1409.3215. URL http://arxiv.org/abs/1409.3215.   \nKai Sheng Tai, Richard Socher, and Christopher D. Manning. Improved Semantic Representations From Tree-Structured Long Short-Term Memory Networks. In Proc. 53rd Annu. Meet. Assoc. Comput. Linguist. 7th Int. Jt. Conf. Nat. Lang. Process., pp. 1556–1566, 2015. ISBN 9781941643723. URL http://arxiv.org/abs/1503.0075.   \nArun Venkatraman, Martial Hebert, and J Andrew Bagnell. Improving Multi-step Prediction of Learned Time Series Models. Twenty-Ninth AAAI Conf. Artif. Intell., pp. 3024–3030, 2015.   \nOrioi Vinyals and Quoc V. Le. A Neural Conversational Model. arXiv, 37, 2015.   \nRonald J. Williams and David Zipser. Gradient-based learning algorithms for recurrent networks and their computational complexity. Back-propagation Theory, Archit. Appl., pp. 433–486, 1995. doi: 10.1080/02673039508720837.   \nWojciech Zaremba, Ilya Sutskever, and Oriol Vinyals. Recurrent Neural Network Regularization. ICLR, pp. 1–8, 2015. URL http://arxiv.org/abs/1409.2329.   \nXingxing Zhang, Liang Lu, and Mirella Lapata. Top-down Tree Long Short-Term Memory Networks. In NAACL-HLT-2016, pp. 310–320, 2016. ",
+        "bbox": [
+            171,
+            152,
+            826,
+            914
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            169,
+            98,
+            828,
+            531
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A VARIATIONS ON TOPOLOGY PREDICTION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            547,
+            117
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Besides the topology prediction approach presented in Section 3.1, we experimented with two additional variations of the proposed doubly-recurrent neuron: (i) using tokens to trigger both depth and width termination (i.e. implicit topology prediction) and (ii) using tokens for width-stopping decision, but predict explicitly depth termination (single topology prediction). Recall that in the model proposed in Section 3.1 both decisions are explicit (double topology prediction). The neurons in each of these alternative formulations are depicted in Figure 7. In order to train these two alternative models, we add special stopping tokens to the vocabulary, and we pad the training with additional nodes labeled with this token. Besides requiring larger trees and resulting in slower training, we empirically observed alternatives (i) and (ii) to result in worse performance. We hypothesize that this has to do with the fact that when using token-based stopping, topological and label prediction decisions are confounded, which results in less efficient learning. ",
+        "bbox": [
+            173,
+            133,
+            825,
+            286
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/fe0f0fd4871bdb513ab5a6aa190a48b889988b7899c6549f4b7c99f2085ed282.jpg",
+        "image_caption": [
+            "Figure 7: A single unit in each of the three alternative versions of the doubly-recurrent neural network, for node $i$ with parent $p$ and sibling $s$ . Left: No explicit topology prediction, Middle: single (ancestral) topology prediction, Right: double (ancestral and fraternal) topology prediction. The top (left) incoming arrows represent the input and state received from the parent node (previous node, respectively). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            299,
+            813,
+            460
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "B TRAINING DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            573,
+            370,
+            588
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "B.1 BACKPROPAGATION WITH DRNN’S ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            603,
+            457,
+            619
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "During training, we do the forward pass over the trees in breadth-first preorder, feeding into every node an ancestral and a fraternal state. For computational efficiency, before passing on the ancestral state to the offspring, we update it through the RNN using the current node’s label, so as to avoid repeating this step for every child node. After the forward pass is complete, we compute label (cross-entropy) and topological (binary cross-entropy) loss for every node. In the backward pass, we compute in this order: ",
+        "bbox": [
+            174,
+            630,
+            825,
+            714
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "1. Gradient of the current node’s label prediction loss with respect to softmax layer parameters $\\mathbf { W } , \\mathbf { v } ^ { a } , \\mathbf { v } ^ { f } \\colon \\nabla _ { \\boldsymbol { \\theta } } \\mathcal { L } \\big ( \\mathbf { x } _ { i } , \\widehat { \\mathbf { x } } _ { i } \\big )$ .   \n2. Gradients of topological prediction variable loss with respect to sigmoid layer parameters: $\\nabla _ { \\theta } \\mathcal { L } ( p _ { i } ^ { a } , t _ { i } ^ { a } )$ and $\\nabla _ { \\theta } \\mathcal { L } ( p _ { i } ^ { \\dot { f } } , t _ { i } ^ { f } )$ .   \n3. Gradient of predictive state layer parameters with respect to $\\mathbf { h } ^ { ( p r e d ) }$ .   \n4. Gradient of predicted ancestral and fraternal hidden states with respect to $g ^ { f }$ and $g ^ { a }$ ’s parameters. ",
+        "bbox": [
+            210,
+            724,
+            825,
+            843
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "The gradients of the input ancestral and fraternal hidden states are then passed on to the previous sibling and parent. When nodes have more than one child, we combine gradients from multiple children by averaging them. This procedure is repeated until the root note is reached, after which a single (ancestral state) gradient is passed to the encoder. ",
+        "bbox": [
+            174,
+            854,
+            825,
+            911
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "B.2 MODEL SPECIFICATION AND TRAINING PARAMETERS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            589,
+            118
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The best parameters for all tasks are chosen by performance on the validation sets. We perform early stopping based on the validation loss. For the IFTTT task, we initialize word embeddings with pretrained GloVe vectors (Pennington et al., 2014). For both tasks we clip gradients when the absolute value of any element exceeds 5. We regularize with a small penalty $\\rho$ on the $l _ { 2 }$ norm of the parameters. We train all methods with ADAM (Kingma & Ba, 2014), with initial learning rate chosen by cross-validation. The parameter configurations that yielded the best results and were used for the final models are shown in Table 3. Details about the four models used for the machine translation task are shown in Table 4. ",
+        "bbox": [
+            173,
+            128,
+            825,
+            241
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/e2cbc7c738bef2a355ef5b6ee6ae77f170cd5997142bd56921427ea151abafd8.jpg",
+        "table_caption": [
+            "Table 3: Hyperparameter choice for DRNNs in the synthetic and IFTTT tasks "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Task</td><td>Encoder</td><td>Dim</td><td>Batch</td><td>Learning Rate</td><td>Regularization p</td></tr><tr><td>synthetic</td><td>LSTM</td><td>50</td><td>20</td><td>0.05</td><td>1×10-5</td></tr><tr><td>IFTTT</td><td>GRU</td><td>150</td><td>35</td><td>0.06</td><td>1×10-4</td></tr><tr><td>IFTTT</td><td>LSTM</td><td>150</td><td>35</td><td>0.05</td><td>5×10-4</td></tr></table>",
+        "bbox": [
+            254,
+            277,
+            743,
+            359
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/3619f4bb775402d7b716b1f403dd23f16312cbe4afff7f14151bdcfe4358cd1f.jpg",
+        "table_caption": [
+            "Table 4: Models used in the machine translation task. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Encoder</td><td>Decoder</td><td>Dim</td><td>RNN Layers</td><td>Batch</td></tr><tr><td>SEQ2SEQ (Small)</td><td>LSTM</td><td>LSTM</td><td>150</td><td>1</td><td>64</td></tr><tr><td>SEQ2SEQ (Large)</td><td>LSTM</td><td>LSTM</td><td>300</td><td>3</td><td>64</td></tr><tr><td>DRNN (Small)</td><td>LSTM</td><td>DRNN-GRU (Left-Right)</td><td>150</td><td>1</td><td>32</td></tr><tr><td>DRNN (Large)</td><td>LSTM</td><td>DRNN-GRU (Left-Right)</td><td>300</td><td>1</td><td>32</td></tr></table>",
+        "bbox": [
+            210,
+            406,
+            787,
+            505
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "C DATASET DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            535,
+            364,
+            551
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "C.1 SYNTHETIC TREE DATASET GENERATION ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            565,
+            500,
+            580
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We generate trees in a top-down fashion, conditioning the label and topology of every node on the state of its ancestors and siblings. For simplicity, we use a Markovian assumption on these dependencies, modeling the probability of a node’s label as depending only on the label of its parent $p ( i )$ and the last sibling $s ( i )$ generated before it (if any). Conditioned on these two inputs, we model the label of the node as coming from a multinomial distribution over the alphabet: ",
+        "bbox": [
+            173,
+            590,
+            825,
+            661
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e610f4ce4a5da76428ec6a0b3e91acfd5256014c9dba401ea10cc1658ced59fb.jpg",
+        "text": "$$\n\\begin{array} { r } { P ( w _ { i } \\mid \\mathcal { T } ) = P ( w \\mid w _ { p ( i ) } , w _ { s ( i ) } ) \\sim \\mathrm { M u l t i } \\big ( \\theta _ { w _ { p ( i ) } , w _ { s ( i ) } } \\big ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            320,
+            669,
+            678,
+            688
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "where $\\theta _ { w _ { p ( i ) } , w _ { s ( i ) } }$ are class probabilities drawn from a Dirichlet prior with parameter $\\alpha _ { v }$ . On the other hand, we denote by $b _ { i } ^ { a }$ the binary variable indicating whether node $i$ has descendants, and by $b _ { i } ^ { f }$ that indicating whether it has an ensuing sibling. We model these variables as depending only on the label of the current node and its position in the tree: ",
+        "bbox": [
+            174,
+            694,
+            825,
+            753
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/930ca0972f816a25353e0eb2e604ba7f04792e580fb4b29e775b2e460add2c57.jpg",
+        "text": "$$\n\\begin{array} { r l } & { P ( b _ { i } ^ { a } \\mid \\mathcal { T } ) = P ( b _ { i } ^ { a } \\mid w _ { i } , D _ { i } ) = \\mathrm { B e r n o u l l i } ( p _ { w _ { i } } ^ { a } \\cdot g ^ { a } ( D _ { i } ) ) } \\\\ & { P ( b _ { i } ^ { f } \\mid \\mathcal { T } ) = P ( b _ { i } ^ { f } \\mid w _ { i } , W _ { i } ) = \\mathrm { B e r n o u l l i } ( p _ { w _ { i } } ^ { f } \\cdot g ^ { f } ( W _ { i } ) ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            313,
+            760,
+            683,
+            803
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "where $D _ { i }$ is the depth of node $i$ and $W _ { i }$ its width, defined as its position among the children of its parent $p ( i )$ . Intuitively, we want to make $P ( b _ { i } ^ { a } = 1 | \\mathcal { T } )$ decrease as we go deeper and further along the branches of the tree, so as to control its growth. Thus, we model $g ^ { a }$ and $g ^ { f }$ as decreasing functions with geometric decay, namely $g ^ { a } ( D ) = ( \\gamma ^ { a } ) ^ { D }$ and $g ^ { f } ( W ) = ( \\gamma ^ { \\breve { f } } ) ^ { W }$ , with $\\gamma ^ { a } , \\gamma ^ { f } \\in ( 0 , \\overline { { 1 } } )$ . For the label-conditioned branching probabilities $P ( b _ { i } ^ { a } \\mid w _ { i } )$ and $P ( b _ { i } ^ { f } \\mid w _ { i } )$ , we use Bernoulli distributions with probabilities drawn from beta priors with parameters $( \\alpha ^ { a } , \\beta ^ { a } )$ and $( \\alpha ^ { f } , \\beta ^ { f } )$ , respectively. ",
+        "bbox": [
+            173,
+            805,
+            825,
+            897
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In summary, we use the following generative procedure to grow the trees: ",
+        "bbox": [
+            173,
+            902,
+            655,
+            917
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "1. For each $w _ { i } \\in V$ , draw $p _ { w _ { i } } ^ { a } \\sim \\mathbf { B e t a } ( \\alpha ^ { a } , \\beta ^ { a } )$ and $p _ { w _ { i } } ^ { f } \\sim \\mathrm { B e t a } ( \\alpha ^ { f } , \\beta ^ { f } )$ ",
+        "bbox": [
+            212,
+            102,
+            686,
+            119
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "2. For each pair $( w _ { i } , w _ { j } )$ draw $\\theta _ { w _ { i } , w _ { j } } \\sim \\operatorname { D i r } ( \\alpha ^ { V } )$ ",
+        "bbox": [
+            215,
+            125,
+            540,
+            140
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "3. While there is an unlabeled non-terminal node $i$ do: ",
+        "bbox": [
+            210,
+            143,
+            573,
+            157
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "• Sample a label for $i$ from $w ^ { * } \\sim P ( w | w _ { p ( i ) } , w _ { s ( i ) } ) = \\mathrm { M u l t i } \\big ( \\theta _ { w _ { p ( i ) } , w _ { s ( i ) } } \\big ) .$ . • Draw $b _ { a } \\sim P ( b ^ { a } | w ^ { * } , D ) = \\operatorname { B e r n o u l l i } ( \\gamma _ { a } ^ { D } \\cdot p _ { w ( i ) } ^ { a } )$ , where $D$ is the current depth. If $b ^ { a } = 1$ , generate an node $k$ , set $p ( k ) = i$ , and add it to the queue. • Draw $b _ { a } \\sim P ( b ^ { f } | w ^ { * } , D ) = \\operatorname { B e r n o u l l i } ( \\gamma _ { f } ^ { W } \\cdot p _ { w ( i ) } ^ { f } )$ , where $W$ is the current width. If $b ^ { f } = 1$ , generate an node $k$ , set $s ( k ) = i$ , and add it to the queue. ",
+        "bbox": [
+            248,
+            161,
+            826,
+            251
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Note that this generative process does create a dependence between the topology and content of the trees (since the variables $b ^ { a }$ and $b ^ { f }$ depend on the content of the tree via their dependence on the label of their corresponding node). However, the actual process by which labels and topological decision is generated relies on separate mechanisms. This is natural assumption which is reasonable to expect in practice. ",
+        "bbox": [
+            173,
+            261,
+            825,
+            330
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "The choice of prior parameters is done drawing inspiration from natural language parse trees. We want nodes to have low but diverse probabilities of generating children, so we seek a slow-decaying distribution with most mass allocated in values close to 0. For this, we use $( \\alpha ^ { a } , \\beta ^ { a } ) = ( 0 . 2 5 , 1 )$ . For sibling generation, we use $( \\alpha ^ { f } , \\beta ^ { f } ) = ( 7 , 2 )$ , which yields a distribution concentrated in values close to 1, so that nodes have on average a high and similar probability of producing siblings. Since we seek trees that are wider than they are deep, we use decay parameters $\\gamma _ { a } = 0 . 6 , \\gamma _ { f } = 0 . 9$ . Finally, we use a $\\alpha _ { v } = 1 0 \\cdot { \\bf 1 }$ for the parent-sibling probability prior, favoring non-uniform interactions. Using this configuration, we generate 5000 sentence-tree pairs, which we split into training (4000 examples), validation (500) and test (500) sets. The characteristics of the trees in the dataset are summarized in Table 5. ",
+        "bbox": [
+            173,
+            337,
+            825,
+            477
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/4bf06093e9a8d147efe7b26796bea28dce220fe40d779c71cac77f7eb86f04a7.jpg",
+        "table_caption": [
+            "Table 5: Synthetic tree dataset statistics. Tree size is measured in number of nodes, depth is the largest path from the root node to a leaf and width is the maximum number of children for any node in the tree. The values reported correspond to means with one standard deviation in parentheses. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Fold</td><td>Examples</td><td>Size</td><td>Depth</td><td>Width</td></tr><tr><td>train</td><td>4000</td><td>3.94 (3.38)</td><td>1.42 (0.66)</td><td>2.89 (1.71)</td></tr><tr><td>dev</td><td>500</td><td>4.13 (3.21)</td><td>1.46 (0.67)</td><td>2.91 (1.76)</td></tr><tr><td>test</td><td>500</td><td>3.64 (3.21)</td><td>1.32 (0.61)</td><td>2.80 (1.71)</td></tr></table>",
+        "bbox": [
+            289,
+            540,
+            709,
+            628
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "C.2 IFTTT ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            654,
+            266,
+            669
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "The IFTTT dataset comes with a script to generate the data by crawling and parsing the recipes. Unfortunately, by the time we ran the script many recipes had been removed or changed. We therefore resorted to the original dataset used by Quirk et al. (2015). We converted these recipes into our tree format, assigning a node to each element in the first three levels (channels, functions and arguments, see figure 5). For the parameters level, many recipes have sentences instead of single tokens, so we broke these up creating one node per word. The last two layers are therefore the most topologically diverse, whereas the structure of the first two layers is constant (all trees have channels and functions). A very small fraction $( < 1 \\%$ ) of trees that could not by parsed into our format was excluded from the dataset. ",
+        "bbox": [
+            173,
+            680,
+            825,
+            806
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Table 6 shows various statistics about the topological characteristics of the recipes in the IFTTT dataset. The middle columns show percentage of trees that contain nonempty arguments and parameters in trigger (IF) and action (THEN) branches. Almost all recipes have none empty arguments and parameters (and thus depth 4, excluding the root), and a lower percentage—but still a majority—has arguments and parameters on the trigger side too. The last two columns show tree statistics pertaining to the complexity of trees after conversion to our format. The distribution of tree sizes is mostly concentrated between 4 and 30 nodes, with a slow-decaying tail of examples above this range (see Figure 8). ",
+        "bbox": [
+            173,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/7b58b9dae4b0688406c6ea4e0d116afdbc68691ad8b168e8ea0bb5b7181c0cd3.jpg",
+        "table_caption": [
+            "Table 6: IFTTT dataset statistics. The middle columns show percentage of trees that contain nonempty arguments and parameters in trigger (IF) and action (THEN) branches. The last column shows average (with standard deviation) tree size and depth. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Fold</td><td rowspan=\"2\">Examples</td><td colspan=\"2\">Has args.(%)</td><td colspan=\"2\">Has params. (%)</td><td colspan=\"2\">Tree Size</td></tr><tr><td>Trigger</td><td>Action</td><td>Trigger</td><td>Action</td><td>#Nodes</td><td>Depth</td></tr><tr><td>train</td><td>67,444</td><td>69.10</td><td>98.46</td><td>65.47</td><td>96.77</td><td>16.93 (31.71)</td><td>3.99 (.13)</td></tr><tr><td>dev</td><td>4,038</td><td>69.44</td><td>98.46</td><td>66.42</td><td>96.31</td><td>16.55 (8.75)</td><td>3.99 (.11)</td></tr><tr><td>test</td><td>3,725</td><td>68.38</td><td>98.66</td><td>65.64</td><td>97.50</td><td>16.43 (8.18)</td><td>3.99 (.12)</td></tr></table>",
+        "bbox": [
+            181,
+            154,
+            816,
+            246
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/55bb3887b04062049bbba8bac0910b7d247e0a696c4c881323bbf4b64de0fedf.jpg",
+        "image_caption": [
+            "Figure 8: Tree size distribution in the IFTTT dataset. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            263,
+            816,
+            405
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Regarding the content of the trees, the labels of the nodes in the first two levels (channels and functions) come from somewhat reduced vocabularies: 111 and 434 unique symbols for the trigger branch, respectively, and 157 and 85 for the action branch. The lower layers of the tree have a much more diverse vocabulary, with about 60K unique tokens in total. On the source side, the vocabulary over the sentence descriptions is large too, with about 30K unique tokens. The average sentence size is 6.07 tokens, with $80 \\%$ of the sentences having at most 12 tokens. ",
+        "bbox": [
+            174,
+            463,
+            825,
+            546
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "C.3 MACHINE TRANSLATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            564,
+            390,
+            579
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Starting from a preprocessed6 $2 \\%$ sub-selection of the English-French section of the WMT14 dataset, we further prune down the data by keeping only sentences of length between 5 and 20 words, and for which every word is within the 20K most frequent. The reason for this is to simplify the task by keeping only common words and avoiding out-of-vocabulary tokens. After this filtering, we are left with 53,607, 918 and 371 sentences for train, validation and test sets. After tokenizing, we obtain dependency parses for the target (English) sentences using the Stanford CoreNLP toolkit (Manning et al., 2014). ",
+        "bbox": [
+            174,
+            590,
+            825,
+            688
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "For the perturbation experiments, we randomly selected 50 sentences from among those in the test that could be easily restructured without significantly altering their meaning. The type of alterations we perform are: subordinate clause swapping, alternative construction substitution, passive/active voice change. In doing this, we try to keep the number of added/deleted words to a minimum, to minimize vocabulary-induced likelihood variations. When inserting new words, be verify that they are contained in the original vocabulary of 20K words. In Table 7 we show a few examples of the source, original target and perturbed target sentences. ",
+        "bbox": [
+            174,
+            694,
+            825,
+            792
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/9a58cbf2be54cb430a7dd392b6b6dc02dedaa95bd75b0d8c4ad765cecd57c413.jpg",
+        "table_caption": [
+            "Table 7: Example structural perturbations for likelihood robustness experiments. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>source target perturbation</td><td>&quot;apres un accord de paix signe en 1992 elle est devenue un parti d opposition.&quot; “after a 1992 peace deal it became an opposition party.&quot; &quot;it became an opposition party after a 1992 peace deal.&quot;</td></tr><tr><td>source target perturbation</td><td>“cela représente environ 9 milliards de grains de mais.” “that&#x27;s about 9 billion individual kernels of corn.&quot; “this amounts to about 9 billion kernels of corn.&quot;</td></tr><tr><td>source target perturbation</td><td>“l&#x27;exercice de fonctions publiques est une question de service public.&quot; &quot;public office is about public service.&quot; &quot;the exercise of public functions is a matter of public service.</td></tr><tr><td>source target perturbation</td><td>“nous avons ainsi effectue depuis la fin de I&#x27;hiver dernier 64 interventions.” “hence we have carried out 64 operations since last winter.” “we have therefore carried out 64 operations since last winter.&quot;</td></tr><tr><td>source target perturbation</td><td>“on estime qu&#x27;un enfant sur 2OoO nés chaque année n&#x27;est ni un garcon ni une fille.&quot; “an estimated one in 2OoO children born each year is neither boy nor girl.&quot; “it is estimated that one in every 2OoO children born every year is neither a boy nor a girl.&quot;</td></tr></table>",
+        "bbox": [
+            173,
+            402,
+            883,
+            646
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "D ADDITIONAL EXAMPLE GENERATED TREES ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            102,
+            576,
+            118
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/6ba28271cf52cee43f0c4e3dd11a59ccb0005caae90ef97b95c7008d843db2a0.jpg",
+        "image_caption": [
+            "(a) Encoder sentence input: “ROOT P R C” "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            138,
+            821,
+            236
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/08ac7093d55b4ae55d9b93ce147a909d3a705737afac4a50d965b08cfa223ee9.jpg",
+        "image_caption": [
+            "(b) Encoder sentence input: “ROOT Z T Y Q” "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            275,
+            821,
+            396
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/8d5161627149fde344ba399ee222056bdf3e5d0f27180bd6677c1a398c106283.jpg",
+        "image_caption": [
+            "(c) Encoder sentence input: “ROOT K T V” "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            435,
+            821,
+            570
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/02c13889f526a643fe6f1c0153c559ca65cd2303de42436849d119efedbf9f52.jpg",
+        "image_caption": [
+            "(d) Encoder sentence input: “ROOT Q F V R G D A” ",
+            "Figure 9: Selected trees generated by the DRNN decoder from vector-encoded descriptions for test examples of the synthetic tree dataset. Trees in the same row correspond to predictions by models trained on randomly sampled subsets of size $N$ of the training split. We present cases for which the prediction is accurate (a,c) and cases for which it is not (b,d). Note how in (d) the model predicts many of the labels correctly, but confuses some of the dependencies (edges) in the tree. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            609,
+            821,
+            731
+        ],
+        "page_idx": 16
+    }
+]

parse/train/MJIve1zgR_/MJIve1zgR_.md

@@ -0,0 +1,328 @@
+# UNBIASED TEACHER FOR SEMI-SUPERVISED OBJECT DETECTION
+
+Yen-Cheng ${ \bf L i u ^ { 1 , 2 } }$ ∗, Chih-Yao $\mathbf { M } \mathbf { a } ^ { 2 }$ , Zijian $\mathbf { H e } ^ { 2 }$ , Chia-Wen ${ \bf K u o } ^ { 1 }$ , Kan Chen2, Peizhao Zhang2, Bichen $\mathbf { W } \mathbf { u } ^ { 2 }$ , Zsolt ${ \bf K i r a } ^ { 1 }$ , Peter Vajda2
+
+1Georgia Tech, 2Facebook Inc. {ycliu,cwkuo,zkira}@gatech.edu, {cyma,zijian,kanchen18,stzpz,wbc,vajdap}@fb.com
+
+# ABSTRACT
+
+Semi-supervised learning, i.e., training networks with both labeled and unlabeled data, has made significant progress recently. However, existing works have primarily focused on image classification tasks and neglected object detection which requires more annotation effort. In this work, we revisit the Semi-Supervised Object Detection (SS-OD) and identify the pseudo-labeling bias issue in SSOD. To address this, we introduce Unbiased Teacher1, a simple yet effective approach that jointly trains a student and a gradually progressing teacher in a mutually-beneficial manner. Together with a class-balance loss to downweight overly confident pseudo-labels, Unbiased Teacher consistently improved state-ofthe-art methods by significant margins on COCO-standard, COCO-additional, and $V O C$ datasets. Specifically, Unbiased Teacher achieves 6.8 absolute mAP improvements against state-of-the-art method when using $1 \%$ of labeled data on MS-COCO, achieves around $1 0 \mathrm { m A P }$ improvements against the supervised baseline when using only $0 . 5 , 1 , 2 \%$ of labeled data on MS-COCO.
+
+# 1 INTRODUCTION
+
+The availability of large-scale datasets and computational resources has allowed deep neural networks to achieve strong performance on a wide variety of tasks. However, training these networks requires a large number of labeled examples that are expensive to annotate and acquire. As an alternative, Semi-Supervised Learning (SSL) methods have received growing attention (Sohn et al., 2020a; Berthelot et al., 2020; 2019; Laine & Aila, 2017; Tarvainen & Valpola, 2017; Sajjadi et al., 2016; Lee, 2013; Grandvalet & Bengio, 2005). Yet, these advances have primarily focused on image classification, rather than object detection where bounding box annotations require more effort.
+
+In this work, we revisit object detection under the SSL setting (Figure 1): an object detector is trained with a single dataset where only a small amount of labeled bounding boxes and a large amount of unlabeled data are provided, or an object detector is jointly trained with a large labeled dataset as well as a large external unlabeled dataset. A straightforward way to address Semi-Supervised Object Detection (SS-OD) is to adapt from existing advanced semi-supervised image classification methods (Sohn et al., 2020a). Unfortunately, object detection has some unique characteristics that interact poorly with such methods. For example, the nature of class-imbalance in object detection tasks impedes the usage of pseudo-labeling. In object detection, there exists foreground-background imbalance and foreground classes imbalance (see Section 3.3). These imbalances make models trained in SSL settings prone to generate biased predictions. Pseudo-labeling methods, one of the most successful SSL methods in image classification (Lee, 2013; Sohn et al., 2020a), may thus be biased towards dominant and overly confident classes (background) while ignoring minor and less confident classes (foreground). As a result, adding biased pseudo-labels into the semi-supervised training aggravates the class-imbalance issue and introduces severe overfitting. As shown in Figure 2, taking a two-stage object detector as an example, there exists heavy overfitting on the fore
+
+![](images/3a4afc16fb87e7ab4911d64720067079773c86fa7d2001ddeb2589e799611b56.jpg)  
+Figure 1: (a) Illustration of semi-supervised object detection, where the model observes a set of labeled data and a set of unlabeled data in the training stage. (b) Our proposed model can efficiently leverage the unlabeled data and perform favorably against the existing semi-supervised object detection works, including CSD (Jeong et al., 2019) and STAC (Sohn et al., 2020b).
+
+# ground/background classification in the RPN and multi-class classification in the ROIhead (but not on bounding box regression).
+
+To overcome these issues, we propose a general framework – Unbiased Teacher: an approach that jointly trains a Student and a slowly progressing Teacher in a mutually-beneficial manner, in which the Teacher generates pseudo-labels to train the Student, and the Student gradually updates the Teacher via Exponential Moving Average (EMA)2, while the Teacher and Student are given different augmented input images (see Figure 3). Inside this framework, (i) we utilize the pseudo-labels as explicit supervision for both RPN and ROIhead and thus alleviate the overfitting issues in both RPN and ROIhead. (ii) We also prevent detrimental effects due to noisy pseudo-labels by exploiting the Teacher-Student dual models (see further discussion and analysis in Section 4.2). (iii) With the use of EMA training and the Focal loss (Lin et al., 2017b), we can address the pseudo-labeling bias problem caused by class-imbalance and thus improve the quality of pseudo-labels. As the result, our object detector achieves significant performance improvements.
+
+We benchmark Unbiased Teacher with SSL setting using the MS-COCO and PASCAL VOC datasets, namely COCO-standard, COCO-additional, and VOC. When using only $1 \%$ labeled data from MS-COCO (COCO-standard), Unbiased Teacher achieves 6.8 absolute mAP improvement against the state-of-the-art method, STAC (Sohn et al., 2020b). Unbiased Teacher consistently achieves around 10 absolute mAP improvements when using only $0 . 5 , 1 , 2 , 5 \%$ of labeled data compared to supervised baseline.
+
+We highlight the contributions of this paper as follows:
+
+• By analyzing object detectors trained with limited-supervision, we identify that the nature of class-imbalance in object detection tasks impedes the effectiveness of pseudo-labeling method on SS-OD task.   
+• We thus proposed a simple yet effective method, Unbiased Teacher, to address the pseudolabeling bias issue caused by class-imbalance existing in ground-truth labels and the overfitting issue caused by the scarcity of labeled data.   
+• Our Unbiased Teacher achieves state-of-the-art performance on SS-OD across COCOstandard, COCO-additional, and VOC datasets. We also provide an ablation study to verify the effectiveness of each proposed component.
+
+# 2 RELATED WORKS
+
+Semi-Supervised Learning. The majority of the recent SSL methods typically consist of (1) input augmentations and perturbations, and (2) consistency regularization. They regularize the model to be invariant and robust to certain augmentations on the input, which requires the outputs given the original and augmented inputs to be consistent. For example, existing approaches apply convention data augmentations (Berthelot et al., 2019; Laine & Aila, 2017; Sajjadi et al., 2016; Tarvainen &
+
+![](images/e1d662fcdba0482b7dbffc1b58afdd60f65be1a18a88c6c93f878f6025574475.jpg)  
+Figure 2: Validation Losses of our model and the model trained with labeled data only. When the labeled data is insufficient ( $1 \%$ and $5 \%$ ), RPN and ROIhead classifiers suffer from overfitting, while RPN and ROIhead regression do not suffer from overfitting. Our model can significantly alleviates the overfitting issue in classifiers and also improves the validation box regression loss.
+
+Valpola, 2017) to generate different transformations of the semantically identical images, perturb the input images along the adversarial direction (Miyato et al., 2018; Yu et al., 2019), utilize multiple networks to generate various views of the same input data (Qiao et al., 2018), mix input data to generate augmented training data and labels (Zhang et al., 2018; Yun et al., 2019; Guo et al., 2019; Hendrycks et al., 2020), or learn augmented prototypes in feature space instead of the image space (Kuo et al., 2020). However, the complexities in architecture design of object detectors hinder the transfer of existing semi-supervised techniques from image classification to object detection.
+
+Semi-Supervised Object Detection. Object detection is one of the most important computer vision tasks and has gained enormous attention (Lin et al., 2017a; He et al., 2017; Redmon & Farhadi, 2017; Liu et al., 2016). While existing works have made significant progress over the years, they have primarily focused on training object detectors with fully-labeled datasets. On the other hand, there exist several semi-supervised object detection works that focus on training object detector with a combination of labeled, weakly-labeled, or unlabeled data. This line of work began even before the resurgence of deep learning (Rosenberg et al., 2005). Later, along with the success of deep learning, Hoffman et al. (2014) and Gao et al. (2019) trained object detectors on data with bounding box labels for some classes and image-level class labels for other classes, enabling detection for categories that lack bounding box annotations. Tang et al. (2016) adapted the image-level classifier of a weakly labeled category (no bounding boxes) into a detector via similarity-based knowledge transfer. Misra et al. (2015) exploited a few sparsely labeled objects and bounding boxes in some video frames and localized unknown objects in the following videos.
+
+Unlike their settings, we follow the standard SSL setting and adapt it to the object detection task, in which the training contains a small set of labeled data and another set of completely unlabeled data (i.e., only images). In this setting, Jeong et al. (2019) proposed a consistency-based method, which enforces the predictions of an input image and its flipped version to be consistent. Sohn et al. (2020b) pre-trained a detector using a small amount labeled data and generates pseudo-labels on unlabeled data to fine-tune the pre-trained detector. Their pseudo-labels are generated only once and are fixed through out the rest of training. While they can improve the performance against the model trained on labeled data, imbalance issue is not considered in existing SS-OD works. In contrast, our method not only improve the pseudo-label generation model via teacher-student mutual learning regimen (Sec. 3.2) but address the crucial imbalance issue in generated pseudo-labels (Sec. 3.3).
+
+# 3 UNBIASED TEACHER
+
+Problem definitiof labeled images $D _ { s } = \{ \mathbf { \bar { x } } _ { i } ^ { s } , \pmb { y } _ { i } ^ { s } \} _ { i = 1 } ^ { N _ { s } }$ dress object detection in a sem and a set of unlabeled images $\bar { D _ { u } } \bar { = } \{ \pmb { x } _ { i } ^ { u } \} _ { i = 1 } ^ { N _ { u } }$ tting, where a setare available for training. and $N _ { u }$ are the number of supervised and unsupervised data. For each labeled image $\pmb { x } ^ { s }$ , the annotations $\boldsymbol { y } ^ { s }$ contain locations, sizes, and object categories of all bounding boxes.
+
+Overview. As shown in Figure 3, our Unbiased Teacher consists of two training stages, the BurnIn stage and the Teacher-Student Mutual Learning stage. In the Burn-In stage (Sec. 3.1), we simply train the object detector using the available supervised data to initialize the detector. At the beginning of the Teacher-Student Mutual Learning stage (Sec. 3.2), we duplicate the initialized detector into two models (Teacher and Student models). Our Teacher-Student Mutual Learning stage aims at evolving both Teacher and Student models via a mutual learning mechanism, where the Teacher generates pseudo-labels to train the Student, and the Student updates the knowledge it learned back to the Teacher; hence, the pseudo-labels used to train the Student itself are improved. Lastly, there exists class-imbalance and foreground-background imbalance problems in object detection, which impedes the effectiveness of semi-supervised techniques of image classification (e.g., pseudo-labeling) being used directly on SS-OD. Therefore, in Sec. 3.3, we also discuss how Focal loss (Lin et al., 2017b) and EMA training alleviate the imbalanced pseudo-label issue.
+
+![](images/b89dd1e2de99c64f3afd899e071ee73e67ed8a0064fecfe4297e088566767240.jpg)  
+Figure 3: Overview of Unbiased Teacher. Unbiased Teacher consists of two stages. Burn-In: we first train the object detector using available labeled data. Teacher-Student Mutual Learning consists of two steps. Student Learning: the fixed teacher generates pseudo-labels to train the Student, while Teacher and Student are given weakly and strongly augmented inputs, respectively. Teacher Refinement: the knowledge that the Student learned is then transferred to the slowly progressing Teacher via exponential moving average (EMA) on network weights. When the detector is trained until converge in the Burn-In stage, we switch to the Teacher-Student Mutual Learning stage.
+
+# 3.1 BURN-IN
+
+It is important to have a good initialization for both Student and Teacher models, as we will rely on the Teacher to generate pseudo-labels to train the Student in the later stage. To do so, we first use the available supervised data to optimize our model $\theta$ with the supervised loss $\mathcal { L } _ { s u p }$ . With the supervised data $D _ { s } = \{ \pmb { x } _ { i } ^ { s } , \pmb { y } _ { i } ^ { s } \} _ { i = 1 } ^ { N _ { s } }$ , the supervised loss of object detection consists of four losses: ithe RPN classification loss $\mathcal { L } _ { c l s } ^ { r p n }$ =1, the RPN regression loss $\mathcal { L } _ { r e g } ^ { r p n }$ , the ROI classification loss $\mathcal { L } _ { c l s } ^ { r o i }$ and the ROI regression loss $\mathcal { L } _ { r e g } ^ { r o i }$ (Ren et al., 2015),
+
+$$
+\mathcal { L } _ { s u p } = \sum _ { i } \mathcal { L } _ { c l s } ^ { r p n } ( \boldsymbol { x } _ { i } ^ { s } , \boldsymbol { y } _ { i } ^ { s } ) + \mathcal { L } _ { r e g } ^ { r p n } ( \boldsymbol { x } _ { i } ^ { s } , \boldsymbol { y } _ { i } ^ { s } ) + \mathcal { L } _ { c l s } ^ { r o i } ( \boldsymbol { x } _ { i } ^ { s } , \boldsymbol { y } _ { i } ^ { s } ) + \mathcal { L } _ { r e g } ^ { r o i } ( \boldsymbol { x } _ { i } ^ { s } , \boldsymbol { y } _ { i } ^ { s } ) .
+$$
+
+After Burn-In, we duplicate the trained weights $\theta$ for both the Teacher and the Student models $( \theta _ { t } \gets \theta , \theta _ { s } \gets \theta )$ . Starting from this trained detector, we further utilize the unsupervised data to improve the object detector via the following proposed training regimen.
+
+# 3.2 TEACHER-STUDENT MUTUAL LEARNING
+
+Overview. To leverage the unsupervised data, we introduce the Teacher-Student Mutual Learning regimen, where the Student is optimized by using the pseudo-labels generated from the Teacher, and the Teacher is updated by gradually transferring the weights of continually learned Student model. With the interaction between the Teacher and the Student, both models can evolve jointly and continuously to improve detection accuracy. With the improvement on detection accuracy, this also means that the Teacher generates more accurate and stable pseudo-labels, which we identify as one of the keys for large performance improvement compared to existing work (Sohn et al., 2020b). In another perspective, we can also regard the Teacher as the temporal ensemble of the Student models in different time steps. This aligns our observation that the accuracy of the Teacher is consistently higher than the Student. As noted in prior works (Tarvainen & Valpola, 2017; Xie et al., 2020), one crucial factor in improving the Teacher model is the diversity of Student models; we thus use the strongly augmented images as as input of the Student, but we use the weakly augmented images as input of the Teacher to provide reliable pseudo-labels.
+
+Student Learning with Pseudo-Labeling. To address the lack of ground-truth labels for unsupervised data, we adapt the pseudo-labeling method to generate labels for training the Student with unsupervised data. This follows the principle of existing successful examples in semi-supervised image classification task (Lee, 2013; Sohn et al., 2020a). Similar to classification-based methods, to prevent the consecutively detrimental effect of noisy pseudo-labels (i.e., confirmation bias or error accumulation), we first set a confidence threshold $\delta$ of predicted bounding boxes to filter lowconfidence predicted bounding boxes, which are more likely to be false positive samples.
+
+While the confidence threshold method have achieved tremendous success in the image classification, it is however not sufficient for object detection. This is because there also exist duplicated box predictions and imbalanced prediction issues in the SS-OD (we leave the discussion of the imbalanced prediction issue in Sec. 3.3). To address the duplicated boxes prediction issue, we remove the repetitive predictions by applying class-wise non-maximum suppression (NMS) before the use of confidence thresholding as performed in STAC (Sohn et al., 2020b).
+
+In addition, noisy pseudo-labels can affect the pseudo-label generation model (Teacher). As a result, we detach the Student and the Teacher. To be more specific, after obtaining the pseudo-labels from the Teacher, only the learnable weights of the Student model is updated via back-propagation.
+
+$$
+\theta _ { s } \xleftarrow \theta _ { s } + \gamma \frac { \partial ( \mathcal { L } _ { s u p } + \lambda _ { u } \mathcal { L } _ { u n s u p } ) } { \partial \theta _ { s } } , \quad \mathcal { L } _ { u n s u p } = \sum _ { i } \mathcal { L } _ { c l s } ^ { r p n } ( \pmb { x } _ { i } ^ { u } , \hat { \pmb { y } } _ { i } ^ { u } ) + \mathcal { L } _ { c l s } ^ { r o i } ( \pmb { x } _ { i } ^ { u } , \hat { \pmb { y } } _ { i } ^ { u } )
+$$
+
+Note that we do not apply unsupervised losses for the bounding box regression since the naive confidence thresholding is not able to filter the pseudo-labels that are potentially incorrect for bounding box regression (because the confidence of predicted bounding boxes only indicate the confidence of predicted object categories instead of the quality of bounding box locations (Jiang et al., 2018)).
+
+Teacher Refinement via Exponential Moving Average. To obtain more stable pseudo-labels, we apply EMA to gradually update the Teacher model. The slowly progressing Teacher model can be regarded as the ensemble of the Student models in different training iterations.
+
+$$
+\theta _ { t }  \alpha \theta _ { t } + ( 1 - \alpha ) \theta _ { s } .
+$$
+
+This approach has been shown to be effective in many existing works, e.g., ADAM optimization (Kingma & Ba, 2015), Batch Normalization (Ioffe & Szegedy, 2015), self-supervised learning (He et al., 2020; Grill et al., 2020), and SSL image classification (Tarvainen & Valpola, 2017), while we, for the first time, demonstrate its effectiveness also in alleviating pseudo-labeling bias issue for SS-OD (see next section).
+
+# 3.3 BIAS IN PSEUDO-LABEL
+
+Ideally, the methods based on pseudo-labels can address problems caused by the scarcity of labels, yet the inherent nature of imbalance in object detection tasks/datasets impedes the effectiveness of pseudo-labeling methods. As mentioned in (Oksuz et al., 2020), in object detection, there exists foreground-background imbalance (e.g., background instances accounts for $70 \%$ of all training instances) and foreground classes imbalance (e.g., human instances accounts for $30 \%$ of all foreground training instances in MS-COCO (Lin et al., 2014)). If standard cross-entropy is applied in the condition of insufficient training data, the model is likely prone to predict the dominant classes. This makes the prediction bias toward prevailing classes and leads to the class-imbalance issue in generated pseudo-labels. Relying on the biased pseudo-labels during training makes the imbalanced prediction issue even more severe. To address the imbalance issue in object detection, existing works have proposed several methods (Shrivastava et al., 2016; Lin et al., 2017b; Li et al., 2020).
+
+In this work, we consider a simple yet effective method; we replace the standard cross-entropy with the multi-class Focal loss (Lin et al., 2017b) for the multi-class classification of ROIhead classifier (i.e., $\mathcal { L } _ { c l s . } ^ { r o i }$ ). Focal loss is designed to put more loss weights on the samples with lower-confidence instances. As a result, it makes the model focus on hard samples, instead of the easier examples that are likely from dominant classes. Although the Focal loss is not widely used for vanilla supervised object detection settings (the accuracy of YOLOv3 (Redmon & Farhadi, 2018) even drops if the focal loss is applied), we argue that it is crucial for SS-OD due to the issue of biased pseudo-labels.
+
+Table 1: Experimental results on COCO-standard comparing with CSD (Jeong et al., 2019) and STAC (Sohn et al., 2020b). \*: we implement the CSD method and adapt it on the MS-COCO dataset. The results of $0 . 5 \%$ with STAC is from their released code.   
+
+<table><tr><td rowspan="2"></td><td colspan="5">COCO-standard</td></tr><tr><td>0.5%</td><td>1%</td><td>2%</td><td>5%</td><td>10%</td></tr><tr><td>Supervised</td><td>6.83 ± 0.15</td><td>9.05 ± 0.16</td><td>12.70 ± 0.15</td><td>18.47± 0.22</td><td>23.86±0.81</td></tr><tr><td>CSD*</td><td>7.41 ± 0.21 (+0.58)</td><td>10.51 ± 0.06 (+1.46)</td><td>13.93 ± 0.12 (+1.23)</td><td>18.63 ± 0.07 (+0.16)</td><td>22.46 ± 0.08 (-1.40)</td></tr><tr><td>STAC</td><td>9.78 ± 0.53 (+2.95)</td><td>13.97 ± 0.35 (+4.92)</td><td>18.25 ± 0.25 (+5.55)</td><td>24.38 ± 0.12 (+5.86)</td><td>28.64 ± 0.21 (+4.78)</td></tr><tr><td>Unbiased Teacher</td><td>16.94 ± 0.23 (+10.11)</td><td>20.75 ± 0.12 (+11.72)</td><td>24.30 ± 0.07 (+11.60)</td><td>28.27 ± 0.11 (+9.80)</td><td>31.50 ± 0.10 (+7.64)</td></tr></table>
+
+On the other hand, we also observe that the EMA training can also alleviate the imbalanced pseudolabeling biased issue due to the conservative property of the EMA training. To be more specific, with the EMA mechanism, the new Teacher model is regularized by the previous Teacher model, and this prevents the decision boundary from drastically moving toward the minority classes. In detail, the weights of the Teacher model can be represented as follows:
+
+$$
+\theta _ { t } ^ { i } = \hat { \theta } - \gamma \sum _ { k = 1 } ^ { i - 1 } ( 1 - \alpha ^ { - k + ( i - 1 ) } ) \frac { \partial ( \mathcal { L } _ { s u p } + \lambda _ { u } \mathcal { L } _ { u n s u p } ) } { \partial \theta _ { s } ^ { k } } ,
+$$
+
+where $\hat { \theta }$ is the model weight after the burn-in stage, $\theta _ { t } ^ { i }$ is the Teacher model weight in $i$ -th iteration, $\theta _ { s } ^ { k }$ is the Student model weight in $k$ -th iteration, $\gamma$ is the learning rate, and $\alpha$ is the EMA coefficient.
+
+The regularization of the previous Teacher model is equivalent to putting an additional small coefficient on the gradients on Student models in previous steps. With the slowly altered decision boundary (i.e., higher stability), the pseudo-labels of these unlabeled instances are less likely to change dramatically, and this prevents the decision boundary from moving toward minority classes (i.e., majority class bias). Thus, the EMA-trained Teacher model is beneficial for producing more stable pseudo-labels and addressing the class-imbalance issue in SS-OD.
+
+We note that the class-imbalance issue is crucial when using pseudo-labeling method to address semi-supervised or other low-label object detection tasks. There indeed exist other class-imbalance methods that can potentially improve the performance, but we leave this for future research.
+
+# 4 EXPERIMENTS
+
+Datasets. We benchmark our proposed method on experimental settings using MS-COCO (Lin et al., 2014) and PASCAL VOC (Everingham et al., 2010) following existing works (Jeong et al., 2019; Sohn et al., 2020b). Specifically, there are three experimental settings: (1) COCO-standard: we randomly sample 0.5, 1, 2, 5, and $10 \%$ of labeled training data as a labeled set and use the rest of the data as the training unlabeled set. (2) COCO-additional: we use the standard labeled training set as the labeled set and the additional COCO2017-unlabeled data as the unlabeled set. (3) VOC: we use the VOC07 trainval set as the labeled training set and the VOC12 trainval set as the unlabeled training set. Model performance is evaluated on the VOC07 test set.
+
+Implementation Details. For a fair comparison, we follow STAC (Sohn et al., 2020b) to use FasterRCNN with FPN (Lin et al., 2017a) and ResNet-50 backbone (He et al., 2016) as our object detectior, where the feature weights are initialized by the ImageNet-pretrained model, same as existing works (Jeong et al., 2019; Sohn et al., 2020b). We use confidence threshold $\delta = 0 . 7$ . For the data augmentation, we apply random horizontal flip for weak augmentation and randomly add color jittering, grayscale, Gaussian blur, and cutout patches for strong augmentations. Note that we do not apply any geometric augmentations, which are used in STAC. We use $A P _ { 5 0 : 9 5 }$ (denoted as mAP) as evaluation metric, and the performance is evaluated on the Teacher model. More training and implementation details can be found in the Appendix.
+
+# 4.1 RESULTS
+
+COCO-standard. We first evaluate the efficacy of our Unbiased Teacher on COCO-standard (Table 1). When there are only $0 . 5 \%$ to $1 0 \%$ of data labeled, our model consistently performs favorably against the state-of-the-art methods, CSD (Jeong et al., 2019) and STAC (Sohn et al., 2020b). It is worth noting that our model trained on $1 \%$ labeled data achieves $2 0 . 7 5 \%$ mAP, which is even higher than STAC trained on $2 \%$ labeled data (mAP $1 8 . 2 5 \%$ ), CSD trained on $5 \%$ labeled data (mAP $1 8 . 5 7 \%$ ), and the supervised baseline trained on $5 \%$ labeled data (mAP $1 8 . 4 7 \%$ ). We also observe that, as there are less labeled data, the improvements between our method and the existing approaches becomes larger. Unbiased Teacher consistently shows around 10 absolute mAP improvements when using less than $5 \%$ of labeled data compared to supervised method. We attribute the improvements to several crucial factors:
+
+Table 2: Experimental results on COCO-additional comparing with CSD (Jeong et al., 2019) and STAC (Sohn et al., 2020b). \*: we implement the CSD method and adapt it on the MS-COCO dataset. Note that 1x represents 90K training iterations, and $N \mathbf { x }$ represents $N { \times } 9 0 \mathrm { K }$ training iterations.   
+
+<table><tr><td rowspan="2"></td><td colspan="5">COCO-additional</td></tr><tr><td>Supervised (1x)</td><td>Supervised (3x)</td><td>CSD (3x)</td><td>STAC (6x)</td><td>Ours (3x)</td></tr><tr><td>AP50:95</td><td>37.63</td><td>40.20</td><td>38.82</td><td>39.21</td><td>41.30</td></tr></table>
+
+![](images/6a448004ebf6e555f29b1f5a65f89bf04374154ea1352f042dca80bbe487040d.jpg)  
+Figure 4: Pseudo-label improvement on (a) accuracy, (b) mIoU, and (c) number of bounding boxes in the case of $C O C O$ -standard $1 \%$ labeled data. We measure the (a) accuracy and (b) mIoU by comparing the ground-truth boxes and pseudo boxes. The Burn-In limit curves indicate the pseudoboxes obtained from the model right after the Burn-In stage without further refinement (i.e., the model trained on labeled data only). GT curve on the number of boxes figure indicates the averaged number of bounding boxes in the GT labels, and we showed that there are around 7 bounding boxes per image on average in MS-COCO. This result indicates our model can generate more accurate pseudo-labels after the Burn-In stage (i.e., 2k iterations).
+
+1) More accurate pseudo-labels. When leveraging the pseudo-labeling and consistency regularization between two networks (Teacher and Student in our case), it is critical to make sure pseudo-labels are accurate and reliable. Existing method attempts to do this by training the pseudo-label generation model using all the available labeled data and is completely frozen afterwards. In contrast, in our framework, our pseudo-label generation model (Teacher) continues to evolve gradually and smoothly via Teacher-Student Mutual Learning. This enables the Teacher to generate more accurate pseudo-labels as presented in Figure 4, which are properly exploited in the training of the Student.
+
+2) Class-imbalance on pseudo-labels. Our improvement also comes from both the use of the EMA and the Focal loss (Lin et al., 2017b), which addresses the class-imbalanced pseudo-labeling issue. As mentioned in Sec. 3.3, using more balanced pseudo-labels not only avoids the consecutive biased prediction problem but also benefits the predictions on the minority classes. Later in Sec. 4.2, we present the details of the ablation study on the EMA and the Focal loss.
+
+COCO-additional and VOC. In the previous section, we presented Unbiased Teacher can successfully leverage very small amounts of labeled data. We now aim to verify whether the model trained on $1 0 0 \%$ supervised data can be further improved by using additional unlabeled data. We thus consider COCO-additional and VOC and present the results in Table 1 and 3.
+
+In the case of COCO-additional (Table 2), compared with supervised only model, our model has a 1.10 absolute AP improvement. We also found a similar trend in the VOC experiment (Table 3). With VOC07 as labeled set and VOC12 as an additional unlabeled set, STAC shows 2.51 absolute mAP improvement with respect to the supervised model, whereas our model demonstrates 6.56 absolute mAP improvement. To further examine whether increasing the size of unlabeled data can further improve the performance, we follow CSD and STAC to use COCO20cls dataset3 as an additional unlabeled set. STAC shows 3.88 absolute mAP improvement, while our model achieves 8.21 absolute mAP improvement. These results demonstrate that our model can further improve the object detector trained on existing labeled datasets by using more unlabeled data. Note that, following STAC, we use a more challenging metric, $A P _ { 5 0 : 9 5 }$ , which averages the ten values over $A P _ { 5 0 }$ to $A P _ { 9 5 }$ since the metric of $A P _ { 5 0 }$ has been indicated as a saturated metric by the prior work (Cai & Vasconcelos, 2018; Sohn et al., 2020b).
+
+Table 3: Results on VOC comparing with CSD (Jeong et al., 2019) and STAC (Sohn et al., 2020b).   
+
+<table><tr><td></td><td>Backbone</td><td>Labeled</td><td>Unlabeled</td><td>AP50</td><td>AP50:95</td></tr><tr><td>Supervised (from Ours)</td><td>ResNet50-FPN</td><td>VOC07</td><td>None</td><td>72.63</td><td>42.13</td></tr><tr><td>CSD</td><td>ResNet101-R-FCN</td><td rowspan="3">VOC07</td><td rowspan="3">VOC12</td><td>74.70 (+2.07)</td><td>1</td></tr><tr><td>STAC</td><td>ResNet50-FPN ResNet50-FPN</td><td>77.45 (+4.82)</td><td>44.64 (+2.51)</td></tr><tr><td>Unbiased Teacher</td><td></td><td>77.37 (+4.74)</td><td>48.69 (+6.56)</td></tr><tr><td>CSD</td><td>ResNet101-R-FCN</td><td rowspan="3">VOC07</td><td>VOC12</td><td>75.10 (+2.47)</td><td>1</td></tr><tr><td>STAC</td><td>ResNet50-FPN</td><td>+</td><td>79.08 (+6.45)</td><td>46.01 (+3.88)</td></tr><tr><td>Unbiased Teacher</td><td>ResNet50-FPN</td><td>COC020cls</td><td>78.82 (+6.19)</td><td>50.34 (+8.21)</td></tr></table>
+
+![](images/be922bddd41d90b7e021568577d4b7ef678fa14785ed7eb5e97fec9efc6ebc76.jpg)  
+Figure 5: Ablation study on the EMA and the Focal loss in the case of COCO-standard $1 \%$ labeled data. (a) mAP of the models using the Focal loss or cross-entropy and applying the EMA or standard training. (b) Class empirical distribution (i.e., histogram) of pseudo-labels generated by each model and compute $\kappa \mathcal { L }$ -divergence between the ground-truth labels distribution and the pseudo-label distribution. Among these models, the model using the Focal loss and EMA training (i.e., green curve) achieves the best mAP with the most balanced pseudo-labels .
+
+# 4.2 ABLATION STUDY
+
+Effect of the EMA training. We first examine the effect of EMA training and present a comparison between our model with EMA and without EMA. Our model without EMA is where the model weights of Teacher and Student are shared during the training stage, and it implies the Teacher model is also updated when the student model is optimized by using unlabeled data and pseudolabels. Note that the state-of-the-art semi-supervised classification model, FixMatch (Sohn et al., 2020a) similarly shares the model weights of the Teacher and the Student models.
+
+From Figure 5, we observe that our model with EMA is superior to without EMA, and this trend can be found both in the model using the Focal loss and cross-entropy. To further analyze the diverged results, we visualize the class distribution of pseudo-labels generated by each model and measure the $\kappa \mathcal { L }$ -divergence between the ground-truth labels distribution and the pseudo-labels distribution. With the use of cross-entropy and standard training (i.e., without EMA training), the model generates the imbalanced pseudo-labels. To be more specific, the instances of most object categories in pseudolabels disappear, while only instances of specific object categories remain. We observe that using the EMA training can alleviate the imbalanced pseudo-labels issue and reduces the $\kappa \mathcal { L }$ -divergence from 1.7915 to 0.2482. On the other hand, we also observe that the model with EMA has a smoother learning curve compared with the model without EMA. This is because the model weight of the pseudo-label generation model (Teacher) is detached from the optimized model (Student). The pseudo-label generation model can thus prevent the detrimental effect caused by the noisy pseudolabels (e.g., false positive boxes) as we describe in Sec. 3.2.
+
+In sum, the EMA training has several advantages: it 1) prevents the imbalanced pseudo-labels issue caused by the imbalanced nature in low-labeled object detection tasks, 2) prevents the detrimental effect caused by the noisy pseudo-labels, and 3) the Teacher model can be regarded as the temporal ensembles model of Student models in different time steps.
+
+Effect of the Focal loss. In addition to the EMA training, we also verify the effectiveness of the Focal loss. As presented in Figure 5, the model using Focal loss can perform favorably against the model using cross-entropy. The model trained with the Focal loss can generate the pseudo-label which distribution is more similar to the distribution of ground-truth labels, and it can improve the $\kappa \mathcal { L }$ -divergence from 1.7915 (Cross entropy w/o EMA) to 0.2001 (Focal loss w/o EMA) and mAP from 13.42 to 17.85. When EMA training is applied, the $\kappa \mathcal { L }$ -divergence of the model with the Focal loss can be further improved from 0.2482 (Cross entropy w/ EMA) to 0.0851 (Focal loss w/ EMA) and mAP improve from 16.91 to 21.19. This confirms the effectiveness of the Focal loss in handling the class imbalance issues existed in the semi-supervised object detection. The reduction of $\kappa \mathcal { L }$ -divergence (i.e., better-fitting pseudo-label distributions to ground-truth label distributions) results in the mAP improvement.
+
+Other ablation studies. We also ablate the effects of the Burn-In stage, pseudo-labeling thresholding, EMA rates, and unsupervised loss weights in the Appendix.
+
+# 5 CONCLUSION
+
+In this paper, we revisit the semi-supervised object detection task. By analyzing the object detectors in low-labeled scenarios, we identify and address two major issues: overfitting and class imbalance. We proposed Unbiased Teacher — a unified framework consisting of a Teacher and a Student that jointly learn to improve each other. In the experiments, we show our model prevents pseudo-labeling bias issue caused by class imbalance and overfitting issue due to labeled data scarcity. Our Unbiased Teacher achieves satisfactory performance across multiple semi-supervised object detection datasets.
+
+# 6 ACKNOWLEDGMENTS
+
+Yen-Cheng Liu and Zsolt Kira were partly supported by DARPA’s Learning with Less Labels (LwLL) program under agreement HR0011-18-S-0044, as part of their affiliation with Georgia Tech.
+
+# REFERENCES
+
+David Berthelot, Nicholas Carlini, Ian Goodfellow, Nicolas Papernot, Avital Oliver, and Colin A Raffel. Mixmatch: A holistic approach to semi-supervised learning. In Advances in Neural Information Processing Systems (NeurIPS), pp. 5049–5059, 2019.   
+David Berthelot, Nicholas Carlini, Ekin D Cubuk, Alex Kurakin, Kihyuk Sohn, Han Zhang, and Colin Raffel. Remixmatch: Semi-supervised learning with distribution alignment and augmentation anchoring. In Advances in Neural Information Processing Systems (NeurIPS), 2020.   
+Zhaowei Cai and Nuno Vasconcelos. Cascade r-cnn: Delving into high quality object detection. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2018.   
+Terrance DeVries and Graham W Taylor. Improved regularization of convolutional neural networks with cutout. arXiv preprint arXiv:1708.04552, 2017.   
+Mark Everingham, Luc Van Gool, Christopher KI Williams, John Winn, and Andrew Zisserman. The pascal visual object classes (voc) challenge. International Journal of Computer Vision (IJCV), 88(2):303–338, 2010.
+
+Jiyang Gao, Jiang Wang, Shengyang Dai, Li-Jia Li, and Ram Nevatia. Note-rcnn: Noise tolerant ensemble rcnn for semi-supervised object detection. In Proceedings of the IEEE international conference on computer vision (ICCV), pp. 9508–9517, 2019.
+
+Yves Grandvalet and Yoshua Bengio. Semi-supervised learning by entropy minimization. In Advances in neural information processing systems (NeurIPS), pp. 529–536, 2005.
+
+Jean-Bastien Grill, Florian Strub, Florent Altche, Corentin Tallec, Pierre H Richemond, Elena ´ Buchatskaya, Carl Doersch, Bernardo Avila Pires, Zhaohan Daniel Guo, Mohammad Gheshlaghi Azar, et al. Bootstrap your own latent: A new approach to self-supervised learning. arXiv preprint arXiv:2006.07733, 2020.
+
+Hongyu Guo, Yongyi Mao, and Richong Zhang. Mixup as locally linear out-of-manifold regularization. In Proceedings of the AAAI Conference on Artificial Intelligence (AAAI), volume 33, pp. 3714–3722, 2019.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2016.
+
+Kaiming He, Georgia Gkioxari, Piotr Dollar, and Ross Girshick. Mask r-cnn. In ´ Proceedings of the IEEE international conference on computer vision (ICCV), pp. 2961–2969, 2017.
+
+Kaiming He, Haoqi Fan, Yuxin Wu, Saining Xie, and Ross Girshick. Momentum contrast for unsupervised visual representation learning. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pp. 9729–9738, 2020.
+
+Dan Hendrycks, Norman Mu, Ekin D. Cubuk, Barret Zoph, Justin Gilmer, and Balaji Lakshminarayanan. AugMix: A simple data processing method to improve robustness and uncertainty. Proceedings of the International Conference on Learning Representations (ICLR), 2020.
+
+Judy Hoffman, Sergio Guadarrama, Eric S Tzeng, Ronghang Hu, Jeff Donahue, Ross Girshick, Trevor Darrell, and Kate Saenko. Lsda: Large scale detection through adaptation. In Advances in Neural Information Processing Systems ((NeurIPS)), pp. 3536–3544, 2014.
+
+Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In Proceedings of the International Conference on Machine Learning (ICML), 2015.
+
+Jisoo Jeong, Seungeui Lee, Jeesoo Kim, and Nojun Kwak. Consistency-based semi-supervised learning for object detection. In Advances in Neural Information Processing Systems (NeurIPS), 2019.
+
+Borui Jiang, Ruixuan Luo, Jiayuan Mao, Tete Xiao, and Yuning Jiang. Acquisition of localization confidence for accurate object detection. In Proceedings of the European Conference on Computer Vision (ECCV), 2018.
+
+Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In Proceedings of the International Conference on Learning Representations (ICLR), 2015.
+
+Chia-Wen Kuo, Chih-Yao Ma, Jia-Bin Huang, and Zsolt Kira. Featmatch: Feature-based augmentation for semi-supervised learning. In Proceedings of the European Conference on Computer Vision (ECCV), 2020.
+
+Samuli Laine and Timo Aila. Temporal ensembling for semi-supervised learning. In Proceedings of the International Conference on Learning Representations (ICLR), 2017.
+
+Hei Law and Jia Deng. Cornernet: Detecting objects as paired keypoints. In Proceedings of the European Conference on Computer Vision (ECCV), 2018.
+
+Dong-Hyun Lee. Pseudo-label: The simple and efficient semi-supervised learning method for deep neural networks. In Workshop on Challenges in Representation Learning, ICML, volume 3, pp. 2, 2013.
+
+Yu Li, Tao Wang, Bingyi Kang, Sheng Tang, Chunfeng Wang, Jintao Li, and Jiashi Feng. Overcoming classifier imbalance for long-tail object detection with balanced group softmax. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2020.
+
+Tsung-Yi Lin, Michael Maire, Serge Belongie, James Hays, Pietro Perona, Deva Ramanan, Piotr Dollar, and C Lawrence Zitnick. Microsoft coco: Common objects in context. In ´ Proceedings of the European Conference on Computer Vision (ECCV), 2014.
+
+Tsung-Yi Lin, Piotr Dollar, Ross Girshick, Kaiming He, Bharath Hariharan, and Serge Belongie.´ Feature pyramid networks for object detection. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2017a.
+
+Tsung-Yi Lin, Priya Goyal, Ross Girshick, Kaiming He, and Piotr Dollar. Focal loss for dense object ´ detection. In Proceedings of the IEEE international conference on computer vision (CVPR), pp. 2980–2988, 2017b.
+
+Wei Liu, Dragomir Anguelov, Dumitru Erhan, Christian Szegedy, Scott Reed, Cheng-Yang Fu, and Alexander C Berg. Ssd: Single shot multibox detector. In European conference on computer vision (ECCV), pp. 21–37. Springer, 2016.
+
+Ishan Misra, Abhinav Shrivastava, and Martial Hebert. Watch and learn: Semi-supervised learning for object detectors from video. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 3593–3602, 2015.
+
+Takeru Miyato, Shin-ichi Maeda, Masanori Koyama, and Shin Ishii. Virtual adversarial training: a regularization method for supervised and semi-supervised learning. IEEE transactions on pattern analysis and machine intelligence (PAMI), 41(8):1979–1993, 2018.
+
+Kemal Oksuz, Baris Can Cam, Sinan Kalkan, and Emre Akbas. Imbalance problems in object detection: A review. IEEE Transactions on Pattern Analysis and Machine Intelligence, 2020.
+
+Siyuan Qiao, Wei Shen, Zhishuai Zhang, Bo Wang, and Alan Yuille. Deep co-training for semisupervised image recognition. In Proceedings of the European Conference on Computer Vision (ECCV), pp. 135–152, 2018.
+
+Joseph Redmon and Ali Farhadi. Yolo9000: better, faster, stronger. In Proceedings of the IEEE conference on computer vision and pattern recognition (CVPR), pp. 7263–7271, 2017.
+
+Joseph Redmon and Ali Farhadi. Yolov3: An incremental improvement. arXiv preprint arXiv:1804.02767, 2018.
+
+Shaoqing Ren, Kaiming He, Ross Girshick, and Jian Sun. Faster r-cnn: Towards real-time object detection with region proposal networks. In Advances in neural information processing systems (NeurIPS), pp. 91–99, 2015.
+
+Chuck Rosenberg, Martial Hebert, and Henry Schneiderman. Semi-supervised self-training of object detection models. In 2005 Seventh IEEE Workshops on Applications of Computer Vision, volume 1, pp. 29–36, 2005.
+
+Mehdi Sajjadi, Mehran Javanmardi, and Tolga Tasdizen. Regularization with stochastic transformations and perturbations for deep semi-supervised learning. In Advances in Neural Information Processing Systems (NeurIPS), pp. 1163–1171, 2016.
+
+Abhinav Shrivastava, Abhinav Gupta, and Ross Girshick. Training region-based object detectors with online hard example mining. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2016.
+
+Kihyuk Sohn, David Berthelot, Chun-Liang Li, Zizhao Zhang, Nicholas Carlini, Ekin D Cubuk, Alex Kurakin, Han Zhang, and Colin Raffel. Fixmatch: Simplifying semi-supervised learning with consistency and confidence. In Advances in Neural Information Processing Systems (NeurIPS), 2020a.
+
+Kihyuk Sohn, Zizhao Zhang, Chun-Liang Li, Han Zhang, Chen-Yu Lee, and Tomas Pfister. A simple semi-supervised learning framework for object detection. arXiv preprint arXiv:2005.04757, 2020b.
+
+Peng Tang, Chetan Ramaiah, Ran Xu, and Caiming Xiong. Proposal learning for semi-supervised object detection. arXiv preprint arXiv:2001.05086, 2020.
+
+Yuxing Tang, Josiah Wang, Boyang Gao, Emmanuel Dellandrea, Robert Gaizauskas, and Liming ´ Chen. Large scale semi-supervised object detection using visual and semantic knowledge transfer. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 2119–2128, 2016.
+
+Antti Tarvainen and Harri Valpola. Mean teachers are better role models: Weight-averaged consistency targets improve semi-supervised deep learning results. In Advances in neural information processing systems (NeurIPS), pp. 1195–1204, 2017.
+
+Yuxin Wu, Alexander Kirillov, Francisco Massa, Wan-Yen Lo, and Ross Girshick. Detectron2. https://github.com/facebookresearch/detectron2, 2019.
+
+Qizhe Xie, Minh-Thang Luong, Eduard Hovy, and Quoc V Le. Self-training with noisy student improves imagenet classification. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2020.
+
+Bing Yu, Jingfeng Wu, Jinwen Ma, and Zhanxing Zhu. Tangent-normal adversarial regularization for semi-supervised learning. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 10676–10684, 2019.
+
+Sangdoo Yun, Dongyoon Han, Seong Joon Oh, Sanghyuk Chun, Junsuk Choe, and Youngjoon Yoo. Cutmix: Regularization strategy to train strong classifiers with localizable features. In Proceedings of the IEEE International Conference on Computer Vision (ICCV), pp. 6023–6032, 2019.
+
+Hongyi Zhang, Moustapha Cisse, Yann N Dauphin, and David Lopez-Paz. mixup: Beyond empirical risk minimization. In Proc. International Conference on Learning Representations (ICLR), 2018.
+
+Zhun Zhong, Liang Zheng, Guoliang Kang, Shaozi Li, and Yi Yang. Random erasing data augmentation. arXiv preprint arXiv:1708.04896, 2017.
+
+A APPENDIX
+
+# A.1 EMA ON IMBALANCED PSEUDO-LABELING ISSUE
+
+To empirically examine the effectiveness of EMA on imbalance, we present the pseudo-label distribution in different training iterations as presented in Figure 6. At the beginning of training (i.e., 30k), both Teacher models with and without EMA could generate the balanced pseudo-labels (the KL divergence between ground-truth labels and pseudo-labels are both small). However, since the Student model is trained with the pseudo-labels generated by the Teacher models, the model without EMA starts biasing towards specific classes. In contrast, with the EMA training, the model generates less imbalanced pseudo-labels. Note that, although the EMA is applied, the balance issue still exists. We thus apply Focal loss to enhance the ability to mitigate the imbalance issue further.
+
+![](images/8c66018ff39bcc905db717d1459ba275913e67adbdbb062381a9234b158d0e8b.jpg)  
+Figure 6: Ablation study on EMA at different training iterations. Both the models with EMA and without EMA have pseudo-label distributions, which are similar to the ground-truth distributions in the early stage of training iterations. However, the model without EMA tends to generate more biased pseudo-label distribution later during training.
+
+# A.2 ADDITIONAL ABLATION STUDY
+
+In addition to the ablation studies provided in the main paper, we further ablate Unbiased Teacher in the following sections.
+
+# A.2.1 EFFECT OF BURN-IN STAGE
+
+As mentioned in Section 3.1, it is crucial to have a good initialization for both Student and Teacher models. We thus present a comparison between the model with and without the Burn-In stage in Figure 7. We observe that, with the Burn-In stage, the model can derive more accurate pseudo-boxes in the early stage of the training. As a result, the model can achieve higher accuracy in the early stage of the training, and it also achieves better results when the model is converged.
+
+# A.2.2 EFFECT OF PSEUDO-LABELING THRESHOLD
+
+As mentioned in Section 3.3, we apply confidence thresholding to filter these low-confidence predicted bounding boxes, which are more likely to be false-positive instances. To show the effectiveness of thresholding, we first provide the accuracy of predicted bounding boxes before and after the pseudo-labeling in Figure 8.
+
+![](images/ad0b577dcf3b79e1d30a56ea6e45a0681e88b573a42250b897db93ae7b6df28f.jpg)  
+Figure 7: In the case of $C O C O$ -standard $1 \%$ labeled data, (a) Unbiased Teacher with Burn-In stage achieve higher mAP against Unbiased Teacher without Burn-In stage. Using Burn-In Stage results in the early improvement of (b) box accuracy and (c) mIoU. (d) Unbiased Teacher with Burn-In stage can derive more pseudo-boxes than Unbiased Teacher without Burn-In stage.
+
+![](images/0eb3b49413c21aed94c0e4d005e9e4abc2c5254796681119fbf32a6ad8f77f46.jpg)  
+Figure 8: Pseudo-label accuracy improvement with the use of confidence thresholding. We measure the accuracy by comparing the ground-truth labels and predicted labels before and after confidence thresholding. This result indicates that confidence thresholding can significantly improve the quality of pseudo-labels.
+
+When varying the threshold value $\delta$ from 0 to 0.9, as expected, the number of generated pseudoboxes increases as the threshold $\delta$ reduces (Figure 9). The model using excessively high threshold (e.g., $\delta \ : = \ : 0 . 9 $ ) cannot perform satisfactory results, as the number of generated pseudo-labels is very low. On the other hand, the model using a low threshold (e.g., $\delta = 0 . 6$ ) also cannot achieve favorable results since the model generates too many bounding boxes, which are likely to be falsepositive instances. We also observe that the model cannot even converge if the threshold is below 0.5.
+
+![](images/bf9b4c94616e04dc7472b854643e99875718344a8755433a7ba7324efd05841e.jpg)  
+Figure 9: (a) Validation AP and (b) number of pseudo-label bounding boxes per image with various pseudo-labeling thresholds $\delta$ . With an excessively low threshold (e.g., $\delta = 0 . 6$ ), the model has a lower AP, as it predicts more pseudo-labeled bounding boxes compared to the number of bounding boxes in ground-truth labels. On the other hand, the performance of the model using an excessively high threshold (e.g., $\delta = 0 . 9$ ) drops as it cannot predict sufficient number of bounding boxes in its generated pseudo-labels.
+
+# A.2.3 EFFECT OF EMA RATES
+
+We also evaluate the model using various EMA rate $\alpha$ from 0.5 to 0.9999 and present the mAP result of the Teacher model in Figure 10. We observe that, with a smaller EMA rate (e.g., $\alpha = 0 . 5$ ), the model has lower mAP and higher variance, as the Student contributes more to the Teacher model for each iteration. This implies the Teacher model is likely to suffer from the detrimental effect caused by noisy pseudo-labels. This unstable learning curve can be stabilized and improved as the EMA rate $\alpha$ increases. When the EMA rate $\alpha$ achieves 0.99, it performs the best mAP. However, if the EMA rate $\alpha$ keeps increasing, the teacher model will grow overly slow as the Teacher model derive the next model weight mostly from the previous Teacher model weight.
+
+![](images/d503bf0212abfc65305c79627f753df496e9ec7a00e7abe32048bb7fac5e032a.jpg)  
+Figure 10: Validation AP on the Teacher model with various MMA rates $\alpha$ . (a) With a small MMA rate (e.g., $\alpha = 0 . 5$ ), the Teacher model has lower AP and larger variance. In contrast, as the MMA rate grows to 0.99, the Teacher model can gradually improve along the training iterations. However, when the MMA grows to 0.9999, the Teacher model grows overly slow but has lowest variance. (b) We breakdown the AP metric into APs from $A P _ { 5 0 }$ to $A P _ { 9 5 }$ .
+
+# A.2.4 EFFECT OF UNSUPERVISED LOSS WEIGHTS
+
+To examine the effect unsupervised loss weights, we vary the unsupervised loss weight $\lambda _ { u }$ from 1.0 to 8.0 in the case of $C O C O$ -standard $1 0 \%$ labeled data. As shown in Table 4, with a lower unsupervised loss weight $\lambda _ { u } = 1 . 0$ , the model performs $2 9 . 3 0 \%$ . On the other hand, we observe that the model performs the best with unsupervised loss weight $\lambda = 5 . 0$ . However, when the weight increases to 8.0, the training of the model cannot converge.
+
+Table 4: Ablation study of varying unsupervised loss weight $\lambda _ { u }$ on the model trained using $1 0 \%$ labeled and $9 0 \%$ unlabeled data.   
+
+<table><tr><td>入u</td><td>1.0</td><td>2.0</td><td>4.0</td><td>5.0</td><td>6.0</td><td>8.0</td></tr><tr><td>AP(%)</td><td>29.30</td><td>30.64</td><td>31.82</td><td>32.00</td><td>31.80</td><td>Cannot Converge</td></tr></table>
+
+# A.3 AP BREAKDOWN FOR COCO-STANDARD
+
+We present an AP breakdown for COCO-standard $0 . 5 \%$ labeled data. As mentioned in Section 4, our proposed model can perform favorably against both STAC (Sohn et al., 2020b) and CSD (Jeong et al., 2019). This trend appears in all evaluation metrics from $A P _ { 5 0 }$ to $A P _ { 9 5 }$ , as shown in Figure 11, and it confirms that our model is preferable for handling extremely low-label scenario compared to the state of the arts.
+
+![](images/4d3b72fa84190227bca23d5caa8b1d806600fe3fa37368cb21899d4e56818f2a.jpg)  
+Figure 11: Evaluation metric breakdown of all methods on $0 . 5 \%$ labeled data.
+
+# A.4 IMPLEMENTATION AND TRAINING DETAILS
+
+Network and framework. Our implementation builds upon the Detectron2 framework (Wu et al., 2019). For a fair comparison, we follow the prior work (Sohn et al., 2020b) to use Faster-RCNN with FPN (Lin et al., 2017a) and ResNet-50 backbone (He et al., 2016) as our object detection network.
+
+Training. At the beginning of the Burn-In stage, the feature backbone network weights are initialized by the ImageNet-pretrained model, which is same as existing works (Jeong et al., 2019; Tang et al., 2020; Sohn et al., 2020b). We use the SGD optimizer with a momentum rate 0.9 and a learning rate 0.01, and we use constant learning rate scheduler. The batch size of supervised and unsupervised data are both 32 images. For the COCO-standard, we train 180k iterations, which includes $1 / 2 / 6 / 1 2 / 2 0 \mathbf { k }$ iterations for $0 . 5 \% / 1 \% / 2 \% / 5 \% / 1 0 \%$ in the Burn-In stage and the remaining iterations in the Teacher-Student Mutual Learning stage. For the COCO-additional, we train $3 6 0 \mathrm { k }$ iterations, which includes $9 0 \mathrm { k }$ iterations in the Burn-Up stage and the remaining $2 7 0 \mathrm { k }$ iterations in the Teacher-Student Mutual Learning stage.
+
+Hyper-parameters. We use confidence threshold $\delta \ : = \ : 0 . 7$ to generate pseudo-labels for all our experiments, the unsupervised loss weight $\lambda _ { u } = 4$ is applied for $C O C O$ -standard and VOC, and the unsupervised loss weight $\lambda _ { u } = 2$ is applied for $C O C O$ -additional. We apply $\alpha = 0 . 9 9 9 6$ as the EMA rate for all our experiments. Hyper-parameters used are summarized in Table 5.
+
+Data augmentation. As shown in Table 6, we apply randomly horizontal flip for weak augmentation and randomly add color jittering, grayscale, Gaussian blur, and cutout patches (DeVries & Taylor, 2017) for the strong augmentation. Note that we do not apply any image-level or box-level geometric augmentations, which are used in STAC (Sohn et al., 2020b). In addition, we do not aggressively search the best hyper-parameters for data augmentations, and it is possible to obtain better hyperparameters.
+
+Table 5: Meanings and values of the hyper-parameters used in experiments.   
+
+<table><tr><td>Hyper-parameter</td><td>Description</td><td>COCO-standard and VOC</td><td>COCO-additional</td></tr><tr><td>8</td><td>Confidence threshold</td><td>0.7</td><td>0.7</td></tr><tr><td>入u</td><td>Unsupervised loss weight</td><td>4</td><td>2</td></tr><tr><td>a</td><td>EMA rate</td><td>0.9996</td><td>0.9996</td></tr><tr><td>b</td><td>Batch size for labeled data</td><td>32</td><td>16</td></tr><tr><td>bu</td><td>Batch size for unlabeled data</td><td>32</td><td>16</td></tr><tr><td>Y</td><td>Learning rate</td><td>0.01</td><td>0.01</td></tr></table>
+
+Table 6: Detail of data augmentations. Probability in the table indicates the probability of applying the corresponding image process.   
+
+<table><tr><td colspan="4">Weak Augmentation</td></tr><tr><td>Process</td><td>Probability</td><td>Parameters</td><td>Descriptions</td></tr><tr><td>Horizontal Flip</td><td>0.5</td><td>-</td><td>None</td></tr><tr><td colspan="4">Strong Augmentation</td></tr><tr><td>Process</td><td>Probability</td><td>Parameters</td><td>Descriptions</td></tr><tr><td>Color Jittering</td><td>0.8</td><td>(brightness,contrast, saturation, hue) =(0.4,0.4,0.4,0.1)</td><td>Brightness factor is chosen uniformly from [O.6,1.4], contrast factor is chosen uniformly from [O.6,1.4], saturation factor is chosen uniformly from [O.6,1.4], and hue value is chosen uniformly from[-O.1, 0.1].</td></tr><tr><td>Grayscale</td><td>0.2</td><td>None</td><td>None</td></tr><tr><td>GaussianBlur</td><td>0.5</td><td>(sigma_x,sigma_y)=(0.1,2.0)</td><td>Gaussian filter with ox = O.1 and σy= 2.O is applied.</td></tr><tr><td>CutoutPattern1</td><td>0.7</td><td>scale=(0.05,0.2),ratio=(0.3,3.3)</td><td>Randomly selects a rectangle region in an image and erases its pixels.We refer the detail in Zhong et al. (2017).</td></tr><tr><td>CutoutPattern2</td><td>0.5</td><td>scale=(0.02,0.2),ratio=(0.1,6)</td><td>Randomly selects a rectangle region in an image and erases its pixels.We refer the detail in Zhong et al.(2017).</td></tr><tr><td>CutoutPattern3</td><td>0.3</td><td>scale=(0.02,0.2),ratio=(0.05,8)</td><td>Randomly selects a rectangle region in an image and erases its pixels.We refer the detail in Zhong et al.(2017).</td></tr></table>
+
+Evaluation Metrics. $A P _ { 5 0 : 9 5 }$ is used to evaluate all methods following the prior works (Law & Deng, 2018; Sohn et al., 2020b).

parse/train/MJIve1zgR_/MJIve1zgR__content_list.json

@@ -0,0 +1,1768 @@
+[
+    {
+        "type": "text",
+        "text": "UNBIASED TEACHER FOR SEMI-SUPERVISED OBJECT DETECTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            714,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Yen-Cheng ${ \\bf L i u ^ { 1 , 2 } }$ ∗, Chih-Yao $\\mathbf { M } \\mathbf { a } ^ { 2 }$ , Zijian $\\mathbf { H e } ^ { 2 }$ , Chia-Wen ${ \\bf K u o } ^ { 1 }$ , Kan Chen2, Peizhao Zhang2, Bichen $\\mathbf { W } \\mathbf { u } ^ { 2 }$ , Zsolt ${ \\bf K i r a } ^ { 1 }$ , Peter Vajda2 ",
+        "bbox": [
+            183,
+            169,
+            710,
+            199
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1Georgia Tech, 2Facebook Inc. {ycliu,cwkuo,zkira}@gatech.edu, {cyma,zijian,kanchen18,stzpz,wbc,vajdap}@fb.com ",
+        "bbox": [
+            186,
+            200,
+            642,
+            241
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            277,
+            544,
+            292
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Semi-supervised learning, i.e., training networks with both labeled and unlabeled data, has made significant progress recently. However, existing works have primarily focused on image classification tasks and neglected object detection which requires more annotation effort. In this work, we revisit the Semi-Supervised Object Detection (SS-OD) and identify the pseudo-labeling bias issue in SSOD. To address this, we introduce Unbiased Teacher1, a simple yet effective approach that jointly trains a student and a gradually progressing teacher in a mutually-beneficial manner. Together with a class-balance loss to downweight overly confident pseudo-labels, Unbiased Teacher consistently improved state-ofthe-art methods by significant margins on COCO-standard, COCO-additional, and $V O C$ datasets. Specifically, Unbiased Teacher achieves 6.8 absolute mAP improvements against state-of-the-art method when using $1 \\%$ of labeled data on MS-COCO, achieves around $1 0 \\mathrm { m A P }$ improvements against the supervised baseline when using only $0 . 5 , 1 , 2 \\%$ of labeled data on MS-COCO. ",
+        "bbox": [
+            233,
+            311,
+            764,
+            505
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            536,
+            334,
+            553
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The availability of large-scale datasets and computational resources has allowed deep neural networks to achieve strong performance on a wide variety of tasks. However, training these networks requires a large number of labeled examples that are expensive to annotate and acquire. As an alternative, Semi-Supervised Learning (SSL) methods have received growing attention (Sohn et al., 2020a; Berthelot et al., 2020; 2019; Laine & Aila, 2017; Tarvainen & Valpola, 2017; Sajjadi et al., 2016; Lee, 2013; Grandvalet & Bengio, 2005). Yet, these advances have primarily focused on image classification, rather than object detection where bounding box annotations require more effort. ",
+        "bbox": [
+            174,
+            570,
+            825,
+            667
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this work, we revisit object detection under the SSL setting (Figure 1): an object detector is trained with a single dataset where only a small amount of labeled bounding boxes and a large amount of unlabeled data are provided, or an object detector is jointly trained with a large labeled dataset as well as a large external unlabeled dataset. A straightforward way to address Semi-Supervised Object Detection (SS-OD) is to adapt from existing advanced semi-supervised image classification methods (Sohn et al., 2020a). Unfortunately, object detection has some unique characteristics that interact poorly with such methods. For example, the nature of class-imbalance in object detection tasks impedes the usage of pseudo-labeling. In object detection, there exists foreground-background imbalance and foreground classes imbalance (see Section 3.3). These imbalances make models trained in SSL settings prone to generate biased predictions. Pseudo-labeling methods, one of the most successful SSL methods in image classification (Lee, 2013; Sohn et al., 2020a), may thus be biased towards dominant and overly confident classes (background) while ignoring minor and less confident classes (foreground). As a result, adding biased pseudo-labels into the semi-supervised training aggravates the class-imbalance issue and introduces severe overfitting. As shown in Figure 2, taking a two-stage object detector as an example, there exists heavy overfitting on the fore",
+        "bbox": [
+            173,
+            674,
+            825,
+            882
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/3a4afc16fb87e7ab4911d64720067079773c86fa7d2001ddeb2589e799611b56.jpg",
+        "image_caption": [
+            "Figure 1: (a) Illustration of semi-supervised object detection, where the model observes a set of labeled data and a set of unlabeled data in the training stage. (b) Our proposed model can efficiently leverage the unlabeled data and perform favorably against the existing semi-supervised object detection works, including CSD (Jeong et al., 2019) and STAC (Sohn et al., 2020b). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            210,
+            87,
+            797,
+            210
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "ground/background classification in the RPN and multi-class classification in the ROIhead (but not on bounding box regression). ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            294,
+            823,
+            323
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To overcome these issues, we propose a general framework – Unbiased Teacher: an approach that jointly trains a Student and a slowly progressing Teacher in a mutually-beneficial manner, in which the Teacher generates pseudo-labels to train the Student, and the Student gradually updates the Teacher via Exponential Moving Average (EMA)2, while the Teacher and Student are given different augmented input images (see Figure 3). Inside this framework, (i) we utilize the pseudo-labels as explicit supervision for both RPN and ROIhead and thus alleviate the overfitting issues in both RPN and ROIhead. (ii) We also prevent detrimental effects due to noisy pseudo-labels by exploiting the Teacher-Student dual models (see further discussion and analysis in Section 4.2). (iii) With the use of EMA training and the Focal loss (Lin et al., 2017b), we can address the pseudo-labeling bias problem caused by class-imbalance and thus improve the quality of pseudo-labels. As the result, our object detector achieves significant performance improvements. ",
+        "bbox": [
+            174,
+            329,
+            825,
+            482
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We benchmark Unbiased Teacher with SSL setting using the MS-COCO and PASCAL VOC datasets, namely COCO-standard, COCO-additional, and VOC. When using only $1 \\%$ labeled data from MS-COCO (COCO-standard), Unbiased Teacher achieves 6.8 absolute mAP improvement against the state-of-the-art method, STAC (Sohn et al., 2020b). Unbiased Teacher consistently achieves around 10 absolute mAP improvements when using only $0 . 5 , 1 , 2 , 5 \\%$ of labeled data compared to supervised baseline. ",
+        "bbox": [
+            174,
+            489,
+            825,
+            571
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We highlight the contributions of this paper as follows: ",
+        "bbox": [
+            176,
+            579,
+            531,
+            594
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• By analyzing object detectors trained with limited-supervision, we identify that the nature of class-imbalance in object detection tasks impedes the effectiveness of pseudo-labeling method on SS-OD task.   \n• We thus proposed a simple yet effective method, Unbiased Teacher, to address the pseudolabeling bias issue caused by class-imbalance existing in ground-truth labels and the overfitting issue caused by the scarcity of labeled data.   \n• Our Unbiased Teacher achieves state-of-the-art performance on SS-OD across COCOstandard, COCO-additional, and VOC datasets. We also provide an ablation study to verify the effectiveness of each proposed component. ",
+        "bbox": [
+            217,
+            606,
+            825,
+            741
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            761,
+            354,
+            777
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Semi-Supervised Learning. The majority of the recent SSL methods typically consist of (1) input augmentations and perturbations, and (2) consistency regularization. They regularize the model to be invariant and robust to certain augmentations on the input, which requires the outputs given the original and augmented inputs to be consistent. For example, existing approaches apply convention data augmentations (Berthelot et al., 2019; Laine & Aila, 2017; Sajjadi et al., 2016; Tarvainen & ",
+        "bbox": [
+            174,
+            792,
+            825,
+            862
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/e1d662fcdba0482b7dbffc1b58afdd60f65be1a18a88c6c93f878f6025574475.jpg",
+        "image_caption": [
+            "Figure 2: Validation Losses of our model and the model trained with labeled data only. When the labeled data is insufficient ( $1 \\%$ and $5 \\%$ ), RPN and ROIhead classifiers suffer from overfitting, while RPN and ROIhead regression do not suffer from overfitting. Our model can significantly alleviates the overfitting issue in classifiers and also improves the validation box regression loss. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            163,
+            74,
+            823,
+            207
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Valpola, 2017) to generate different transformations of the semantically identical images, perturb the input images along the adversarial direction (Miyato et al., 2018; Yu et al., 2019), utilize multiple networks to generate various views of the same input data (Qiao et al., 2018), mix input data to generate augmented training data and labels (Zhang et al., 2018; Yun et al., 2019; Guo et al., 2019; Hendrycks et al., 2020), or learn augmented prototypes in feature space instead of the image space (Kuo et al., 2020). However, the complexities in architecture design of object detectors hinder the transfer of existing semi-supervised techniques from image classification to object detection. ",
+        "bbox": [
+            173,
+            292,
+            825,
+            391
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Semi-Supervised Object Detection. Object detection is one of the most important computer vision tasks and has gained enormous attention (Lin et al., 2017a; He et al., 2017; Redmon & Farhadi, 2017; Liu et al., 2016). While existing works have made significant progress over the years, they have primarily focused on training object detectors with fully-labeled datasets. On the other hand, there exist several semi-supervised object detection works that focus on training object detector with a combination of labeled, weakly-labeled, or unlabeled data. This line of work began even before the resurgence of deep learning (Rosenberg et al., 2005). Later, along with the success of deep learning, Hoffman et al. (2014) and Gao et al. (2019) trained object detectors on data with bounding box labels for some classes and image-level class labels for other classes, enabling detection for categories that lack bounding box annotations. Tang et al. (2016) adapted the image-level classifier of a weakly labeled category (no bounding boxes) into a detector via similarity-based knowledge transfer. Misra et al. (2015) exploited a few sparsely labeled objects and bounding boxes in some video frames and localized unknown objects in the following videos. ",
+        "bbox": [
+            173,
+            397,
+            825,
+            578
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Unlike their settings, we follow the standard SSL setting and adapt it to the object detection task, in which the training contains a small set of labeled data and another set of completely unlabeled data (i.e., only images). In this setting, Jeong et al. (2019) proposed a consistency-based method, which enforces the predictions of an input image and its flipped version to be consistent. Sohn et al. (2020b) pre-trained a detector using a small amount labeled data and generates pseudo-labels on unlabeled data to fine-tune the pre-trained detector. Their pseudo-labels are generated only once and are fixed through out the rest of training. While they can improve the performance against the model trained on labeled data, imbalance issue is not considered in existing SS-OD works. In contrast, our method not only improve the pseudo-label generation model via teacher-student mutual learning regimen (Sec. 3.2) but address the crucial imbalance issue in generated pseudo-labels (Sec. 3.3). ",
+        "bbox": [
+            174,
+            584,
+            825,
+            724
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 UNBIASED TEACHER ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            744,
+            380,
+            761
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Problem definitiof labeled images $D _ { s } = \\{ \\mathbf { \\bar { x } } _ { i } ^ { s } , \\pmb { y } _ { i } ^ { s } \\} _ { i = 1 } ^ { N _ { s } }$ dress object detection in a sem and a set of unlabeled images $\\bar { D _ { u } } \\bar { = } \\{ \\pmb { x } _ { i } ^ { u } \\} _ { i = 1 } ^ { N _ { u } }$ tting, where a setare available for training. and $N _ { u }$ are the number of supervised and unsupervised data. For each labeled image $\\pmb { x } ^ { s }$ , the annotations $\\boldsymbol { y } ^ { s }$ contain locations, sizes, and object categories of all bounding boxes. ",
+        "bbox": [
+            173,
+            775,
+            823,
+            833
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Overview. As shown in Figure 3, our Unbiased Teacher consists of two training stages, the BurnIn stage and the Teacher-Student Mutual Learning stage. In the Burn-In stage (Sec. 3.1), we simply train the object detector using the available supervised data to initialize the detector. At the beginning of the Teacher-Student Mutual Learning stage (Sec. 3.2), we duplicate the initialized detector into two models (Teacher and Student models). Our Teacher-Student Mutual Learning stage aims at evolving both Teacher and Student models via a mutual learning mechanism, where the Teacher generates pseudo-labels to train the Student, and the Student updates the knowledge it learned back to the Teacher; hence, the pseudo-labels used to train the Student itself are improved. Lastly, there exists class-imbalance and foreground-background imbalance problems in object detection, which impedes the effectiveness of semi-supervised techniques of image classification (e.g., pseudo-labeling) being used directly on SS-OD. Therefore, in Sec. 3.3, we also discuss how Focal loss (Lin et al., 2017b) and EMA training alleviate the imbalanced pseudo-label issue. ",
+        "bbox": [
+            173,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/b89dd1e2de99c64f3afd899e071ee73e67ed8a0064fecfe4297e088566767240.jpg",
+        "image_caption": [
+            "Figure 3: Overview of Unbiased Teacher. Unbiased Teacher consists of two stages. Burn-In: we first train the object detector using available labeled data. Teacher-Student Mutual Learning consists of two steps. Student Learning: the fixed teacher generates pseudo-labels to train the Student, while Teacher and Student are given weakly and strongly augmented inputs, respectively. Teacher Refinement: the knowledge that the Student learned is then transferred to the slowly progressing Teacher via exponential moving average (EMA) on network weights. When the detector is trained until converge in the Burn-In stage, we switch to the Teacher-Student Mutual Learning stage. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            104,
+            818,
+            272
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            412,
+            825,
+            497
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 BURN-IN ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            515,
+            279,
+            530
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "It is important to have a good initialization for both Student and Teacher models, as we will rely on the Teacher to generate pseudo-labels to train the Student in the later stage. To do so, we first use the available supervised data to optimize our model $\\theta$ with the supervised loss $\\mathcal { L } _ { s u p }$ . With the supervised data $D _ { s } = \\{ \\pmb { x } _ { i } ^ { s } , \\pmb { y } _ { i } ^ { s } \\} _ { i = 1 } ^ { N _ { s } }$ , the supervised loss of object detection consists of four losses: ithe RPN classification loss $\\mathcal { L } _ { c l s } ^ { r p n }$ =1, the RPN regression loss $\\mathcal { L } _ { r e g } ^ { r p n }$ , the ROI classification loss $\\mathcal { L } _ { c l s } ^ { r o i }$ and the ROI regression loss $\\mathcal { L } _ { r e g } ^ { r o i }$ (Ren et al., 2015), ",
+        "bbox": [
+            173,
+            541,
+            825,
+            633
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/527208e4f0b59fa29a1be1f788bbaf3804d855aa3200497e1a90614526eabffb.jpg",
+        "text": "$$\n\\mathcal { L } _ { s u p } = \\sum _ { i } \\mathcal { L } _ { c l s } ^ { r p n } ( \\boldsymbol { x } _ { i } ^ { s } , \\boldsymbol { y } _ { i } ^ { s } ) + \\mathcal { L } _ { r e g } ^ { r p n } ( \\boldsymbol { x } _ { i } ^ { s } , \\boldsymbol { y } _ { i } ^ { s } ) + \\mathcal { L } _ { c l s } ^ { r o i } ( \\boldsymbol { x } _ { i } ^ { s } , \\boldsymbol { y } _ { i } ^ { s } ) + \\mathcal { L } _ { r e g } ^ { r o i } ( \\boldsymbol { x } _ { i } ^ { s } , \\boldsymbol { y } _ { i } ^ { s } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            250,
+            642,
+            745,
+            676
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "After Burn-In, we duplicate the trained weights $\\theta$ for both the Teacher and the Student models $( \\theta _ { t } \\gets \\theta , \\theta _ { s } \\gets \\theta )$ . Starting from this trained detector, we further utilize the unsupervised data to improve the object detector via the following proposed training regimen. ",
+        "bbox": [
+            174,
+            683,
+            823,
+            727
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 TEACHER-STUDENT MUTUAL LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            744,
+            501,
+            758
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Overview. To leverage the unsupervised data, we introduce the Teacher-Student Mutual Learning regimen, where the Student is optimized by using the pseudo-labels generated from the Teacher, and the Teacher is updated by gradually transferring the weights of continually learned Student model. With the interaction between the Teacher and the Student, both models can evolve jointly and continuously to improve detection accuracy. With the improvement on detection accuracy, this also means that the Teacher generates more accurate and stable pseudo-labels, which we identify as one of the keys for large performance improvement compared to existing work (Sohn et al., 2020b). In another perspective, we can also regard the Teacher as the temporal ensemble of the Student models in different time steps. This aligns our observation that the accuracy of the Teacher is consistently higher than the Student. As noted in prior works (Tarvainen & Valpola, 2017; Xie et al., 2020), one crucial factor in improving the Teacher model is the diversity of Student models; we thus use the strongly augmented images as as input of the Student, but we use the weakly augmented images as input of the Teacher to provide reliable pseudo-labels. ",
+        "bbox": [
+            173,
+            770,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Student Learning with Pseudo-Labeling. To address the lack of ground-truth labels for unsupervised data, we adapt the pseudo-labeling method to generate labels for training the Student with unsupervised data. This follows the principle of existing successful examples in semi-supervised image classification task (Lee, 2013; Sohn et al., 2020a). Similar to classification-based methods, to prevent the consecutively detrimental effect of noisy pseudo-labels (i.e., confirmation bias or error accumulation), we first set a confidence threshold $\\delta$ of predicted bounding boxes to filter lowconfidence predicted bounding boxes, which are more likely to be false positive samples. ",
+        "bbox": [
+            174,
+            138,
+            825,
+            237
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "While the confidence threshold method have achieved tremendous success in the image classification, it is however not sufficient for object detection. This is because there also exist duplicated box predictions and imbalanced prediction issues in the SS-OD (we leave the discussion of the imbalanced prediction issue in Sec. 3.3). To address the duplicated boxes prediction issue, we remove the repetitive predictions by applying class-wise non-maximum suppression (NMS) before the use of confidence thresholding as performed in STAC (Sohn et al., 2020b). ",
+        "bbox": [
+            173,
+            242,
+            825,
+            327
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In addition, noisy pseudo-labels can affect the pseudo-label generation model (Teacher). As a result, we detach the Student and the Teacher. To be more specific, after obtaining the pseudo-labels from the Teacher, only the learnable weights of the Student model is updated via back-propagation. ",
+        "bbox": [
+            174,
+            334,
+            825,
+            376
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/002730e223d8362521cd528b4a5222a31d7031bb6217a16edc3158be098a19c8.jpg",
+        "text": "$$\n\\theta _ { s } \\xleftarrow \\theta _ { s } + \\gamma \\frac { \\partial ( \\mathcal { L } _ { s u p } + \\lambda _ { u } \\mathcal { L } _ { u n s u p } ) } { \\partial \\theta _ { s } } , \\quad \\mathcal { L } _ { u n s u p } = \\sum _ { i } \\mathcal { L } _ { c l s } ^ { r p n } ( \\pmb { x } _ { i } ^ { u } , \\hat { \\pmb { y } } _ { i } ^ { u } ) + \\mathcal { L } _ { c l s } ^ { r o i } ( \\pmb { x } _ { i } ^ { u } , \\hat { \\pmb { y } } _ { i } ^ { u } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            222,
+            380,
+            776,
+            419
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Note that we do not apply unsupervised losses for the bounding box regression since the naive confidence thresholding is not able to filter the pseudo-labels that are potentially incorrect for bounding box regression (because the confidence of predicted bounding boxes only indicate the confidence of predicted object categories instead of the quality of bounding box locations (Jiang et al., 2018)). ",
+        "bbox": [
+            173,
+            422,
+            825,
+            479
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Teacher Refinement via Exponential Moving Average. To obtain more stable pseudo-labels, we apply EMA to gradually update the Teacher model. The slowly progressing Teacher model can be regarded as the ensemble of the Student models in different training iterations. ",
+        "bbox": [
+            174,
+            484,
+            825,
+            527
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d86b9daf27e08d04b95eb90ac824ebb788e2882d2b50b080d2d1ebffda9eea3e.jpg",
+        "text": "$$\n\\theta _ { t }  \\alpha \\theta _ { t } + ( 1 - \\alpha ) \\theta _ { s } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            419,
+            532,
+            576,
+            549
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "This approach has been shown to be effective in many existing works, e.g., ADAM optimization (Kingma & Ba, 2015), Batch Normalization (Ioffe & Szegedy, 2015), self-supervised learning (He et al., 2020; Grill et al., 2020), and SSL image classification (Tarvainen & Valpola, 2017), while we, for the first time, demonstrate its effectiveness also in alleviating pseudo-labeling bias issue for SS-OD (see next section). ",
+        "bbox": [
+            174,
+            554,
+            823,
+            625
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.3 BIAS IN PSEUDO-LABEL ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            640,
+            383,
+            655
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Ideally, the methods based on pseudo-labels can address problems caused by the scarcity of labels, yet the inherent nature of imbalance in object detection tasks/datasets impedes the effectiveness of pseudo-labeling methods. As mentioned in (Oksuz et al., 2020), in object detection, there exists foreground-background imbalance (e.g., background instances accounts for $70 \\%$ of all training instances) and foreground classes imbalance (e.g., human instances accounts for $30 \\%$ of all foreground training instances in MS-COCO (Lin et al., 2014)). If standard cross-entropy is applied in the condition of insufficient training data, the model is likely prone to predict the dominant classes. This makes the prediction bias toward prevailing classes and leads to the class-imbalance issue in generated pseudo-labels. Relying on the biased pseudo-labels during training makes the imbalanced prediction issue even more severe. To address the imbalance issue in object detection, existing works have proposed several methods (Shrivastava et al., 2016; Lin et al., 2017b; Li et al., 2020). ",
+        "bbox": [
+            174,
+            666,
+            825,
+            819
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this work, we consider a simple yet effective method; we replace the standard cross-entropy with the multi-class Focal loss (Lin et al., 2017b) for the multi-class classification of ROIhead classifier (i.e., $\\mathcal { L } _ { c l s . } ^ { r o i }$ ). Focal loss is designed to put more loss weights on the samples with lower-confidence instances. As a result, it makes the model focus on hard samples, instead of the easier examples that are likely from dominant classes. Although the Focal loss is not widely used for vanilla supervised object detection settings (the accuracy of YOLOv3 (Redmon & Farhadi, 2018) even drops if the focal loss is applied), we argue that it is crucial for SS-OD due to the issue of biased pseudo-labels. ",
+        "bbox": [
+            174,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/b60873145e246641695b03796920d8f04323a2357bfcdb6e0985f07c320312cc.jpg",
+        "table_caption": [
+            "Table 1: Experimental results on COCO-standard comparing with CSD (Jeong et al., 2019) and STAC (Sohn et al., 2020b). \\*: we implement the CSD method and adapt it on the MS-COCO dataset. The results of $0 . 5 \\%$ with STAC is from their released code. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\"></td><td colspan=\"5\">COCO-standard</td></tr><tr><td>0.5%</td><td>1%</td><td>2%</td><td>5%</td><td>10%</td></tr><tr><td>Supervised</td><td>6.83 ± 0.15</td><td>9.05 ± 0.16</td><td>12.70 ± 0.15</td><td>18.47± 0.22</td><td>23.86±0.81</td></tr><tr><td>CSD*</td><td>7.41 ± 0.21 (+0.58)</td><td>10.51 ± 0.06 (+1.46)</td><td>13.93 ± 0.12 (+1.23)</td><td>18.63 ± 0.07 (+0.16)</td><td>22.46 ± 0.08 (-1.40)</td></tr><tr><td>STAC</td><td>9.78 ± 0.53 (+2.95)</td><td>13.97 ± 0.35 (+4.92)</td><td>18.25 ± 0.25 (+5.55)</td><td>24.38 ± 0.12 (+5.86)</td><td>28.64 ± 0.21 (+4.78)</td></tr><tr><td>Unbiased Teacher</td><td>16.94 ± 0.23 (+10.11)</td><td>20.75 ± 0.12 (+11.72)</td><td>24.30 ± 0.07 (+11.60)</td><td>28.27 ± 0.11 (+9.80)</td><td>31.50 ± 0.10 (+7.64)</td></tr></table>",
+        "bbox": [
+            173,
+            156,
+            825,
+            244
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "On the other hand, we also observe that the EMA training can also alleviate the imbalanced pseudolabeling biased issue due to the conservative property of the EMA training. To be more specific, with the EMA mechanism, the new Teacher model is regularized by the previous Teacher model, and this prevents the decision boundary from drastically moving toward the minority classes. In detail, the weights of the Teacher model can be represented as follows: ",
+        "bbox": [
+            174,
+            260,
+            823,
+            330
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e1e7c284f200abae4272e5de28a5d8b7c4be0bff6691ca063eb46f56fe40738a.jpg",
+        "text": "$$\n\\theta _ { t } ^ { i } = \\hat { \\theta } - \\gamma \\sum _ { k = 1 } ^ { i - 1 } ( 1 - \\alpha ^ { - k + ( i - 1 ) } ) \\frac { \\partial ( \\mathcal { L } _ { s u p } + \\lambda _ { u } \\mathcal { L } _ { u n s u p } ) } { \\partial \\theta _ { s } ^ { k } } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            316,
+            337,
+            679,
+            380
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $\\hat { \\theta }$ is the model weight after the burn-in stage, $\\theta _ { t } ^ { i }$ is the Teacher model weight in $i$ -th iteration, $\\theta _ { s } ^ { k }$ is the Student model weight in $k$ -th iteration, $\\gamma$ is the learning rate, and $\\alpha$ is the EMA coefficient. ",
+        "bbox": [
+            171,
+            388,
+            825,
+            417
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The regularization of the previous Teacher model is equivalent to putting an additional small coefficient on the gradients on Student models in previous steps. With the slowly altered decision boundary (i.e., higher stability), the pseudo-labels of these unlabeled instances are less likely to change dramatically, and this prevents the decision boundary from moving toward minority classes (i.e., majority class bias). Thus, the EMA-trained Teacher model is beneficial for producing more stable pseudo-labels and addressing the class-imbalance issue in SS-OD. ",
+        "bbox": [
+            174,
+            424,
+            823,
+            508
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We note that the class-imbalance issue is crucial when using pseudo-labeling method to address semi-supervised or other low-label object detection tasks. There indeed exist other class-imbalance methods that can potentially improve the performance, but we leave this for future research. ",
+        "bbox": [
+            176,
+            515,
+            823,
+            558
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            577,
+            326,
+            593
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Datasets. We benchmark our proposed method on experimental settings using MS-COCO (Lin et al., 2014) and PASCAL VOC (Everingham et al., 2010) following existing works (Jeong et al., 2019; Sohn et al., 2020b). Specifically, there are three experimental settings: (1) COCO-standard: we randomly sample 0.5, 1, 2, 5, and $10 \\%$ of labeled training data as a labeled set and use the rest of the data as the training unlabeled set. (2) COCO-additional: we use the standard labeled training set as the labeled set and the additional COCO2017-unlabeled data as the unlabeled set. (3) VOC: we use the VOC07 trainval set as the labeled training set and the VOC12 trainval set as the unlabeled training set. Model performance is evaluated on the VOC07 test set. ",
+        "bbox": [
+            174,
+            609,
+            825,
+            719
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Implementation Details. For a fair comparison, we follow STAC (Sohn et al., 2020b) to use FasterRCNN with FPN (Lin et al., 2017a) and ResNet-50 backbone (He et al., 2016) as our object detectior, where the feature weights are initialized by the ImageNet-pretrained model, same as existing works (Jeong et al., 2019; Sohn et al., 2020b). We use confidence threshold $\\delta = 0 . 7$ . For the data augmentation, we apply random horizontal flip for weak augmentation and randomly add color jittering, grayscale, Gaussian blur, and cutout patches for strong augmentations. Note that we do not apply any geometric augmentations, which are used in STAC. We use $A P _ { 5 0 : 9 5 }$ (denoted as mAP) as evaluation metric, and the performance is evaluated on the Teacher model. More training and implementation details can be found in the Appendix. ",
+        "bbox": [
+            174,
+            727,
+            825,
+            853
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            869,
+            277,
+            883
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "COCO-standard. We first evaluate the efficacy of our Unbiased Teacher on COCO-standard (Table 1). When there are only $0 . 5 \\%$ to $1 0 \\%$ of data labeled, our model consistently performs favorably against the state-of-the-art methods, CSD (Jeong et al., 2019) and STAC (Sohn et al., 2020b). It is worth noting that our model trained on $1 \\%$ labeled data achieves $2 0 . 7 5 \\%$ mAP, which is even higher than STAC trained on $2 \\%$ labeled data (mAP $1 8 . 2 5 \\%$ ), CSD trained on $5 \\%$ labeled data (mAP $1 8 . 5 7 \\%$ ), and the supervised baseline trained on $5 \\%$ labeled data (mAP $1 8 . 4 7 \\%$ ). We also observe that, as there are less labeled data, the improvements between our method and the existing approaches becomes larger. Unbiased Teacher consistently shows around 10 absolute mAP improvements when using less than $5 \\%$ of labeled data compared to supervised method. We attribute the improvements to several crucial factors: ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/4007e25433bf1e99ab4a711ba6f8e8cb26d4ef24a73cd5d6fe49757141ee9e0c.jpg",
+        "table_caption": [
+            "Table 2: Experimental results on COCO-additional comparing with CSD (Jeong et al., 2019) and STAC (Sohn et al., 2020b). \\*: we implement the CSD method and adapt it on the MS-COCO dataset. Note that 1x represents 90K training iterations, and $N \\mathbf { x }$ represents $N { \\times } 9 0 \\mathrm { K }$ training iterations. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\"></td><td colspan=\"5\">COCO-additional</td></tr><tr><td>Supervised (1x)</td><td>Supervised (3x)</td><td>CSD (3x)</td><td>STAC (6x)</td><td>Ours (3x)</td></tr><tr><td>AP50:95</td><td>37.63</td><td>40.20</td><td>38.82</td><td>39.21</td><td>41.30</td></tr></table>",
+        "bbox": [
+            236,
+            161,
+            763,
+            219
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/6a448004ebf6e555f29b1f5a65f89bf04374154ea1352f042dca80bbe487040d.jpg",
+        "image_caption": [
+            "Figure 4: Pseudo-label improvement on (a) accuracy, (b) mIoU, and (c) number of bounding boxes in the case of $C O C O$ -standard $1 \\%$ labeled data. We measure the (a) accuracy and (b) mIoU by comparing the ground-truth boxes and pseudo boxes. The Burn-In limit curves indicate the pseudoboxes obtained from the model right after the Burn-In stage without further refinement (i.e., the model trained on labeled data only). GT curve on the number of boxes figure indicates the averaged number of bounding boxes in the GT labels, and we showed that there are around 7 bounding boxes per image on average in MS-COCO. This result indicates our model can generate more accurate pseudo-labels after the Burn-In stage (i.e., 2k iterations). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            246,
+            823,
+            364
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            505,
+            825,
+            616
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "1) More accurate pseudo-labels. When leveraging the pseudo-labeling and consistency regularization between two networks (Teacher and Student in our case), it is critical to make sure pseudo-labels are accurate and reliable. Existing method attempts to do this by training the pseudo-label generation model using all the available labeled data and is completely frozen afterwards. In contrast, in our framework, our pseudo-label generation model (Teacher) continues to evolve gradually and smoothly via Teacher-Student Mutual Learning. This enables the Teacher to generate more accurate pseudo-labels as presented in Figure 4, which are properly exploited in the training of the Student. ",
+        "bbox": [
+            174,
+            623,
+            825,
+            722
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "2) Class-imbalance on pseudo-labels. Our improvement also comes from both the use of the EMA and the Focal loss (Lin et al., 2017b), which addresses the class-imbalanced pseudo-labeling issue. As mentioned in Sec. 3.3, using more balanced pseudo-labels not only avoids the consecutive biased prediction problem but also benefits the predictions on the minority classes. Later in Sec. 4.2, we present the details of the ablation study on the EMA and the Focal loss. ",
+        "bbox": [
+            174,
+            728,
+            825,
+            797
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "COCO-additional and VOC. In the previous section, we presented Unbiased Teacher can successfully leverage very small amounts of labeled data. We now aim to verify whether the model trained on $1 0 0 \\%$ supervised data can be further improved by using additional unlabeled data. We thus consider COCO-additional and VOC and present the results in Table 1 and 3. ",
+        "bbox": [
+            174,
+            805,
+            823,
+            861
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In the case of COCO-additional (Table 2), compared with supervised only model, our model has a 1.10 absolute AP improvement. We also found a similar trend in the VOC experiment (Table 3). With VOC07 as labeled set and VOC12 as an additional unlabeled set, STAC shows 2.51 absolute mAP improvement with respect to the supervised model, whereas our model demonstrates 6.56 absolute mAP improvement. To further examine whether increasing the size of unlabeled data can further improve the performance, we follow CSD and STAC to use COCO20cls dataset3 as an additional unlabeled set. STAC shows 3.88 absolute mAP improvement, while our model achieves 8.21 absolute mAP improvement. These results demonstrate that our model can further improve the object detector trained on existing labeled datasets by using more unlabeled data. Note that, following STAC, we use a more challenging metric, $A P _ { 5 0 : 9 5 }$ , which averages the ten values over $A P _ { 5 0 }$ to $A P _ { 9 5 }$ since the metric of $A P _ { 5 0 }$ has been indicated as a saturated metric by the prior work (Cai & Vasconcelos, 2018; Sohn et al., 2020b). ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/d2a02523761d322275df1e93f67943950b743c55811f3dc62635223e98217854.jpg",
+        "table_caption": [
+            "Table 3: Results on VOC comparing with CSD (Jeong et al., 2019) and STAC (Sohn et al., 2020b). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>Backbone</td><td>Labeled</td><td>Unlabeled</td><td>AP50</td><td>AP50:95</td></tr><tr><td>Supervised (from Ours)</td><td>ResNet50-FPN</td><td>VOC07</td><td>None</td><td>72.63</td><td>42.13</td></tr><tr><td>CSD</td><td>ResNet101-R-FCN</td><td rowspan=\"3\">VOC07</td><td rowspan=\"3\">VOC12</td><td>74.70 (+2.07)</td><td>1</td></tr><tr><td>STAC</td><td>ResNet50-FPN ResNet50-FPN</td><td>77.45 (+4.82)</td><td>44.64 (+2.51)</td></tr><tr><td>Unbiased Teacher</td><td></td><td>77.37 (+4.74)</td><td>48.69 (+6.56)</td></tr><tr><td>CSD</td><td>ResNet101-R-FCN</td><td rowspan=\"3\">VOC07</td><td>VOC12</td><td>75.10 (+2.47)</td><td>1</td></tr><tr><td>STAC</td><td>ResNet50-FPN</td><td>+</td><td>79.08 (+6.45)</td><td>46.01 (+3.88)</td></tr><tr><td>Unbiased Teacher</td><td>ResNet50-FPN</td><td>COC020cls</td><td>78.82 (+6.19)</td><td>50.34 (+8.21)</td></tr></table>",
+        "bbox": [
+            202,
+            127,
+            790,
+            262
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/be922bddd41d90b7e021568577d4b7ef678fa14785ed7eb5e97fec9efc6ebc76.jpg",
+        "image_caption": [
+            "Figure 5: Ablation study on the EMA and the Focal loss in the case of COCO-standard $1 \\%$ labeled data. (a) mAP of the models using the Focal loss or cross-entropy and applying the EMA or standard training. (b) Class empirical distribution (i.e., histogram) of pseudo-labels generated by each model and compute $\\kappa \\mathcal { L }$ -divergence between the ground-truth labels distribution and the pseudo-label distribution. Among these models, the model using the Focal loss and EMA training (i.e., green curve) achieves the best mAP with the most balanced pseudo-labels . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            165,
+            276,
+            831,
+            438
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            530,
+            825,
+            642
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.2 ABLATION STUDY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            660,
+            341,
+            674
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Effect of the EMA training. We first examine the effect of EMA training and present a comparison between our model with EMA and without EMA. Our model without EMA is where the model weights of Teacher and Student are shared during the training stage, and it implies the Teacher model is also updated when the student model is optimized by using unlabeled data and pseudolabels. Note that the state-of-the-art semi-supervised classification model, FixMatch (Sohn et al., 2020a) similarly shares the model weights of the Teacher and the Student models. ",
+        "bbox": [
+            174,
+            685,
+            825,
+            768
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "From Figure 5, we observe that our model with EMA is superior to without EMA, and this trend can be found both in the model using the Focal loss and cross-entropy. To further analyze the diverged results, we visualize the class distribution of pseudo-labels generated by each model and measure the $\\kappa \\mathcal { L }$ -divergence between the ground-truth labels distribution and the pseudo-labels distribution. With the use of cross-entropy and standard training (i.e., without EMA training), the model generates the imbalanced pseudo-labels. To be more specific, the instances of most object categories in pseudolabels disappear, while only instances of specific object categories remain. We observe that using the EMA training can alleviate the imbalanced pseudo-labels issue and reduces the $\\kappa \\mathcal { L }$ -divergence from 1.7915 to 0.2482. On the other hand, we also observe that the model with EMA has a smoother learning curve compared with the model without EMA. This is because the model weight of the pseudo-label generation model (Teacher) is detached from the optimized model (Student). The pseudo-label generation model can thus prevent the detrimental effect caused by the noisy pseudolabels (e.g., false positive boxes) as we describe in Sec. 3.2. ",
+        "bbox": [
+            173,
+            775,
+            825,
+            887
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            172
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In sum, the EMA training has several advantages: it 1) prevents the imbalanced pseudo-labels issue caused by the imbalanced nature in low-labeled object detection tasks, 2) prevents the detrimental effect caused by the noisy pseudo-labels, and 3) the Teacher model can be regarded as the temporal ensembles model of Student models in different time steps. ",
+        "bbox": [
+            174,
+            180,
+            823,
+            236
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Effect of the Focal loss. In addition to the EMA training, we also verify the effectiveness of the Focal loss. As presented in Figure 5, the model using Focal loss can perform favorably against the model using cross-entropy. The model trained with the Focal loss can generate the pseudo-label which distribution is more similar to the distribution of ground-truth labels, and it can improve the $\\kappa \\mathcal { L }$ -divergence from 1.7915 (Cross entropy w/o EMA) to 0.2001 (Focal loss w/o EMA) and mAP from 13.42 to 17.85. When EMA training is applied, the $\\kappa \\mathcal { L }$ -divergence of the model with the Focal loss can be further improved from 0.2482 (Cross entropy w/ EMA) to 0.0851 (Focal loss w/ EMA) and mAP improve from 16.91 to 21.19. This confirms the effectiveness of the Focal loss in handling the class imbalance issues existed in the semi-supervised object detection. The reduction of $\\kappa \\mathcal { L }$ -divergence (i.e., better-fitting pseudo-label distributions to ground-truth label distributions) results in the mAP improvement. ",
+        "bbox": [
+            173,
+            243,
+            825,
+            396
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Other ablation studies. We also ablate the effects of the Burn-In stage, pseudo-labeling thresholding, EMA rates, and unsupervised loss weights in the Appendix. ",
+        "bbox": [
+            173,
+            404,
+            821,
+            431
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            450,
+            318,
+            467
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we revisit the semi-supervised object detection task. By analyzing the object detectors in low-labeled scenarios, we identify and address two major issues: overfitting and class imbalance. We proposed Unbiased Teacher — a unified framework consisting of a Teacher and a Student that jointly learn to improve each other. In the experiments, we show our model prevents pseudo-labeling bias issue caused by class imbalance and overfitting issue due to labeled data scarcity. Our Unbiased Teacher achieves satisfactory performance across multiple semi-supervised object detection datasets. ",
+        "bbox": [
+            173,
+            481,
+            825,
+            579
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            598,
+            387,
+            613
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yen-Cheng Liu and Zsolt Kira were partly supported by DARPA’s Learning with Less Labels (LwLL) program under agreement HR0011-18-S-0044, as part of their affiliation with Georgia Tech. ",
+        "bbox": [
+            176,
+            627,
+            823,
+            670
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            690,
+            285,
+            705
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "David Berthelot, Nicholas Carlini, Ian Goodfellow, Nicolas Papernot, Avital Oliver, and Colin A Raffel. Mixmatch: A holistic approach to semi-supervised learning. In Advances in Neural Information Processing Systems (NeurIPS), pp. 5049–5059, 2019.   \nDavid Berthelot, Nicholas Carlini, Ekin D Cubuk, Alex Kurakin, Kihyuk Sohn, Han Zhang, and Colin Raffel. Remixmatch: Semi-supervised learning with distribution alignment and augmentation anchoring. In Advances in Neural Information Processing Systems (NeurIPS), 2020.   \nZhaowei Cai and Nuno Vasconcelos. Cascade r-cnn: Delving into high quality object detection. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2018.   \nTerrance DeVries and Graham W Taylor. Improved regularization of convolutional neural networks with cutout. arXiv preprint arXiv:1708.04552, 2017.   \nMark Everingham, Luc Van Gool, Christopher KI Williams, John Winn, and Andrew Zisserman. The pascal visual object classes (voc) challenge. International Journal of Computer Vision (IJCV), 88(2):303–338, 2010. ",
+        "bbox": [
+            173,
+            713,
+            826,
+            922
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jiyang Gao, Jiang Wang, Shengyang Dai, Li-Jia Li, and Ram Nevatia. Note-rcnn: Noise tolerant ensemble rcnn for semi-supervised object detection. In Proceedings of the IEEE international conference on computer vision (ICCV), pp. 9508–9517, 2019. ",
+        "bbox": [
+            176,
+            103,
+            821,
+            146
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yves Grandvalet and Yoshua Bengio. Semi-supervised learning by entropy minimization. In Advances in neural information processing systems (NeurIPS), pp. 529–536, 2005. ",
+        "bbox": [
+            173,
+            155,
+            823,
+            184
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jean-Bastien Grill, Florian Strub, Florent Altche, Corentin Tallec, Pierre H Richemond, Elena ´ Buchatskaya, Carl Doersch, Bernardo Avila Pires, Zhaohan Daniel Guo, Mohammad Gheshlaghi Azar, et al. Bootstrap your own latent: A new approach to self-supervised learning. arXiv preprint arXiv:2006.07733, 2020. ",
+        "bbox": [
+            173,
+            193,
+            825,
+            250
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hongyu Guo, Yongyi Mao, and Richong Zhang. Mixup as locally linear out-of-manifold regularization. In Proceedings of the AAAI Conference on Artificial Intelligence (AAAI), volume 33, pp. 3714–3722, 2019. ",
+        "bbox": [
+            173,
+            258,
+            825,
+            303
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2016. ",
+        "bbox": [
+            173,
+            310,
+            826,
+            354
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Georgia Gkioxari, Piotr Dollar, and Ross Girshick. Mask r-cnn. In ´ Proceedings of the IEEE international conference on computer vision (ICCV), pp. 2961–2969, 2017. ",
+        "bbox": [
+            169,
+            363,
+            823,
+            393
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Haoqi Fan, Yuxin Wu, Saining Xie, and Ross Girshick. Momentum contrast for unsupervised visual representation learning. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pp. 9729–9738, 2020. ",
+        "bbox": [
+            176,
+            401,
+            823,
+            445
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Dan Hendrycks, Norman Mu, Ekin D. Cubuk, Barret Zoph, Justin Gilmer, and Balaji Lakshminarayanan. AugMix: A simple data processing method to improve robustness and uncertainty. Proceedings of the International Conference on Learning Representations (ICLR), 2020. ",
+        "bbox": [
+            178,
+            453,
+            823,
+            497
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Judy Hoffman, Sergio Guadarrama, Eric S Tzeng, Ronghang Hu, Jeff Donahue, Ross Girshick, Trevor Darrell, and Kate Saenko. Lsda: Large scale detection through adaptation. In Advances in Neural Information Processing Systems ((NeurIPS)), pp. 3536–3544, 2014. ",
+        "bbox": [
+            174,
+            505,
+            823,
+            549
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In Proceedings of the International Conference on Machine Learning (ICML), 2015. ",
+        "bbox": [
+            174,
+            558,
+            825,
+            601
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jisoo Jeong, Seungeui Lee, Jeesoo Kim, and Nojun Kwak. Consistency-based semi-supervised learning for object detection. In Advances in Neural Information Processing Systems (NeurIPS), 2019. ",
+        "bbox": [
+            174,
+            609,
+            825,
+            652
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Borui Jiang, Ruixuan Luo, Jiayuan Mao, Tete Xiao, and Yuning Jiang. Acquisition of localization confidence for accurate object detection. In Proceedings of the European Conference on Computer Vision (ECCV), 2018. ",
+        "bbox": [
+            173,
+            661,
+            825,
+            705
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In Proceedings of the International Conference on Learning Representations (ICLR), 2015. ",
+        "bbox": [
+            171,
+            714,
+            825,
+            743
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Chia-Wen Kuo, Chih-Yao Ma, Jia-Bin Huang, and Zsolt Kira. Featmatch: Feature-based augmentation for semi-supervised learning. In Proceedings of the European Conference on Computer Vision (ECCV), 2020. ",
+        "bbox": [
+            173,
+            752,
+            823,
+            795
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Samuli Laine and Timo Aila. Temporal ensembling for semi-supervised learning. In Proceedings of the International Conference on Learning Representations (ICLR), 2017. ",
+        "bbox": [
+            171,
+            804,
+            823,
+            834
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hei Law and Jia Deng. Cornernet: Detecting objects as paired keypoints. In Proceedings of the European Conference on Computer Vision (ECCV), 2018. ",
+        "bbox": [
+            171,
+            843,
+            825,
+            872
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Dong-Hyun Lee. Pseudo-label: The simple and efficient semi-supervised learning method for deep neural networks. In Workshop on Challenges in Representation Learning, ICML, volume 3, pp. 2, 2013. ",
+        "bbox": [
+            174,
+            881,
+            823,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yu Li, Tao Wang, Bingyi Kang, Sheng Tang, Chunfeng Wang, Jintao Li, and Jiashi Feng. Overcoming classifier imbalance for long-tail object detection with balanced group softmax. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2020. ",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tsung-Yi Lin, Michael Maire, Serge Belongie, James Hays, Pietro Perona, Deva Ramanan, Piotr Dollar, and C Lawrence Zitnick. Microsoft coco: Common objects in context. In ´ Proceedings of the European Conference on Computer Vision (ECCV), 2014. ",
+        "bbox": [
+            176,
+            156,
+            823,
+            200
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tsung-Yi Lin, Piotr Dollar, Ross Girshick, Kaiming He, Bharath Hariharan, and Serge Belongie.´ Feature pyramid networks for object detection. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2017a. ",
+        "bbox": [
+            173,
+            210,
+            826,
+            253
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tsung-Yi Lin, Priya Goyal, Ross Girshick, Kaiming He, and Piotr Dollar. Focal loss for dense object ´ detection. In Proceedings of the IEEE international conference on computer vision (CVPR), pp. 2980–2988, 2017b. ",
+        "bbox": [
+            173,
+            263,
+            823,
+            306
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Wei Liu, Dragomir Anguelov, Dumitru Erhan, Christian Szegedy, Scott Reed, Cheng-Yang Fu, and Alexander C Berg. Ssd: Single shot multibox detector. In European conference on computer vision (ECCV), pp. 21–37. Springer, 2016. ",
+        "bbox": [
+            173,
+            318,
+            825,
+            361
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ishan Misra, Abhinav Shrivastava, and Martial Hebert. Watch and learn: Semi-supervised learning for object detectors from video. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 3593–3602, 2015. ",
+        "bbox": [
+            173,
+            371,
+            826,
+            415
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Takeru Miyato, Shin-ichi Maeda, Masanori Koyama, and Shin Ishii. Virtual adversarial training: a regularization method for supervised and semi-supervised learning. IEEE transactions on pattern analysis and machine intelligence (PAMI), 41(8):1979–1993, 2018. ",
+        "bbox": [
+            173,
+            425,
+            823,
+            469
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kemal Oksuz, Baris Can Cam, Sinan Kalkan, and Emre Akbas. Imbalance problems in object detection: A review. IEEE Transactions on Pattern Analysis and Machine Intelligence, 2020. ",
+        "bbox": [
+            171,
+            478,
+            825,
+            508
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Siyuan Qiao, Wei Shen, Zhishuai Zhang, Bo Wang, and Alan Yuille. Deep co-training for semisupervised image recognition. In Proceedings of the European Conference on Computer Vision (ECCV), pp. 135–152, 2018. ",
+        "bbox": [
+            174,
+            517,
+            825,
+            563
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Joseph Redmon and Ali Farhadi. Yolo9000: better, faster, stronger. In Proceedings of the IEEE conference on computer vision and pattern recognition (CVPR), pp. 7263–7271, 2017. ",
+        "bbox": [
+            173,
+            571,
+            823,
+            602
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Joseph Redmon and Ali Farhadi. Yolov3: An incremental improvement. arXiv preprint arXiv:1804.02767, 2018. ",
+        "bbox": [
+            171,
+            612,
+            823,
+            641
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Shaoqing Ren, Kaiming He, Ross Girshick, and Jian Sun. Faster r-cnn: Towards real-time object detection with region proposal networks. In Advances in neural information processing systems (NeurIPS), pp. 91–99, 2015. ",
+        "bbox": [
+            173,
+            651,
+            823,
+            695
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Chuck Rosenberg, Martial Hebert, and Henry Schneiderman. Semi-supervised self-training of object detection models. In 2005 Seventh IEEE Workshops on Applications of Computer Vision, volume 1, pp. 29–36, 2005. ",
+        "bbox": [
+            174,
+            707,
+            823,
+            748
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Mehdi Sajjadi, Mehran Javanmardi, and Tolga Tasdizen. Regularization with stochastic transformations and perturbations for deep semi-supervised learning. In Advances in Neural Information Processing Systems (NeurIPS), pp. 1163–1171, 2016. ",
+        "bbox": [
+            173,
+            760,
+            825,
+            804
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Abhinav Shrivastava, Abhinav Gupta, and Ross Girshick. Training region-based object detectors with online hard example mining. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2016. ",
+        "bbox": [
+            173,
+            813,
+            823,
+            857
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kihyuk Sohn, David Berthelot, Chun-Liang Li, Zizhao Zhang, Nicholas Carlini, Ekin D Cubuk, Alex Kurakin, Han Zhang, and Colin Raffel. Fixmatch: Simplifying semi-supervised learning with consistency and confidence. In Advances in Neural Information Processing Systems (NeurIPS), 2020a. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            922
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kihyuk Sohn, Zizhao Zhang, Chun-Liang Li, Han Zhang, Chen-Yu Lee, and Tomas Pfister. A simple semi-supervised learning framework for object detection. arXiv preprint arXiv:2005.04757, 2020b. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            145
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Peng Tang, Chetan Ramaiah, Ran Xu, and Caiming Xiong. Proposal learning for semi-supervised object detection. arXiv preprint arXiv:2001.05086, 2020. ",
+        "bbox": [
+            171,
+            155,
+            825,
+            184
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yuxing Tang, Josiah Wang, Boyang Gao, Emmanuel Dellandrea, Robert Gaizauskas, and Liming ´ Chen. Large scale semi-supervised object detection using visual and semantic knowledge transfer. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 2119–2128, 2016. ",
+        "bbox": [
+            174,
+            193,
+            826,
+            248
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Antti Tarvainen and Harri Valpola. Mean teachers are better role models: Weight-averaged consistency targets improve semi-supervised deep learning results. In Advances in neural information processing systems (NeurIPS), pp. 1195–1204, 2017. ",
+        "bbox": [
+            174,
+            258,
+            825,
+            301
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yuxin Wu, Alexander Kirillov, Francisco Massa, Wan-Yen Lo, and Ross Girshick. Detectron2. https://github.com/facebookresearch/detectron2, 2019. ",
+        "bbox": [
+            176,
+            309,
+            821,
+            338
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Qizhe Xie, Minh-Thang Luong, Eduard Hovy, and Quoc V Le. Self-training with noisy student improves imagenet classification. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2020. ",
+        "bbox": [
+            174,
+            347,
+            825,
+            390
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Bing Yu, Jingfeng Wu, Jinwen Ma, and Zhanxing Zhu. Tangent-normal adversarial regularization for semi-supervised learning. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 10676–10684, 2019. ",
+        "bbox": [
+            173,
+            398,
+            826,
+            441
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Sangdoo Yun, Dongyoon Han, Seong Joon Oh, Sanghyuk Chun, Junsuk Choe, and Youngjoon Yoo. Cutmix: Regularization strategy to train strong classifiers with localizable features. In Proceedings of the IEEE International Conference on Computer Vision (ICCV), pp. 6023–6032, 2019. ",
+        "bbox": [
+            176,
+            450,
+            823,
+            493
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Hongyi Zhang, Moustapha Cisse, Yann N Dauphin, and David Lopez-Paz. mixup: Beyond empirical risk minimization. In Proc. International Conference on Learning Representations (ICLR), 2018. ",
+        "bbox": [
+            169,
+            501,
+            823,
+            531
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Zhun Zhong, Liang Zheng, Guoliang Kang, Shaozi Li, and Yi Yang. Random erasing data augmentation. arXiv preprint arXiv:1708.04896, 2017. ",
+        "bbox": [
+            171,
+            540,
+            823,
+            569
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A APPENDIX ",
+        "bbox": [
+            176,
+            102,
+            297,
+            117
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A.1 EMA ON IMBALANCED PSEUDO-LABELING ISSUE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            171,
+            562,
+            184
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "To empirically examine the effectiveness of EMA on imbalance, we present the pseudo-label distribution in different training iterations as presented in Figure 6. At the beginning of training (i.e., 30k), both Teacher models with and without EMA could generate the balanced pseudo-labels (the KL divergence between ground-truth labels and pseudo-labels are both small). However, since the Student model is trained with the pseudo-labels generated by the Teacher models, the model without EMA starts biasing towards specific classes. In contrast, with the EMA training, the model generates less imbalanced pseudo-labels. Note that, although the EMA is applied, the balance issue still exists. We thus apply Focal loss to enhance the ability to mitigate the imbalance issue further. ",
+        "bbox": [
+            173,
+            195,
+            825,
+            308
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/8c66018ff39bcc905db717d1459ba275913e67adbdbb062381a9234b158d0e8b.jpg",
+        "image_caption": [
+            "Figure 6: Ablation study on EMA at different training iterations. Both the models with EMA and without EMA have pseudo-label distributions, which are similar to the ground-truth distributions in the early stage of training iterations. However, the model without EMA tends to generate more biased pseudo-label distribution later during training. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            194,
+            319,
+            774,
+            579
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A.2 ADDITIONAL ABLATION STUDY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            655,
+            439,
+            669
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In addition to the ablation studies provided in the main paper, we further ablate Unbiased Teacher in the following sections. ",
+        "bbox": [
+            174,
+            681,
+            821,
+            710
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A.2.1 EFFECT OF BURN-IN STAGE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            728,
+            426,
+            742
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "As mentioned in Section 3.1, it is crucial to have a good initialization for both Student and Teacher models. We thus present a comparison between the model with and without the Burn-In stage in Figure 7. We observe that, with the Burn-In stage, the model can derive more accurate pseudo-boxes in the early stage of the training. As a result, the model can achieve higher accuracy in the early stage of the training, and it also achieves better results when the model is converged. ",
+        "bbox": [
+            174,
+            753,
+            825,
+            824
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A.2.2 EFFECT OF PSEUDO-LABELING THRESHOLD ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            842,
+            540,
+            857
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "As mentioned in Section 3.3, we apply confidence thresholding to filter these low-confidence predicted bounding boxes, which are more likely to be false-positive instances. To show the effectiveness of thresholding, we first provide the accuracy of predicted bounding boxes before and after the pseudo-labeling in Figure 8. ",
+        "bbox": [
+            176,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/ad0b577dcf3b79e1d30a56ea6e45a0681e88b573a42250b897db93ae7b6df28f.jpg",
+        "image_caption": [
+            "Figure 7: In the case of $C O C O$ -standard $1 \\%$ labeled data, (a) Unbiased Teacher with Burn-In stage achieve higher mAP against Unbiased Teacher without Burn-In stage. Using Burn-In Stage results in the early improvement of (b) box accuracy and (c) mIoU. (d) Unbiased Teacher with Burn-In stage can derive more pseudo-boxes than Unbiased Teacher without Burn-In stage. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            214,
+            108,
+            781,
+            467
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/0eb3b49413c21aed94c0e4d005e9e4abc2c5254796681119fbf32a6ad8f77f46.jpg",
+        "image_caption": [
+            "Figure 8: Pseudo-label accuracy improvement with the use of confidence thresholding. We measure the accuracy by comparing the ground-truth labels and predicted labels before and after confidence thresholding. This result indicates that confidence thresholding can significantly improve the quality of pseudo-labels. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            339,
+            554,
+            653,
+            710
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "When varying the threshold value $\\delta$ from 0 to 0.9, as expected, the number of generated pseudoboxes increases as the threshold $\\delta$ reduces (Figure 9). The model using excessively high threshold (e.g., $\\delta \\ : = \\ : 0 . 9 $ ) cannot perform satisfactory results, as the number of generated pseudo-labels is very low. On the other hand, the model using a low threshold (e.g., $\\delta = 0 . 6$ ) also cannot achieve favorable results since the model generates too many bounding boxes, which are likely to be falsepositive instances. We also observe that the model cannot even converge if the threshold is below 0.5. ",
+        "bbox": [
+            173,
+            825,
+            825,
+            922
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/bf9b4c94616e04dc7472b854643e99875718344a8755433a7ba7324efd05841e.jpg",
+        "image_caption": [
+            "Figure 9: (a) Validation AP and (b) number of pseudo-label bounding boxes per image with various pseudo-labeling thresholds $\\delta$ . With an excessively low threshold (e.g., $\\delta = 0 . 6$ ), the model has a lower AP, as it predicts more pseudo-labeled bounding boxes compared to the number of bounding boxes in ground-truth labels. On the other hand, the performance of the model using an excessively high threshold (e.g., $\\delta = 0 . 9$ ) drops as it cannot predict sufficient number of bounding boxes in its generated pseudo-labels. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            89,
+            818,
+            261
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "A.2.3 EFFECT OF EMA RATES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            378,
+            400,
+            392
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "We also evaluate the model using various EMA rate $\\alpha$ from 0.5 to 0.9999 and present the mAP result of the Teacher model in Figure 10. We observe that, with a smaller EMA rate (e.g., $\\alpha = 0 . 5$ ), the model has lower mAP and higher variance, as the Student contributes more to the Teacher model for each iteration. This implies the Teacher model is likely to suffer from the detrimental effect caused by noisy pseudo-labels. This unstable learning curve can be stabilized and improved as the EMA rate $\\alpha$ increases. When the EMA rate $\\alpha$ achieves 0.99, it performs the best mAP. However, if the EMA rate $\\alpha$ keeps increasing, the teacher model will grow overly slow as the Teacher model derive the next model weight mostly from the previous Teacher model weight. ",
+        "bbox": [
+            173,
+            405,
+            826,
+            517
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/d503bf0212abfc65305c79627f753df496e9ec7a00e7abe32048bb7fac5e032a.jpg",
+        "image_caption": [
+            "Figure 10: Validation AP on the Teacher model with various MMA rates $\\alpha$ . (a) With a small MMA rate (e.g., $\\alpha = 0 . 5$ ), the Teacher model has lower AP and larger variance. In contrast, as the MMA rate grows to 0.99, the Teacher model can gradually improve along the training iterations. However, when the MMA grows to 0.9999, the Teacher model grows overly slow but has lowest variance. (b) We breakdown the AP metric into APs from $A P _ { 5 0 }$ to $A P _ { 9 5 }$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            540,
+            838,
+            718
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "A.2.4 EFFECT OF UNSUPERVISED LOSS WEIGHTS",
+        "text_level": 1,
+        "bbox": [
+            174,
+            827,
+            532,
+            842
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "To examine the effect unsupervised loss weights, we vary the unsupervised loss weight $\\lambda _ { u }$ from 1.0 to 8.0 in the case of $C O C O$ -standard $1 0 \\%$ labeled data. As shown in Table 4, with a lower unsupervised loss weight $\\lambda _ { u } = 1 . 0$ , the model performs $2 9 . 3 0 \\%$ . On the other hand, we observe that the model performs the best with unsupervised loss weight $\\lambda = 5 . 0$ . However, when the weight increases to 8.0, the training of the model cannot converge. ",
+        "bbox": [
+            174,
+            853,
+            825,
+            924
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/caa4386822bd9e68df07e3e4b8a211b17e42f8f4d0c00799d64048a236d435ca.jpg",
+        "table_caption": [
+            "Table 4: Ablation study of varying unsupervised loss weight $\\lambda _ { u }$ on the model trained using $1 0 \\%$ labeled and $9 0 \\%$ unlabeled data. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>入u</td><td>1.0</td><td>2.0</td><td>4.0</td><td>5.0</td><td>6.0</td><td>8.0</td></tr><tr><td>AP(%)</td><td>29.30</td><td>30.64</td><td>31.82</td><td>32.00</td><td>31.80</td><td>Cannot Converge</td></tr></table>",
+        "bbox": [
+            251,
+            148,
+            740,
+            196
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "A.3 AP BREAKDOWN FOR COCO-STANDARD ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            226,
+            503,
+            239
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "We present an AP breakdown for COCO-standard $0 . 5 \\%$ labeled data. As mentioned in Section 4, our proposed model can perform favorably against both STAC (Sohn et al., 2020b) and CSD (Jeong et al., 2019). This trend appears in all evaluation metrics from $A P _ { 5 0 }$ to $A P _ { 9 5 }$ , as shown in Figure 11, and it confirms that our model is preferable for handling extremely low-label scenario compared to the state of the arts. ",
+        "bbox": [
+            174,
+            252,
+            825,
+            324
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/4d3b72fa84190227bca23d5caa8b1d806600fe3fa37368cb21899d4e56818f2a.jpg",
+        "image_caption": [
+            "Figure 11: Evaluation metric breakdown of all methods on $0 . 5 \\%$ labeled data. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            343,
+            344,
+            653,
+            489
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "A.4 IMPLEMENTATION AND TRAINING DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            568,
+            521,
+            582
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Network and framework. Our implementation builds upon the Detectron2 framework (Wu et al., 2019). For a fair comparison, we follow the prior work (Sohn et al., 2020b) to use Faster-RCNN with FPN (Lin et al., 2017a) and ResNet-50 backbone (He et al., 2016) as our object detection network. ",
+        "bbox": [
+            174,
+            595,
+            825,
+            637
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Training. At the beginning of the Burn-In stage, the feature backbone network weights are initialized by the ImageNet-pretrained model, which is same as existing works (Jeong et al., 2019; Tang et al., 2020; Sohn et al., 2020b). We use the SGD optimizer with a momentum rate 0.9 and a learning rate 0.01, and we use constant learning rate scheduler. The batch size of supervised and unsupervised data are both 32 images. For the COCO-standard, we train 180k iterations, which includes $1 / 2 / 6 / 1 2 / 2 0 \\mathbf { k }$ iterations for $0 . 5 \\% / 1 \\% / 2 \\% / 5 \\% / 1 0 \\%$ in the Burn-In stage and the remaining iterations in the Teacher-Student Mutual Learning stage. For the COCO-additional, we train $3 6 0 \\mathrm { k }$ iterations, which includes $9 0 \\mathrm { k }$ iterations in the Burn-Up stage and the remaining $2 7 0 \\mathrm { k }$ iterations in the Teacher-Student Mutual Learning stage. ",
+        "bbox": [
+            173,
+            645,
+            825,
+            771
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Hyper-parameters. We use confidence threshold $\\delta \\ : = \\ : 0 . 7$ to generate pseudo-labels for all our experiments, the unsupervised loss weight $\\lambda _ { u } = 4$ is applied for $C O C O$ -standard and VOC, and the unsupervised loss weight $\\lambda _ { u } = 2$ is applied for $C O C O$ -additional. We apply $\\alpha = 0 . 9 9 9 6$ as the EMA rate for all our experiments. Hyper-parameters used are summarized in Table 5. ",
+        "bbox": [
+            173,
+            776,
+            823,
+            833
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Data augmentation. As shown in Table 6, we apply randomly horizontal flip for weak augmentation and randomly add color jittering, grayscale, Gaussian blur, and cutout patches (DeVries & Taylor, 2017) for the strong augmentation. Note that we do not apply any image-level or box-level geometric augmentations, which are used in STAC (Sohn et al., 2020b). In addition, we do not aggressively search the best hyper-parameters for data augmentations, and it is possible to obtain better hyperparameters. ",
+        "bbox": [
+            173,
+            839,
+            825,
+            924
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "table",
+        "img_path": "images/98cda4bb6ba6bbb885d9bc6ae161f04946f195d6d952d4c2c53c92f8761fc72c.jpg",
+        "table_caption": [
+            "Table 5: Meanings and values of the hyper-parameters used in experiments. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Hyper-parameter</td><td>Description</td><td>COCO-standard and VOC</td><td>COCO-additional</td></tr><tr><td>8</td><td>Confidence threshold</td><td>0.7</td><td>0.7</td></tr><tr><td>入u</td><td>Unsupervised loss weight</td><td>4</td><td>2</td></tr><tr><td>a</td><td>EMA rate</td><td>0.9996</td><td>0.9996</td></tr><tr><td>b</td><td>Batch size for labeled data</td><td>32</td><td>16</td></tr><tr><td>bu</td><td>Batch size for unlabeled data</td><td>32</td><td>16</td></tr><tr><td>Y</td><td>Learning rate</td><td>0.01</td><td>0.01</td></tr></table>",
+        "bbox": [
+            210,
+            127,
+            789,
+            250
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "table",
+        "img_path": "images/fe57a41f517952bc0e214a0e98d4affe63513a3b914835f42df9b10ee8e3acd1.jpg",
+        "table_caption": [
+            "Table 6: Detail of data augmentations. Probability in the table indicates the probability of applying the corresponding image process. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"4\">Weak Augmentation</td></tr><tr><td>Process</td><td>Probability</td><td>Parameters</td><td>Descriptions</td></tr><tr><td>Horizontal Flip</td><td>0.5</td><td>-</td><td>None</td></tr><tr><td colspan=\"4\">Strong Augmentation</td></tr><tr><td>Process</td><td>Probability</td><td>Parameters</td><td>Descriptions</td></tr><tr><td>Color Jittering</td><td>0.8</td><td>(brightness,contrast, saturation, hue) =(0.4,0.4,0.4,0.1)</td><td>Brightness factor is chosen uniformly from [O.6,1.4], contrast factor is chosen uniformly from [O.6,1.4], saturation factor is chosen uniformly from [O.6,1.4], and hue value is chosen uniformly from[-O.1, 0.1].</td></tr><tr><td>Grayscale</td><td>0.2</td><td>None</td><td>None</td></tr><tr><td>GaussianBlur</td><td>0.5</td><td>(sigma_x,sigma_y)=(0.1,2.0)</td><td>Gaussian filter with ox = O.1 and σy= 2.O is applied.</td></tr><tr><td>CutoutPattern1</td><td>0.7</td><td>scale=(0.05,0.2),ratio=(0.3,3.3)</td><td>Randomly selects a rectangle region in an image and erases its pixels.We refer the detail in Zhong et al. (2017).</td></tr><tr><td>CutoutPattern2</td><td>0.5</td><td>scale=(0.02,0.2),ratio=(0.1,6)</td><td>Randomly selects a rectangle region in an image and erases its pixels.We refer the detail in Zhong et al.(2017).</td></tr><tr><td>CutoutPattern3</td><td>0.3</td><td>scale=(0.02,0.2),ratio=(0.05,8)</td><td>Randomly selects a rectangle region in an image and erases its pixels.We refer the detail in Zhong et al.(2017).</td></tr></table>",
+        "bbox": [
+            174,
+            311,
+            825,
+            540
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "Evaluation Metrics. $A P _ { 5 0 : 9 5 }$ is used to evaluate all methods following the prior works (Law & Deng, 2018; Sohn et al., 2020b). ",
+        "bbox": [
+            174,
+            565,
+            823,
+            594
+        ],
+        "page_idx": 16
+    }
+]

parse/train/MbM_gvIB3Y4/MbM_gvIB3Y4.md

@@ -0,0 +1,459 @@
+# WHICH MUTUAL-INFORMATION REPRESENTATION LEARNING OBJECTIVES ARE SUFFICIENT FOR CONTROL?
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Mutual information maximization provides an appealing formalism for learning representations of data. In the context of reinforcement learning, such representations can accelerate learning by discarding irrelevant and redundant information, while retaining the information necessary for control. Much of the prior work on these methods has addressed the practical difficulties of estimating mutual information from samples of high-dimensional observations, while comparatively less is understood about which mutual information objectives are sufficient for reinforcement learning (RL) from a theoretical perspective. In this paper we identify conditions under which representations that maximize specific mutual-information objectives are theoretically sufficient for learning and representing the optimal policy. Somewhat surprisingly, we find that several popular objectives can yield insufficient representations given mild and common assumptions on the structure of the MDP. We corroborate our theoretical results with empirical results experiments on a simulated game environment with visual observations.
+
+# 1 INTRODUCTION
+
+While deep reinforcement learning (RL) algorithms are capable of learning policies from highdimensional observations, such as images (Mnih et al., 2013; Lee et al., 2019; Kalashnikov et al., 2018), in practice policy learning faces a bottleneck in acquiring useful representations of the observation space (Shelhamer et al., 2016). State representation learning approaches aim to remedy this issue by learning structured and compact representations on which to perform RL. While a wide range of representation learning objectives have been proposed (Lesort et al., 2018), a particularly appealing class of methods that is amenable to rigorous analysis is based on maximizing mutual information (MI) between variables. In the unsupervised learning setting, this is often realized as the InfoMax principle (Linsker, 1988; Bell & Sejnowski, 1995), which maximizes the mutual information between the input and its latent representation subject to domain-specific constraints. This approach has been widely applied in unsupervised learning in the domains of image, audio, and natural language understanding (Oord et al., 2018; Hjelm et al., 2018; Ravanelli & Bengio, 2019). In RL, the variables of interest for MI maximization are sequential states, actions, and rewards (see Figure 1). As we will discuss, several popular methods for representation learning in RL involve mutual information maximization with different combinations of these variables (Anand et al., 2019; Oord et al., 2018; Pathak et al., 2017; Shelhamer et al., 2016).
+
+A useful representation should retain the factors of variation that are necessary to learn and represent the optimal policy or the optimal value function, and discard irrelevant and redundant information. While much prior work has focused on the problem of how to optimize various mutual information objectives in high dimensions (Song & Ermon, 2019; Belghazi et al., 2018; Oord et al., 2018; Hjelm et al., 2018), we focus instead on whether the representations that maximize these objectives are actually theoretically sufficient for learning and representing the optimal policy or value function. We find that some commonly used objectives are insufficient given relatively mild and common assumptions on the structure of the MDP, and identify other objectives which are sufficient. We show these results theoretically and illustrate the analysis empirically in didactic examples in which MI can be computed exactly. Our results provide some guidance to the deep RL practitioner on when and why objectives may be expected to work well or fail, and also provide a framework to analyze newly proposed representation learning objectives based on MI. To investigate how our theoretical results pertain to deep RL, we compare the performance of RL agents in a simulated game trained with state representations learned by maximizing the MI objective given visual inputs. The experimental results corroborate our theoretical findings, and demonstrate that the sufficiency of a representation can have a substantial impact on the performance of an RL agent that uses that representation.
+
+# 2 RELATED WORK
+
+In this paper, we analyze several widely used mutual information objectives for control. In this section we first review MI-based unsupervised learning, then the application of these techniques to the RL setting. Finally, we discuss alternative perspectives on representation learning in RL.
+
+Mutual information-based unsupervised learning. Mutual information-based methods are particularly appealing for representation learning as they admit both rigorous analysis and intuitive interpretation. Tracing its roots to the InfoMax principle (Linsker, 1988; Bell & Sejnowski, 1995), a common technique is to maximize the MI between the input and its latent representation subject to domain-specific constraints (Becker & Hinton, 1992). This technique has been applied to learn representations for natural language (Devlin et al., 2019), video (Sun et al., 2019), and images (Bachman et al., 2019; Hjelm et al., 2018). A major challenge to using MI maximization methods in practice is the difficulty of estimating MI from samples (McAllester & Statos, 2018) and with high-dimensional inputs (Song & Ermon, 2019). Much recent work has focused on improving MI estimation via variational methods (Song & Ermon, 2019; Poole et al., 2019; Oord et al., 2018; Belghazi et al., 2018). In this work we are concerned with analyzing the MI objectives, and not the estimation method. In our experiments with image observations, we make use of noise contrastive estimation methods (Gutmann & Hyvarinen, 2010), though other choices could also suffice.¨
+
+Mutual information objectives in RL. Reinforcement learning adds aspects of temporal structure and control to the standard unsupervised learning problem discussed above (see Figure 1). This structure can be leveraged by maximizing MI between sequential states, actions, or combinations thereof. Some works omit the action, maximizing the MI between current and future states (Anand et al., 2019; Oord et al., 2018; Stooke et al., 2020). Much prior work learns latent forward dynamics models (Watter et al., 2015; Karl et al., 2016; Zhang et al., 2018b; Hafner et al., 2019; Lee et al., 2019), related to the forward information objective we introduce in Section 4. Multi-step inverse models, closely related to the inverse information objective (Section 4), have been used to learn control-centric representations (Yu et al., 2019; Gregor et al., 2016). Single-step inverse models have been deployed as regularization of forward models (Zhang et al., 2018a; Agrawal et al., 2016) and as an auxiliary loss for policy gradient RL Shelhamer et al. (2016); Pathak et al. (2017). The MI objectives that we study have also been used as reward bonuses to improve exploration, without impacting the representation, in the form of empowerment (Klyubin et al., 2008; 2005; Mohamed & Rezende, 2015; Leibfried et al., 2019) and information-theoretic curiosity (Still & Precup, 2012).
+
+Representation learning for reinforcement learning. In RL, the problem of finding a compact state space has been studied as state aggregation or abstraction (Bean et al., 1987; Li et al., 2006). Abstraction schemes include bisimulation (Givan et al., 2003), homomorphism (Ravindran & Barto, 2003), utile distinction (McCallum, 1996), and policy irrelevance (Jong & Stone, 2005). While efficient algorithms exist for MDPs with known transition models for some abstraction schemes such as bisimulation (Ferns et al., 2006; Givan et al., 2003), in general obtaining error-free abstractions is highly impractical for most problems of interest. For approximate abstractions prior work has bounded the sub-optimality of the policy (Bertsekas et al., 1988; Dean & Givan, 1997; Abel et al., 2016) as well as the sample efficiency (Lattimore & Szepesvari, 2019; Van Roy & Dong, 2019; Du et al., 2019), with some results extending to the deep learning setting (Gelada et al., 2019; Nachum et al., 2018). In this paper, we focus on whether a representation can be used to learn the optimal policy, and not the tractability of learning. Alternatively, priors based on the structure of the physical world can be used to guide representation learning (Jonschkowski & Brock, 2015). In deep RL, many auxiliary objectives distinct from the objectives that we study have been proposed, including meta-learning general value functions (Veeriah et al., 2019), predicting multiple value functions (Bellemare et al., 2019; Fedus et al., 2019; Jaderberg et al., 2016) and predicting domainspecific measurements (Mirowski, 2019; Dosovitskiy & Koltun, 2016). We restrict our analysis to objectives that can be expressed as MI-maximization.
+
+# 3 REPRESENTATION LEARNING FOR RL
+
+The goal of representation learning for RL is to learn a compact representation of the state space that discards irrelevant and redundant information. In this section we formalize each part of this statement, starting with defining the RL problem and representation learning in the context of RL. We then propose and define the metric of sufficiency to evaluate the usefulness of a representation.
+
+# 3.1 PRELIMINARIES
+
+We begin with brief preliminaries of reinforcement learning and mutual information.
+
+Reinforcement learning. A Markov decision process (MDP) is defined by the tuple $( \boldsymbol { S } , \boldsymbol { A } , \boldsymbol { T } , \boldsymbol { r } )$ , where $s$ is the set of states, $\mathcal { A }$ the set of actions, $\mathcal { T } : \mathcal { S } \times \mathcal { A } \times \mathcal { S }  [ 0 , 1 ]$ the state transition distribution, and $r : S \times \mathcal { A } \times \mathcal { S }  \mathbb { R }$ the reward function. We will use capital letters to refer to random variables and lower case letters to refer to values of those variables (e.g., $S$ is the random variable for the state and s is a specific state). Throughout our analysis we will often be interested in multiple reward functions, and denote a set of reward functions as $\mathcal { R }$ . The objective of RL is to find a policy that maximizes the sum of discounted returns $\bar { R }$ for a given reward function $r$ , and we denote this optimal policy as $\begin{array} { r } { \pi _ { r } ^ { * } = \arg \operatorname* { m a x } _ { \pi } \mathbb { E } _ { \pi } [ \sum _ { t } \gamma ^ { t } r ( S _ { t } , A _ { t } ) ] } \end{array}$ for discount factor $\gamma$ . We also define the optimal $Q$ -function as $\begin{array} { r } { Q _ { r } ^ { \ast } ( \mathbf { s } _ { t } , \mathbf { a } _ { t } ) = \mathbb { E } _ { \pi ^ { \ast } } [ \sum _ { t = 1 } ^ { \infty } \gamma ^ { t } r ( S _ { t } , { \cal A } _ { t } ) | \mathbf { s } _ { t } , \mathbf { a } _ { t } ] } \end{array}$ . The optimal $Q$ -function satisfies the recursive Bellman equation, $\begin{array} { r } { Q _ { r } ^ { * } ( \mathbf { s } _ { t } , \mathbf { a } _ { t } ) = r ( \mathbf { s } _ { t } , \mathbf { a } _ { t } ) + \gamma \mathbb { E } _ { p ( \mathbf { s } _ { t + 1 } \mid \mathbf { s } _ { t } , \mathbf { a } _ { t } ) } } \end{array}$ arg maxat+1 Q∗r(st+1, at+1). The optimal policy and the optimal Q-function are related according to $\pi ^ { * } ( { \mathbf { s } } ) = \arg \operatorname* { m a x } _ { \mathbf { a } } Q ^ { * } ( { \mathbf { s } } , { \mathbf { a } } )$ .
+
+Mutual information. In information theory, the mutual information (MI) between two random variables, $X$ and $Y$ , is defined as (Cover, 1999):
+
+$$
+I ( X ; Y ) = \mathbb { E } _ { p ( x , y ) } \log { \frac { p ( x , y ) } { p ( x ) p ( y ) } } = H ( X ) - H ( X | Y ) .
+$$
+
+The first definition indicates that MI can be understood as a relative entropy (or KL-divergence), while the second underscores the intuitive notion that MI measures the reduction in the uncertainty of one random variable from observing the value of the other.
+
+Representation learning for RL. The goal of representation learning for RL is to find a compact representation of the state space that discards details in the state that are not relevant for representing the policy or value function, while preserving task-relevant information (see Figure 1). While state aggregation methods typically define deterministic rules to group states in the representation (Bean et al., 1987; Li et al., 2006), MI-based representation learning methods used for deep RL treat the representation as a random variable (Nachum et al., 2018; Oord et al., 2018; Pathak et al., 2017). Accordingly, we formalize a representation as a stochastic mapping between original state space and representation space.
+
+Definition 1. A stochastic representation $\phi _ { \mathcal { Z } }$ (s) is a mapping from states $\mathbf { s } \in { \mathcal { S } }$ to a probability distribution $p ( Z | S = \mathbf { s } )$ ) over elements of a new representation space $z \in { \mathcal { Z } }$ .
+
+![](images/9e662ae63ac9fbc6afeb4c3d7af340b019c69d98dc1c935dd61bd7067e1c2111.jpg)  
+Figure 1: Probabilistic graphical model illustrating the state representation learning problem, estimating state representation $Z$ from original state $S$ .
+
+In this work we consider learning state representations from data by maximizing an objective $\mathbb { J }$ Given an objective $\mathbb { J }$ , we define the set of representations that maximize this objective as $\Phi _ { \mathbb { J } } =$ $\{ \phi _ { \mathcal { Z } } \}$ s.t. $\phi _ { \mathcal { Z } } \in \arg \operatorname* { m a x } \mathbb { J } ( \phi )$ .
+
+Unlike problem formulations for partially observed settings (Watter et al., 2015; Hafner et al., 2019; Lee et al., 2019), we assume that $S$ is a Markovian state; therefore the representation for a given state is conditionally independent of the past states, a common assumption in the state aggregation literature (Bean et al., 1987; Li et al., 2006). See Figure 1 for a depiction of the graphical model.
+
+# 3.2 SUFFICIENT REPRESENTATIONS FOR REINFORCEMENT LEARNING
+
+We now turn to the problem of evaluating stochastic representations for RL. Intuitively, we expect a useful state representation to be capable of representing the optimal policy in the original state space.
+
+Definition 2. A representation $\phi _ { \mathcal { Z } }$ is $\pi ^ { * }$ -sufficient with respect to a set of reward functions $\mathcal { R }$ if $\forall r \in \mathcal R$ , $\phi _ { \mathcal { Z } } ( \mathbf { s } _ { 1 } ) = \phi _ { \mathcal { Z } } ( \mathbf { s } _ { 2 } ) \implies \pi _ { r } ^ { * } ( A | \mathbf { s } _ { 1 } ) = \pi _ { r } ^ { * } ( A | \mathbf { s } _ { 2 } )$ .
+
+When a stochastic representation $\phi _ { \mathcal { Z } }$ produces the same distribution over the representation space for two different states ${ \bf s } _ { 1 }$ and $\mathbf { s } _ { 2 }$ we say it aliases these states. Unfortunately, as already proven in Theorem 4 of Li et al. (2006) for the more restrictive case of deterministic representations, being able to represent the optimal policy does not guarantee that it can be learned via RL in the representation space. Accordingly, we define a stricter notion of sufficiency that does guarantee the convergence of Q-learning to the optimal policy in the original state space (refer to Theorem 4 of Li et al. (2006) for the proof of this).
+
+Definition 3. A representation $\phi _ { \mathcal { Z } }$ is $Q ^ { * }$ -sufficient with respect to a set of reward functions $\mathcal { R }$ if $\forall r \in { \mathcal { R } }$ $\mathcal { R } , \phi _ { \mathcal { Z } } ( \mathbf { s } _ { 1 } ) = \phi _ { \mathcal { Z } } ( \mathbf { s } _ { 2 } ) \implies \forall \mathbf { a } , Q _ { r } ^ { * } ( \mathbf { a } , \mathbf { s } _ { 1 } ) = Q _ { r } ^ { * } ( \mathbf { a } , \mathbf { s } _ { 2 } )$ .
+
+Note that $Q ^ { * }$ -sufficiency implies $\pi ^ { * }$ -sufficiency since the optimal policy and the optimal Q-function are directly related via $\begin{array} { r } { \pi _ { r } ^ { * } ( s ) = \arg \operatorname* { m a x } _ { a } Q _ { r } ^ { * } ( s , a ) } \end{array}$ (Sutton $\&$ Barto, 2018); however the converse is not true. We emphasize that while $Q ^ { * }$ -sufficiency guarantees convergence, it does not guarantee tractability, which has been explored in prior work (Lattimore & Szepesvari, 2019; Du et al., 2019).
+
+We will further say that an objective $\mathbb { J }$ is sufficient with respect to some set of reward functions $\mathcal { R }$ if all the representations that maximize that objective $\Phi _ { \mathbb { J } }$ are sufficient with respect to every element of $\mathcal { R }$ according to the definition above. Surprisingly, we will demonstrate that not all commonly used objectives satisfy this basic qualification even when $\mathcal { R }$ contains a single known reward function.
+
+# 4 MUTUAL INFORMATION FOR REPRESENTATION LEARNING IN RL
+
+In our study, we consider several MI objectives proposed in the literature.
+
+Forward information: A commonly sought characteristic of a state representation is to ensure it retains maximum predictive power over future state representations. This property is satisfied by representations maximizing the following MI objective,
+
+$$
+\mathbb { J } _ { f w d } = I ( Z _ { t + k } ; Z _ { t } , A _ { t } ) = H ( Z _ { t + k } ) - H ( Z _ { t + k } | Z _ { t } , A _ { t } ) .
+$$
+
+We suggestively name this objective “forward information” due to the second term, which is the entropy of the forward dynamics distribution. This objective is related to that proposed in Nachum et al. (2018), where they consider a sequence of actions.
+
+State-only transition information: Several popular methods (Oord et al., 2018; Anand et al., 2019; Stooke et al., 2020) optimize a similar objective, but do not include the action 1:
+
+$$
+\mathbb { J } _ { s t a t e } = I ( Z _ { t + k } ; Z _ { t } ) = H ( Z _ { t + k } ) - H ( Z _ { t + k } | Z _ { t } ) .
+$$
+
+As we will show, the exclusion of the action can have a profound effect on the characteristics of the resulting representations.
+
+Inverse information: Another commonly sought characteristic of state representations is to retain maximum predictive power of the action distribution that could have generated an observed transition from $\mathbf { s } _ { t }$ to $\mathbf { s } _ { t + 1 }$ . Such representations can be learned by maximizing the following information theoretic objective:
+
+$$
+\mathbb { J } _ { i n v } = I ( A _ { t } ; Z _ { t + k } | Z _ { t } ) = H ( A _ { t } | Z _ { t } ) - H ( A _ { t } | Z _ { t } , Z _ { t + k } )
+$$
+
+We suggestively name this objective “inverse information” due to the second term, which is the entropy of the inverse dynamics. A wide range of prior work learns representations by optimizing closely related objectives (Gregor et al., 2016; Shelhamer et al., 2016; Agrawal et al., 2016; Pathak et al., 2017; Yu et al., 2019; Zhang et al., 2018a). Intuitively, inverse models allow the representation to capture only the elements of the state that are necessary to predict the action, allowing the discard of potentially irrelevant information.
+
+# 5 SUFFICIENCY ANALYSIS
+
+In this section we analyze the sufficiency for control of representations obtained by maximizing each objective presented in Section 4. To focus on the representation learning problem, we decouple it from RL by assuming access to a dataset of transitions collected with a policy that reaches all states with some probability, which can then be used to learn the desired representation. We also assume that distributions, such as the dynamics or inverse dynamics, can be modeled with arbitrary accuracy, and that the maximizing set of representations for a given objective can be computed. While these assumptions might be relaxed in any practical RL algorithm, and exploration plays a confounding role, studying these objectives under such simplifying assumptions allows us to compare them in terms of sufficiency on an equal playing field, isolating the role of representation learning from other confounding components of a complete RL algorithm.
+
+# 5.1 FORWARD INFORMATION
+
+In this section we show that a representation that maximizes $\mathbb { J } _ { f w d }$ is sufficient for optimal control under any reward function. This result aligns with intuition that a representation that captures forward dynamics can represent everything predictable in the state space, and can thus be used to learn the optimal policy for any task. Note that this strength can also be a weakness if there are many predictable elements that are irrelevant for downstream tasks, since the representation retains more information than is needed for the task.
+
+Proposition 1. $\mathbb { J } _ { f w d }$ is sufficient for all reward functions.
+
+Proof. (Sketch) We first show that if $Z _ { t } , A _ { t }$ are maximally informative of $Z _ { t + k }$ , they are also maximally informative of the return $\bar { R } _ { t }$ . Due to the Markov structure, $\mathbb { E } _ { p ( Z _ { t } | S _ { t } = \mathbf { s } ) } p ( \bar { R } _ { t } | Z _ { t } , A _ { t } ) =$ $p ( \bar { R } _ { t } | S _ { t } = \mathbf { s } , A _ { t } )$ . In other words, given $\phi _ { \mathcal { Z } }$ , additionally knowing $S$ doesn’t change our belief about the future return. The $Q$ -value is the expectation of the return, so $Z$ has as much information about the Q-value as $S$ does. The full proof can be found in Appendix 8.1. □
+
+# 5.2 STATE-ONLY TRANSITION INFORMATION
+
+While $\mathbb { J } _ { s t a t e }$ is closely related to $\mathbb { J } _ { f w d }$ , we now show that it is not sufficient.
+
+Proposition 2. $\mathbb { J } _ { s t a t e }$ is not sufficient for all reward functions.
+
+Proof. Consider the counter-example in Figure 2. Suppose that the two actions ${ \bf a } _ { 0 }$ and ${ \bf a } _ { 1 }$ are equally likely under the policy distribution. Each state gives no information about which of the two possible next states is more likely; this depends on the action. Therefore, a representation maximizing $\mathbb { J } _ { s t a t e }$ is free to alias states with the same next-state distribution, such as $\mathbf { s } _ { 0 }$ and ${ \bf s } _ { 3 }$ . An alternative view is that such a representation can maximize $\mathbb { J } _ { s t a t e } = H ( Z _ { t + k } ) - H ( Z _ { t + k } | Z _ { t } )$ by reducing both terms in equal amounts - aliasing $\mathbf { s } _ { 0 }$ and ${ \bf s } _ { 3 }$ decreases the marginal entropy as well as the entropy of predicting the next state starting from ${ \bf s } _ { 1 }$ or ${ \bf s } _ { 2 }$ . However, this aliased representation is not capable of representing the optimal policy which must distinguish $\mathbf { s } _ { 0 }$ and ${ \bf s } _ { 3 }$ in order to choose the correct action to reach $\mathbf { s } _ { 2 }$ , which yields reward. □
+
+# 5.3 INVERSE INFORMATION
+
+Here we show that representations that maximize $\mathbb { J } _ { i n v }$ are not sufficient for control in all MDPs. Intuitively, one way that the representation can be insufficient is by retaining only controllable state elements, while the reward function depends on state elements outside the agent’s control. We then show that additionally representing the immediate reward is not enough to resolve this issue.
+
+![](images/f09aad04268a7b54929f4b8c241ee90ab6f1ea5ffe2cdcb24e84ffd1ae3fa254.jpg)  
+Figure 2: (left) A representation that aliases the states ${ \bf s } _ { 0 }$ and ${ \bf s } _ { 3 }$ into a single state maximizes $\mathbb { J } _ { s t a t e }$ but is not sufficient to represent the optimal policy which must choose different actions in ${ \bf s } _ { 0 }$ and ${ \bf s } _ { 3 }$ to reach $\mathbf { s } _ { 2 }$ which yields reward. (right) Values of $\mathbb { J } _ { s t a t e }$ and $\mathbb { J } _ { f w d }$ for a few representative state representations, ordered by increasing $I ( Z ; S )$ . The representation that aliases $\mathbf { s } _ { 0 }$ and ${ \bf s } _ { 3 }$ (plotted with a diamond) maximizes $\mathbb { J } _ { s t a t e }$ , but the policy learned with this representation may not be optimal (as shown here). The original state representation (plotted with a star) is sufficient.
+
+Proposition 3. $\mathbb { J } _ { i n v }$ is not sufficient for all reward functions. Additionally, adding $I ( R _ { t } ; Z _ { t } )$ to the objective does not make it sufficient.
+
+Proof. Consider the MDP illustrated in Figure 3, and the representation that aliases the states ${ \bf s } _ { 0 }$ and $\mathbf { s } _ { 1 }$ . The same actions taken from these states lead to different next states which may have different rewards ${ \bf \dot { a } } _ { 0 }$ leads to the reward from $\mathbf { s } _ { 0 }$ while ${ \bf a } _ { 1 }$ leads to the reward from ${ \bf s } _ { 1 }$ ). However, this representation maximizes $\mathbb { J } _ { i n v }$ because given each pair of states, the action is identifiable. Interestingly, this problem cannot be remedied by simply requiring that the representation also be capable of predicting immediate rewards. The same counterexample holds since we assumed ${ \bf s } _ { 0 }$ and ${ \bf s } _ { 1 }$ have the same reward. □
+
+![](images/df72795a71197bc7cb6e2b95e593b14aa638b99f2ada4d18f7476ca9c67dc4e6.jpg)  
+Figure 3: (left) In this MDP, a representation that aliases the states $\mathbf { s } _ { 0 }$ and $\mathbf { s } _ { 1 }$ into a single state maximizes $\mathbb { J } _ { i n v }$ , yet is not sufficient to represent the optimal policy, which must distinguish between $\mathbf { s } _ { 0 }$ and ${ \bf s } _ { 1 }$ in order to take a different action (towards the high-reward states outlined in green). (right) Values of $\mathbb { J } _ { i n v }$ and $\mathbb { J } _ { f w d }$ for a few selected state representations, ordered by increasing $I ( Z ; S )$ . The representation that aliases ${ \bf s } _ { 0 }$ and $\mathbf { s } _ { 1 }$ (plotted with a diamond) maximizes $\mathbb { J } _ { i n v }$ , but is not sufficient to learn the optimal policy. Note that this counterexample holds also for $\mathbb { J } _ { i n v } + I ( R ; Z )$ .
+
+# 6 EXPERIMENTS
+
+In this section, we present experiments studying MI-based representation learning with image observations, to analyze whether the conclusions of our theoretical analysis hold in practice. Our goal is not to show that any particular method is necessarily better or worse, but rather to illustrate that the sufficiency arguments that we presented translate into quantifiable performance differences in the deep RL setting.
+
+# 6.1 EXPERIMENTAL SETUP
+
+To separate representation learning from RL, we first optimize each representation learning objective on a dataset of offline data consisting of $5 0 \mathrm { k }$ transitions collected from a uniform random policy. We then freeze the weights of the state encoder learned in the first phase and train RL agents with the representation as state input. To clearly illustrate the characteristics of each objective, we use the simple pygame (Shinners, 2011) video game catcher, in which the agent controls a paddle that it can move back and forth to catch fruit that falls from the top of the screen (see Figure 4). A positive reward is given when the fruit is caught and a negative reward when the fruit is not caught. The episode terminates after one piece of fruit falls. We optimize $\mathbb { J } _ { f w d }$ and $\mathbb { J } _ { s t a t e }$ with noise contrastive estimation (Gutmann & Hyvarinen, 2010), and ¨ $\mathbb { J } _ { i n v }$ by training an inverse model via maximum likelihood. For the RL algorithm, we use the Soft Actor-Critic algorithm Haarnoja et al. (2018), modified slightly for the discrete action distribution. Please see Appendix 8.2 for full experimental details.
+
+# 6.2 COMPUTATIONAL RESULTS
+
+In principle, we expect that a representation learned with $\mathbb { J } _ { i n v }$ may not sufficient to solve the catcher game. Because the agent does not control the fruit, a representation maximizing $\mathbb { J } _ { i n v }$ might discard that information, thereby making it impossible to represent the optimal policy. We observe in Figure 5 (top left) that indeed representations trained to maximize $\mathbb { J } _ { i n v }$ result in RL agents that converge slower and to a lower asymptotic expected return. Further, attempting to learn a decoder from the learned representation to the position of the falling fruit incurs a high error (Figure 5, bottom left), indicating that the fruit is not precisely captured by the representation. We argue that this type of problem setting is not contrived, and is representative of many situations in realistic tasks. Consider, for instance, an autonomous vehicle that is stopped
+
+![](images/ce6da2f5fbaece3ee7c7efb1812e0e1a2eaaf453217dbda173ab92da6a6456bf.jpg)  
+Figure 4: (left) Original catcher game in which the agent (grey paddle) moves left or right to catch fruit (yellow square) that falls from the top of the screen. (right) Variation catcher-grip in which the agent is instantiated as a gripper, and must open the gripper to catch fruit.
+
+at a stoplight. Because the agent does not control the color of the stoplight, it may not be captured in the representation learned by $\mathbb { J } _ { i n v }$ and the resulting RL policy may choose to run the light.
+
+In the second experiment, we consider a failure mode of $\mathbb { J } _ { s t a t e }$ . We augment the paddle with a gripper that the agent controls and must be open in order to properly catch the fruit. Since the change in the gripper is completely controlled by a single action, the current state contains no information about the state of the gripper in the future. Therefore, a representation maximizing $\mathbb { J } _ { s t a t e }$ might alias states where the gripper is open with states where the gripper is closed. In our experiment, we see that the error in predicting the state of the gripper from the representation learned via $\mathbb { J } _ { s t a t e }$ is chance (Figure 5, bottom right). This degrades the performance of an RL agent trained with this state representation since the best the agent can do is move under the fruit and randomly open or close the gripper (Figure 5, top right). In the driving example, suppose turning on the headlights incurs positive reward if it’s raining but negative reward if it’s sunny. The representation could fail to distinguish the state of the headlights, making it impossible to learn when to properly use the headlights.
+
+![](images/9680d5ec132ab084bbcc8453ec85f7bb3920cfa78c9927a7f37d1fa1a3df869f.jpg)
+
+<table><tr><td>Obj.</td><td>Agent Err.</td><td>Fruit Err.</td><td>Grip Err.</td></tr><tr><td>Jfwd</td><td>0.1</td><td>0.1</td><td>0.3</td></tr><tr><td>Jstate</td><td>0.1</td><td>0.1</td><td>0.5</td></tr></table>
+
+Figure 5: (top) Policy performance using learned representations as state inputs to RL, for the catcher and catcher-grip environments. (bottom) Error in predicting the positions of ground truth state elements from each learned representation. Representations maximizing $\mathbb { J } _ { i n v }$ need not represent the fruit, while representations maximizing $\mathbb { J } _ { s t a t e }$ need not represent the gripper, leading these representations to perform poorly in catcher and catcher-grip respectively.   
+
+<table><tr><td>Obj.</td><td>Agent Err.</td><td>Fruit Err.</td></tr><tr><td>Jfwd</td><td>0.1</td><td>0.1</td></tr><tr><td>Jinu</td><td>0.15</td><td>0.47</td></tr></table>
+
+$\mathbb { J } _ { f w d }$ produces useful representations in all cases, and is equally or more effective than learning representations purely from the RL objective alone (as in Figure 5). We experiment with more visual complexity by adding background distractors; these results are presented in Appendix 8.4. We find that in this setting representations learned with $\mathbb { J } _ { f w d }$ to yield even larger gains over learning representations end-to-end via RL. We also analyze the learned representations by evaluating how well they predict the optimal $Q ^ { * }$ in Appendix 8.3.
+
+# 7 DISCUSSION
+
+In this work, we aimed to analyze mutual information representation learning objectives for control from a theoretical perspective. In contrast to much prior work that studies how these objectives can be effectively optimized given high-dimensional observations, we analyze which objectives are guaranteed to yield representations that are actually sufficient for learning the optimal policy. Surprisingly, we show that two common objectives yield representations that are theoretically insufficient, and provide a proof of sufficiency for a third. We validate our theoretical results with an empirical investigation on a simple video game environment, and show that the insufficiency of these objectives can degrade the performance of deep RL agents.
+
+We view this investigation as a step forward in understanding the theoretical characteristics of representation learning techniques commonly used in deep RL. We see many exciting avenues for future work. First, identifying more restrictive MDP classes in which insufficient objectives are in fact sufficient, and relating these to realistic applications. Second, investigating if sample complexity bounds can be established in the case of a sufficient objective. Third, extending our analysis to the partially observed setting, which is more reflective of practical applications. We see these directions as fruitful in providing a deeper understanding of the learning dynamics of deep RL, and potentially yielding novel algorithms for provably accelerating RL with representation learning.
+
+# REFERENCES
+
+David Abel, D Ellis Hershkowitz, and Michael L Littman. Near optimal behavior via approximate state abstraction. In Proceedings of the 33rd International Conference on International Conference on Machine Learning-Volume 48, pp. 2915–2923, 2016.
+
+Pulkit Agrawal, Ashvin V Nair, Pieter Abbeel, Jitendra Malik, and Sergey Levine. Learning to poke by poking: Experiential learning of intuitive physics. In Advances in neural information processing systems, pp. 5074–5082, 2016.
+
+Ankesh Anand, Evan Racah, Sherjil Ozair, Yoshua Bengio, Marc-Alexandre Cotˆ e, and R Devon ´ Hjelm. Unsupervised state representation learning in atari. In Advances in Neural Information Processing Systems, pp. 8766–8779, 2019.
+
+Philip Bachman, R Devon Hjelm, and William Buchwalter. Learning representations by maximizing mutual information across views. In Advances in Neural Information Processing Systems, pp. 15509–15519, 2019.
+
+James C Bean, John R Birge, and Robert L Smith. Aggregation in dynamic programming. Operations Research, 35(2):215–220, 1987.
+
+Suzanna Becker and Geoffrey E Hinton. Self-organizing neural network that discovers surfaces in random-dot stereograms. Nature, 355(6356):161–163, 1992.
+
+Mohamed Ishmael Belghazi, Aristide Baratin, Sai Rajeswar, Sherjil Ozair, Yoshua Bengio, Aaron Courville, and R Devon Hjelm. Mine: mutual information neural estimation. arXiv preprint arXiv:1801.04062, 2018.
+
+Anthony J Bell and Terrence J Sejnowski. An information-maximization approach to blind separation and blind deconvolution. Neural computation, 7(6):1129–1159, 1995.
+
+Marc Bellemare, Will Dabney, Robert Dadashi, Adrien Ali Taiga, Pablo Samuel Castro, Nicolas Le Roux, Dale Schuurmans, Tor Lattimore, and Clare Lyle. A geometric perspective on optimal representations for reinforcement learning. In Advances in Neural Information Processing Systems, pp. 4360–4371, 2019.
+
+Dimitri P Bertsekas, David A Castanon, et al. Adaptive aggregation methods for infinite horizon dynamic programming. 1988.
+
+Thomas M Cover. Elements of information theory. John Wiley & Sons, 1999.
+
+Thomas Dean and Robert Givan. Model minimization in markov decision processes. In AAAI/IAAI, pp. 106–111, 1997.
+
+Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. Bert: Pre-training of deep bidirectional transformers for language understanding. In Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long and Short Papers), pp. 4171–4186, 2019.
+
+Alexey Dosovitskiy and Vladlen Koltun. Learning to act by predicting the future. In International Conference on Learning Representations, 2016.
+
+Simon S Du, Sham M Kakade, Ruosong Wang, and Lin F Yang. Is a good representation sufficient for sample efficient reinforcement learning? arXiv preprint arXiv:1910.03016, 2019.
+
+William Fedus, Carles Gelada, Yoshua Bengio, Marc G Bellemare, and Hugo Larochelle. Hyperbolic discounting and learning over multiple horizons. arXiv preprint arXiv:1902.06865, 2019.
+
+Norm Ferns, Pablo Samuel Castro, Doina Precup, and Prakash Panangaden. Methods for computing state similarity in markov decision processes. In Proceedings of the Twenty-Second Conference on Uncertainty in Artificial Intelligence, pp. 174–181, 2006.
+
+Carles Gelada, Saurabh Kumar, Jacob Buckman, Ofir Nachum, and Marc G Bellemare. Deepmdp: Learning continuous latent space models for representation learning. In International Conference on Machine Learning, pp. 2170–2179, 2019.
+
+Robert Givan, Thomas Dean, and Matthew Greig. Equivalence notions and model minimization in markov decision processes. Artificial Intelligence, 147(1-2):163–223, 2003.
+
+Karol Gregor, Danilo Jimenez Rezende, and Daan Wierstra. Variational intrinsic control. arXiv preprint arXiv:1611.07507, 2016.
+
+Michael Gutmann and Aapo Hyvarinen. Noise-contrastive estimation: A new estimation principle ¨ for unnormalized statistical models. In Proceedings of the Thirteenth International Conference on Artificial Intelligence and Statistics, pp. 297–304, 2010.
+
+Tuomas Haarnoja, Aurick Zhou, Pieter Abbeel, and Sergey Levine. Soft actor-critic: Off-policy maximum entropy deep reinforcement learning with a stochastic actor. arXiv preprint arXiv:1801.01290, 2018.
+
+Danijar Hafner, Timothy Lillicrap, Ian Fischer, Ruben Villegas, David Ha, Honglak Lee, and James Davidson. Learning latent dynamics for planning from pixels. In International Conference on Machine Learning, pp. 2555–2565, 2019.
+
+R Devon Hjelm, Alex Fedorov, Samuel Lavoie-Marchildon, Karan Grewal, Adam Trischler, and Yoshua Bengio. Learning deep representations by mutual information estimation and maximization. arXiv preprint arXiv:1808.06670, 2018.
+
+Max Jaderberg, Volodymyr Mnih, Wojciech Marian Czarnecki, Tom Schaul, Joel Z Leibo, David Silver, and Koray Kavukcuoglu. Reinforcement learning with unsupervised auxiliary tasks. arXiv preprint arXiv:1611.05397, 2016.
+
+Nicholas K Jong and Peter Stone. State abstraction discovery from irrelevant state variables. In IJCAI, volume 8, pp. 752–757, 2005.
+
+Rico Jonschkowski and Oliver Brock. Learning state representations with robotic priors. Autonomous Robots, 39(3):407–428, 2015.
+
+Dmitry Kalashnikov, Alex Irpan, Peter Pastor, Julian Ibarz, Alexander Herzog, Eric Jang, Deirdre Quillen, Ethan Holly, Mrinal Kalakrishnan, Vincent Vanhoucke, et al. Scalable deep reinforcement learning for vision-based robotic manipulation. In Conference on Robot Learning, pp. 651–673, 2018.
+
+Maximilian Karl, Maximilian Soelch, Justin Bayer, and Patrick van der Smagt. Deep variational bayes filters: Unsupervised learning of state space models from raw data. In International Conference on Learning Representations, 2016.
+
+Alexander S Klyubin, Daniel Polani, and Chrystopher L Nehaniv. Empowerment: A universal agent-centric measure of control. In 2005 IEEE Congress on Evolutionary Computation, volume 1, pp. 128–135. IEEE, 2005.
+
+Alexander S Klyubin, Daniel Polani, and Chrystopher L Nehaniv. Keep your options open: An information-based driving principle for sensorimotor systems. PloS one, 3(12), 2008.
+
+Tor Lattimore and Csaba Szepesvari. Learning with good feature representations in bandits and in rl with a generative model. arXiv preprint arXiv:1911.07676, 2019.
+
+Alex X. Lee, Anusha Nagabandi, Pieter Abbeel, and Sergey Levine. Stochastic latent actor-critic: Deep reinforcement learning with a latent variable model. arXiv preprint arXiv:1907.00953, 2019.
+
+Felix Leibfried, Sergio Pascual-D´ıaz, and Jordi Grau-Moya. A unified bellman optimality principle combining reward maximization and empowerment. In Advances in Neural Information Processing Systems, pp. 7867–7878, 2019.
+
+Timothee Lesort, Natalia D ´ ´ıaz-Rodr´ıguez, Jean-Franois Goudou, and David Filliat. State representation learning for control: An overview. Neural Networks, 108:379–392, 2018.
+
+Lihong Li, Thomas J Walsh, and Michael L Littman. Towards a unified theory of state abstraction for mdps. In ISAIM, 2006.
+
+Ralph Linsker. Self-organization in a perceptual network. Computer, 21(3):105–117, 1988.
+
+David McAllester and Karl Statos. Formal limitations on the measurement of mutual information. arXiv preprint arXiv:1811.04251, 2018.
+
+Andrew Kachites McCallum. Reinforcement Learning with Selective Perception and Hidden State. PhD thesis, University of Rochester, 1996.
+
+Piotr Mirowski. Learning to navigate. In 1st International Workshop on Multimodal Understanding and Learning for Embodied Applications, pp. 25–25, 2019.
+
+Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Alex Graves, Ioannis Antonoglou, Daan Wierstra, and Martin Riedmiller. Playing atari with deep reinforcement learning. arXiv preprint arXiv:1312.5602, 2013.
+
+Shakir Mohamed and Danilo Jimenez Rezende. Variational information maximisation for intrinsically motivated reinforcement learning. In Advances in neural information processing systems, pp. 2125–2133, 2015.
+
+Ofir Nachum, Shixiang Gu, Honglak Lee, and Sergey Levine. Near-optimal representation learning for hierarchical reinforcement learning. 2018.
+
+Aaron van den Oord, Yazhe Li, and Oriol Vinyals. Representation learning with contrastive predictive coding. arXiv preprint arXiv:1807.03748, 2018.
+
+Deepak Pathak, Pulkit Agrawal, Alexei A Efros, and Trevor Darrell. Curiosity-driven exploration by self-supervised prediction. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pp. 2778–2787. JMLR. org, 2017.
+
+Ben Poole, Sherjil Ozair, Aaron van den Oord, Alexander A Alemi, and George Tucker. On variational bounds of mutual information. arXiv preprint arXiv:1905.06922, 2019.
+
+Mirco Ravanelli and Yoshua Bengio. Learning speaker representations with mutual information, 2019.
+
+Balaraman Ravindran and Andrew G Barto. Smdp homomorphisms: an algebraic approach to abstraction in semi-markov decision processes. In Proceedings of the 18th international joint conference on Artificial intelligence, pp. 1011–1016, 2003.
+
+Evan Shelhamer, Parsa Mahmoudieh, Max Argus, and Trevor Darrell. Loss is its own reward: Self-supervision for reinforcement learning. arXiv preprint arXiv:1612.07307, 2016.
+
+Pete Shinners. Pygame. http://pygame.org/, 2011.
+
+Jiaming Song and Stefano Ermon. Understanding the limitations of variational mutual information estimators. arXiv preprint arXiv:1910.06222, 2019.
+
+Susanne Still and Doina Precup. An information-theoretic approach to curiosity-driven reinforcement learning. Theory in Biosciences, 131(3):139–148, 2012.
+
+Adam Stooke, Kimin Lee, Pieter Abbeel, and Michael Laskin. Decoupling representation learning from reinforcement learning. Technical report, UC Berkeley, 2020.
+
+Chen Sun, Fabien Baradel, Kevin Murphy, and Cordelia Schmid. Contrastive bidirectional transformer for temporal representation learning. arXiv preprint arXiv:1906.05743, 2019.
+
+Richard S Sutton and Andrew G Barto. Reinforcement learning: An introduction. MIT press, 2018.
+
+Benjamin Van Roy and Shi Dong. Comments on the du-kakade-wang-yang lower bounds. arXiv preprint arXiv:1911.07910, 2019.
+
+Vivek Veeriah, Matteo Hessel, Zhongwen Xu, Janarthanan Rajendran, Richard L Lewis, Junhyuk Oh, Hado P van Hasselt, David Silver, and Satinder Singh. Discovery of useful questions as auxiliary tasks. In Advances in Neural Information Processing Systems, pp. 9306–9317, 2019.
+
+Manuel Watter, Jost Springenberg, Joschka Boedecker, and Martin Riedmiller. Embed to control: A locally linear latent dynamics model for control from raw images. In Advances in neural information processing systems, pp. 2746–2754, 2015.
+
+Tianhe Yu, Gleb Shevchuk, Dorsa Sadigh, and Chelsea Finn. Unsupervised visuomotor control through distributional planning networks. In Robotics Science and Systems, 2019.
+
+Amy Zhang, Harsh Satija, and Joelle Pineau. Decoupling dynamics and reward for transfer learning. arXiv preprint arXiv:1804.10689, 2018a.
+
+Marvin Zhang, Sharad Vikram, Laura Smith, Pieter Abbeel, Matthew J Johnson, and Sergey Levine. Solar: Deep structured latent representations for model-based reinforcement learning. arXiv preprint arXiv:1808.09105, 2018b.
+
+# 8 APPENDIX
+
+# 8.1 SUFFICIENCY OF $\mathbb { J } _ { f w d }$ : PROOF OF PROPOSITION 1
+
+We describe the proofs for the sufficiency results from Section 5 here. We begin by providing a set of lemmas, before proving the sufficiency of $\mathbb { J } _ { f w d }$ .
+
+![](images/34983f5e13dab7cad97c50e0a4b9d33a15aecc253a0c83bb14e760120b6c938c.jpg)  
+Figure 6: Graphical model for Lemma 1, depicting true states $S$ , states in the representation $Z$ , actions $A$ , rewards $R$ , and the variable $X$ (which we will interpret as the sum of future rewards in the proof of Proposition 1).
+
+Lemma 1. Let $X$ be a random variable dependent on $S _ { t + k }$ , with the conditional independence assumptions implied by the graphical model in Figure 6. (In the main proof of Proposition $^ { l }$ , we will let $X$ be the sum of rewards from time $t + k$ onwards.) $\begin{array} { r } { t f I ( Z _ { t + k } ; Z _ { t } , A _ { t } ) = I ( S _ { t + k } ; S _ { t } , A _ { t } ) \forall k } \end{array}$ , then $I ( X ; Z _ { t } , A _ { t } ) = I ( X ; S _ { t } , A _ { t } ) \forall k$ .
+
+Proof. For proof by contradiction, assume there is some $\phi _ { \mathcal { Z } }$ and some $r$ such that $I ( X ; Z _ { t } , A _ { t } ) <$ $I ( X ; S _ { t } , A _ { t } )$ and that $I ( Z _ { t + k } ; Z _ { t } , A _ { t } ) = I ( S _ { t + k } ; S _ { t } , A _ { t } )$ . Now we know that because $Z _ { t } \to S _ { t } \to$ $S _ { t + k } \to Z _ { t + k }$ form a Markov chain, by the data processing inequality (DPI) $I ( Z _ { t + k } ; Z _ { t } , A _ { t } ) \le$ $I ( S _ { t + k } ; Z _ { t } , A _ { t } ) \ \leq \ I ( S _ { t + k } ; S _ { t } , A _ { t } )$ . We will proceed by showing that that $I ( X ; Z _ { t } , A _ { t } ) ~ <$ $I ( X ; S _ { t } , A _ { t } ) \implies I ( S _ { t + k } ; Z _ { t } , A _ { t } ) < I ( S _ { t + k } ; S _ { t } , A _ { t } ) |$ , which gives the needed contradiction.
+
+Using chain rule, we can expand the following expression in two different ways.
+
+$$
+I ( X ; Z _ { t } , S _ { t } , A _ { t } ) = I ( X ; Z _ { t } | S _ { t } , A _ { t } ) + I ( X ; S _ { t } , A _ { t } ) = 0 + I ( X ; S _ { t } , A _ { t } )
+$$
+
+$$
+I ( X ; Z _ { t } , S _ { t } , A _ { t } ) = I ( X ; S _ { t } | Z _ { t } , A _ { t } ) + I ( X ; Z _ { t } , A _ { t } )
+$$
+
+Note that the first term in Equation 5 is zero by the conditional independence assumptions in Figure 6. Equating the expansions, we can see that to satisfy our assumption that $I ( X ; Z _ { t } , A _ { t } \bar { ) } < I ( X ; \bar { S _ { t } } , A _ { t } )$ , we must have that $I ( X ; S _ { t } | Z _ { t } , A _ { t } ) > 0$ .
+
+Now we follow a similar procedure to expand the following expression:
+
+$$
+I ( S _ { t + k } ; Z _ { t } , S _ { t } , A _ { t } ) = I ( S _ { t + k } ; Z _ { t } | S _ { t } , A _ { t } ) + I ( S _ { t + k } ; S _ { t } , A _ { t } ) = 0 + I ( S _ { t + k } ; S _ { t } , A _ { t } )
+$$
+
+$$
+I ( S _ { t + k } ; Z _ { t } , S _ { t } , A _ { t } ) = I ( S _ { t + k } ; S _ { t } | Z _ { t } , A _ { t } ) + I ( S _ { t + k } ; Z _ { t } , A _ { t } )
+$$
+
+The first term in Equation 7 is zero by the conditional independence assumptions in Figure 6. Comparing the first term in Equation 8 with the first term in Equation 6, we see because $S _ { t } $ $S _ { t + k } \to X$ form a Markov chain, by the DPI that $I ( S _ { t + k } ; S _ { t } | Z _ { t } , \bar { A } _ { t } ) \ge I ( X ; S _ { t } | Z _ { t } , A _ { t } )$ . Therefore we must have $I ( S _ { t + k } ; S _ { t } | Z _ { t } , A _ { t } ) > 0 $ . Combining Equations 7 and 8:
+
+$$
+I ( S _ { t + k } ; S _ { t } , A _ { t } ) = I ( S _ { t + k } ; S _ { t } | Z _ { t } , A _ { t } ) + I ( S _ { t + k } ; Z _ { t } , A _ { t } )
+$$
+
+Since $I ( S _ { t + k } ; S _ { t } | Z _ { t } , A _ { t } ) > 0 , I ( S _ { t + k } ; Z _ { t } , A _ { t } ) < I ( S _ { t + k } ; S _ { t } , A _ { t } ) _ { \mathrm { t } }$ , which is exactly the contradiction we set out to show.
+
+Lemma 2. If $I ( Y ; Z ) ~ = ~ I ( Y ; X )$ and $Y ~ \perp ~ Z | X$ , then $\exists p ( Z | X ) ~ s . t . ~ \forall x , p ( Y | X ~ = ~ x ) ~ =$ $\begin{array} { r } { \int p ( Y | Z ) p ( \dot { Z } | X = x ) \dot { d z } } \end{array}$ .
+
+Proof. First note that the statement is not trivially true. Without any assumption regarding MI, we can write,
+
+$$
+p ( Y | X = x ) = \int p ( Y , Z | X = x ) d z = \int p ( Y | Z , X = x ) p ( Z | X = x ) d z
+$$
+
+Comparing this with the statement we’d like to prove, we can see that the key idea is to show that the MI equivalence implies that $p ( Y | Z , X = x ) = p ( Y | Z )$ . To begin, consider $I ( Y ; Z ) = I ( Y ; X )$ . We can re-write this equality using the entropy definition of MI.
+
+$$
+H ( Y ) - H ( Y \vert Z ) = H ( Y ) - H ( Y \vert X )
+$$
+
+Note that the $H ( Y )$ cancel and substituting the definition of entropy we have:
+
+$$
+\mathbb { E } _ { p ( Y , Z ) } [ \log p ( Y | Z ) ] = \mathbb { E } _ { p ( Y , X ) } [ \log p ( Y | X ) ]
+$$
+
+Note that on the right-hand side, we can use the Tower property to re-write the expectation as
+
+$$
+\begin{array} { r } { { \mathbb E } _ { p ( Y , X ) } [ \log p ( Y | X ) ] = { \mathbb E } _ { p ( Z ) } { \mathbb E } _ { p ( Y , X \mid Z ) } [ \log p ( Y | X ) ] = { \mathbb E } _ { p ( Y | X ) p ( X , Z ) } [ \log p ( Y | X ) ] } \end{array}
+$$
+
+Now we can use the Tower property again to re-write the expectation on both sides.
+
+$$
+\begin{array} { r l } & { \mathbb { E } _ { p ( X ) } [ \mathbb { E } _ { p ( Y , Z | X ) } [ \log p ( Y | Z ) ] ] = \mathbb { E } _ { p ( X ) } [ \mathbb { E } _ { p ( Y | X ) p ( X , Z | X ) } [ \log p ( Y | X ) ] ] } \\ & { \mathbb { E } _ { p ( X ) } [ \mathbb { E } _ { p ( Y | X ) p ( Z | X ) } [ \log p ( Y | Z ) ] ] = \mathbb { E } _ { p ( X ) } [ \mathbb { E } _ { p ( Y | X ) p ( Z | X ) } [ \log p ( Y | X ) ] ] } \\ & { \mathbb { E } _ { p ( X ) } [ \mathbb { E } _ { p ( Y | X ) p ( Z | X ) } [ \log p ( Y | Z ) ] ] - \log p ( Y | X ) ] = 0 } \\ & { \mathbb { E } _ { p ( X ) } [ \mathbb { E } _ { p ( Y | X ) } [ \mathbb { E } _ { p ( Z | X ) } [ \log p ( Y | Z ) ] - \log p ( Y | X ) ] ] = 0 } \end{array}
+$$
+
+Log probabilities are always $\leq 0$ , therefore for the sum to equal zero, each term must be zero.
+
+$$
+\log p ( Y | X ) = \mathbb { E } _ { p ( Z | X ) } [ \log p ( Y | Z ) ]
+$$
+
+By Jensen’s inequality,
+
+$$
+\log p ( Y | X ) \leq \log \mathbb { E } _ { p ( Z | X ) } [ p ( Y | Z ) ]
+$$
+
+By the monotonicity of the logarithm:
+
+$$
+p ( Y | X ) \leq \mathbb { E } _ { p ( Z | X ) } [ p ( Y | Z ) ]
+$$
+
+If there exists some $x$ and some $y$ such that $p ( Y = y | X = x ) < \mathbb { E } _ { p ( Z | X = x ) } [ p ( Y = y | Z ) ]$ , then there must be some other $y ^ { \prime }$ for the same $x$ where $p ( Y = y ^ { \prime } | X = x ) > \mathbb { E } _ { p ( Z | X = x ) } [ p ( Y = y ^ { \prime } | Z ) ]$ because $\rho ( Y | X = x )$ must sum to 1.
+
+$$
+p ( Y | X ) = \mathbb { E } _ { p ( Z | X ) } [ p ( Y | Z ) ] = \int p ( Y | Z ) p ( Z | X = x ) d z = \int p ( Y , Z | X = x ) d z
+$$
+
+Where the last equality follows by conditional independence of $Y$ and $Z$ given $X$ .
+
+Given the lemmas stated above, we can then use them to prove the sufficiency of $\mathbb { J } _ { f w d }$
+
+Proposition 1. (Sufficiency of $\mathbb { J } _ { f w d } )$ Let $( \boldsymbol { S } , \boldsymbol { A } , \boldsymbol { T } , \boldsymbol { r } )$ be an MDP with dynamics $p ( S _ { t + 1 } | S _ { t } , A _ { t } )$ . Let the policy distribution $p ( A | S )$ and steady-state state occupancy $p ( S )$ have full support on the action and state alphabets $\mathcal { A }$ and $s$ respectively. See Figure 6 for a graphical depiction of the conditional independence relationships between variables.
+
+For a representation $\phi _ { \mathcal { Z } }$ and set of reward functions $\mathcal { R }$ , if $I ( Z _ { t + k } ; Z _ { t } , A _ { t } )$ is maximized $\forall k > 0 , t > 0$ then $\forall r \in \mathcal { R }$ and $\forall \mathbf { s } _ { 1 } , \mathbf { s } _ { 2 } \in S$ $, \phi _ { \mathcal { Z } } ( \mathbf { s } _ { 1 } ) = \phi _ { \mathcal { Z } } ( \mathbf { s } _ { 2 } ) \implies \forall \mathbf { a } , Q _ { r } ^ { * } ( \mathbf { a } , \mathbf { s } _ { 1 } ) = Q _ { r } ^ { * } ( \mathbf { a } , \mathbf { s } _ { 2 } ) .$ .
+
+Proof. Note that $\left( Z _ { t + k } ; Z _ { t } , A _ { t } \right)$ is maximized if the representation $\phi _ { \mathcal { Z } }$ is taken to be the identity. In other words $\begin{array} { r } { \operatorname* { m a x } _ { \phi } I ( Z _ { t + k } ; Z _ { t } , A _ { t } ) = I ( S _ { t + k } ; S _ { t } , A _ { t } ) } \end{array}$ .
+
+Define the random variable $\bar { R } _ { t }$ to be the discounted return starting from state $\mathbf { s } _ { t }$ .
+
+$$
+\bar { R } _ { t } = \sum _ { k = 1 } ^ { H - t } \gamma ^ { k } R _ { t + k }
+$$
+
+Plug in $\bar { R } _ { t }$ for the random variable $X$ in Lemma 1:
+
+$$
+I ( Z _ { t + k } ; Z _ { t } , A _ { t } ) = I ( S _ { t + k } ; S _ { t } , A _ { t } ) \qquad \Longrightarrow \qquad I ( \bar { R } _ { t + k } ; Z _ { t } , A _ { t } ) = I ( \bar { R } _ { t + k } ; S _ { t } , A _ { t } )
+$$
+
+Now let $X = [ S _ { t } , A _ { t } ]$ , $Y = \bar { R } _ { t }$ , and $Z = Z _ { t }$ , and note that by the structure of the graphical model in Figure $6 , Y \perp Z | X$ . Plugging into Lemma 2:
+
+$$
+\mathbb { E } _ { p ( \mathbf { z } _ { t } \mid S _ { t } = \mathbf { s } ) } p ( \bar { R } _ { t } | Z _ { t } , A _ { t } ) = p ( \bar { R } _ { t } | S _ { t } = \mathbf { s } , A _ { t } )
+$$
+
+Now the $Q$ -function given a reward function $r$ and a state-action pair $( \mathbf { s } , \mathbf { a } )$ can be written as an expectation of this random variable $\bar { R } _ { t }$ , given $S _ { t } = \mathbf { s }$ and $A = \mathbf { a }$ . (Note that $p ( \bar { R } _ { t } | S _ { t } = \mathbf { s } , A _ { t } = \mathbf { a } )$ can be calculated from the dynamics, policy, and reward distributions.)
+
+$$
+Q _ { r } ( \mathbf { s } , \mathbf { a } ) = \mathbb { E } _ { p ( \bar { R } _ { t } | S _ { t } = \mathbf { s } , A _ { t } = \mathbf { a } ) } [ \bar { R } _ { t } ]
+$$
+
+Since $\phi _ { \mathcal { Z } } ( \mathbf { s } _ { 1 } ) _ { - } = \phi _ { \mathcal { Z } } ( \mathbf { s } _ { 2 } )$ , $p ( \mathbf { z } _ { t } | S _ { t } = \mathbf { s } _ { 1 } ) = p ( \mathbf { z } _ { t } | S _ { t } = \mathbf { s } _ { 2 } )$ . Therefore by Equation 21, $p ( { \bar { R } } _ { t } | S _ { t } =$ $\mathbf { s } _ { 1 } , A _ { t } ) = p ( \bar { R } _ { t } | S _ { t } = \mathbf { s } _ { 2 } , A _ { t } )$ . Plugging this result into Equation 22, $Q _ { r } ( \mathbf { a } , \mathbf { s } _ { 1 } ) = Q _ { r } ( \mathbf { a } , \mathbf { s } _ { 2 } )$ . Because this reasoning holds for all $Q$ -functions 2, it also holds for the optimal $Q$ , therefore ${ \cal Q } _ { r } ^ { \ast } ( { \bf a } , { \bf s } _ { 1 } ) =$ $Q _ { r } ^ { * } ( \mathbf { a } , \mathbf { s } _ { 2 } )$ .
+
+# 8.2 EXPERIMENTAL DETAILS
+
+# 8.2.1 DIDACTIC EXPERIMENTS
+
+The didactic examples are computed as follows. Given the list of states in the MDP, we compute the possible representations, restricting our focus to representations that group states into “blocks.” We do this because there are infinite stochastic representations and the MI expressions we consider are not convex in the parameters of $p ( Z | S )$ , making searching over these representations difficult. Given each state representation, we compute the value of the MI objective as well as the optimal value function using exact value iteration. In these examples, we assume that the policy distribution is uniform, and that the environment dynamics are deterministic. Since we consider the infinite horizon setting, we use the steady-state state occupancy in our calculations.
+
+# 8.2.2 DEEP RL EXPERIMENTS
+
+The deep RL experiments with the catcher game are conducted as follows. First, we use a uniform random policy to collect 50k transitions in the environment. In this simple environment, the uniform random policy suffices to visit all states (the random agent is capable of accidentally catching the fruit, for example). Next, each representation learning objective is maximized on this dataset. For all objectives, the images are pre-processed in the same manner (resized to 64x64 pixels and normalized) and embedded with a convolutional network. The convolutional encoder consists of five convolutional layers with ReLU activations and produces a latent vector with dimension 256. We use the latent vector to estimate each mutual information objective, as described below.
+
+Inverse information: We interpret the latent embeddings of the images $S _ { t }$ and $S _ { t + 1 }$ as the parameters of Gaussian distributions $p ( Z | S _ { t } )$ and $p ( Z | S _ { t + 1 } )$ . We obtain a single sample from each of these two distributions, concatenate them and pass them through a single linear layer to predict the action. The objective we maximize is the cross-entropy of the predicted actions with the true actions, as in Agrawal et al. 2016 and Shelhamer et al. 2016. To prevent recovering the trivial solution of preserving all the information in the image, we add an information bottleneck to the image embeddings. We tune the Lagrange multiplier on this bottleneck such that the action prediction loss remains the same value as when trained without the bottleneck. This approximates the objective $\begin{array} { r } { \operatorname* { m i n } _ { \phi } I ( Z ; S ) s . t . I _ { i n v } = \operatorname* { m a x } I _ { i n v } } \end{array}$ . To use the learned encoder for RL, we embed the image from the current timestep and take the mean of the predicted distribution as the state for the RL agent.
+
+State-only information: We follow the Noise Contrastive Estimation (NCE) approach presented in CPC (Oord et al. 2018). Denoting $Z _ { t }$ and $Z t + 1$ as the latent embedding vectors from the convolutional encoders, we use a log-bilinear model as in CPC to compute the score: $f ( Z _ { t } , Z _ { t + 1 } ) =$ $\mathrm { e x p } ( Z _ { t } ^ { T } W Z _ { t + 1 } )$ for the cross-entropy loss. We also experimented with an information bottleneck as described above, but found that it wasn’t needed to obtain insufficient representations. To use the learned encoder for RL, we embed the image from the current timestep and use this latent vector as the state for the RL agent.
+
+Forward information: We follow the same NCE strategy as for state-only information, with the difference that we concatenate the action to $Z _ { t }$ before computing the contrastive loss.
+
+We then freeze the state encoder learned via MI-maximization and use the representation as the state input for RL. The RL agent is trained using the Soft Actor-Critic algorithm Haarnoja et al. (2018), modified slightly for the discrete action distribution (the Q-function outputs Q-values for all actions rather than taking action as input, the policy outputs the action distribution rather than parameters of a distribution, and we can directly compute the expectation in the critic loss rather than sampling). The policy and critic networks consist of two hidden linear layers of 200 units each. We use ReLU activations.
+
+# 8.3 ANALYSIS: PREDICTING $Q ^ { * }$ FROM THE REPRESENTATION
+
+In Section 6, we evaluated the learned representations by running a temporal difference RL algorithm with the representation as the state input. In this section, instead of using the bootstrap to learn the $Q$ -function, we instead regress the $Q$ -function to the optimal $Q ^ { * }$ . To do this, we first compute the (roughly) optimal $Q ^ { * }$ by running RL with ground truth game state as input and taking the learned $Q$ as $Q ^ { * }$ . Then, we instantiate a new RL agent and train it with the learned image representation as input, regressing the $Q$ -function directly onto the values of $Q ^ { * }$ . We evaluate the policy derived from this new $Q$ -function, and plot the results for both the catcher and catcher-grip environments in Figure 7. We find that similar to the result achieved using the bootstrap, the policy performs poorly when using representations learned by insufficient objectives $( \mathbb { J } _ { i n v }$ in catcher and $\mathbb { J } _ { s t a t e }$ in catcher-grip). Interestingly, we find that the error between the learned $Q$ -values and the $Q ^ { * }$ -values is roughly the same for sufficient and insufficient representations. We hypothesize that this discrepancy between $Q$ -value error and policy performance is due to the fact that small differences in $Q$ -values on a small set of states can result in significant behavior differences in the policy.
+
+![](images/bfe152a6102f04bc06c789aca1582b802178090103147e0e8f43929d4e4f4aa5.jpg)  
+Figure 7: Performance of policies obtained from a $Q$ -function trained to predict $Q ^ { * }$ , given state representations learned by each MI objective, in the (left) catcher environment and (right) catchergrip environment. Insufficient objectives $\mathbb { J } _ { i n v }$ and $\mathbb { J } _ { s t a t e }$ respectively perform worse than sufficient objective $\mathbb { J } _ { f w d }$ .
+
+# 8.4 DEEP RL EXPERIMENTS WITH BACKGROUND DISTRACTORS
+
+In this section we repeat the experiments from Section 6 with added visual complexity in the form of background distractors. We randomly generate images of 10 circles of different colors and replace the black background of the game with these images. Examples of the agent’s observations are shown in Figure 8.
+
+We plot the results for both the catcher and catcher-grip games with distractors in Figure 9. As in Section 6, we show both the result of performing RL with the frozen representation as input (top), as well as the error of decoding true state elements from the representation (bottom). In both environments, end-to-end RL from images performs poorly, demonstrating the need for representation learning to aid in solving the task. As predicted by the theory, the representation learned by $\mathbb { J } _ { i n v }$ fails in both games, and the representation learned by $\mathbb { J } _ { s t a t e }$ fails in the catcher-grip game. We find that the difference in performance between sufficient and insufficient objectives is even more pronounced in this setting than in the plain background setting.
+
+![](images/9e77ef9c2ec0c4acef995494602c1bc826deab08aec366292e60e18eee10d8a2.jpg)  
+Figure 8: Example 64x64 pixel observations with background distractors.
+
+![](images/35cefecdbd5d43cb5e03e389b19c95b6d44c8bc42f578882b2590715dd7828fd.jpg)  
+Figure 9: (top) Policy performance using learned representations as state inputs to RL, for the catcher and catcher-grip environments with background distractors. (bottom) Error in predicting the positions of ground truth state elements from each learned representation. Representations maximizing $\mathbb { J } _ { i n v }$ need not represent the fruit, while representations maximizing $\mathbb { J } _ { s t a t e }$ need not represent the gripper, leading these representations to perform poorly in catcher and catcher-grip respectively.

parse/train/SyfIfnC5Ym/SyfIfnC5Ym.md

@@ -0,0 +1,361 @@
+# IMPROVING THE GENERALIZATION OF ADVERSARIAL TRAINING WITH DOMAIN ADAPTATION
+
+Chuanbiao Song   
+Department of Computer Science   
+Huazhong University of Science and Technology   
+Wuhan 430074, China   
+cbsong@hust.edu.cn   
+Kun He∗   
+Department of Computer Science   
+Huazhong University of Science and Technology   
+Wuhan 430074, China   
+brooklet60@hust.edu.cn   
+Liwei Wang   
+Department of Machine Intelligence   
+Peking University   
+wanglw@pku.edu.cn   
+John E. Hopcroft   
+Department of Computer Science   
+Cornell University   
+Ithaca 14850, NY, USA   
+jeh@cs.cornell.edu
+
+# ABSTRACT
+
+By injecting adversarial examples into training data, adversarial training is promising for improving the robustness of deep learning models. However, most existing adversarial training approaches are based on a specific type of adversarial attack. It may not provide sufficiently representative samples from the adversarial domain, leading to a weak generalization ability on adversarial examples from other attacks. Moreover, during the adversarial training, adversarial perturbations on inputs are usually crafted by fast single-step adversaries so as to scale to large datasets. This work is mainly focused on the adversarial training yet efficient FGSM adversary. In this scenario, it is difficult to train a model with great generalization due to the lack of representative adversarial samples, aka the samples are unable to accurately reflect the adversarial domain. To alleviate this problem, we propose a novel Adversarial Training with Domain Adaptation (ATDA) method. Our intuition is to regard the adversarial training on FGSM adversary as a domain adaption task with limited number of target domain samples. The main idea is to learn a representation that is semantically meaningful and domain invariant on the clean domain as well as the adversarial domain. Empirical evaluations on Fashion-MNIST, SVHN, CIFAR-10 and CIFAR-100 demonstrate that ATDA can greatly improve the generalization of adversarial training and the smoothness of the learned models, and outperforms state-of-the-art methods on standard benchmark datasets. To show the transfer ability of our method, we also extend ATDA to the adversarial training on iterative attacks such as PGD-Adversial Training (PAT) and the defense performance is improved considerably.
+
+# 1 INTRODUCTION
+
+Deep learning techniques have shown impressive performance on image classification and many other computer vision tasks. However, recent works have revealed that deep learning models are often vulnerable to adversarial examples (Szegedy et al., 2014; Goodfellow et al.; Papernot et al., 2016), which are maliciously designed to deceive the target model by generating carefully crafted adversarial perturbations on original clean inputs. Moreover, adversarial examples can transfer across models to mislead other models with a high probability (Papernot et al., 2017; Liu et al., 2017). How to effectively defense against adversarial attacks is crucial for security-critical computer vision systems, such as autonomous driving.
+
+As a promising approach, adversarial training defends from adversarial perturbations by training a target classifier with adversarial examples. Researchers have found (Goodfellow et al.; Kurakin et al., 2016b; Madry et al., 2018) that adversarial training could increase the robustness of neural networks. However, adversarial training often obtains adversarial examples by taking a specific attack technique (e.g., FGSM) into consideration, so the defense targeted such attack and the trained model exhibits weak generalization ability on adversarial examples from other adversaries (Kurakin et al., 2016b). Tramer et al. (2018) showed that the robustness of adversarial training can be easily cir- \` cumvented by the attack that combines with random perturbation from other models. Accordingly, for most existing adversarial training methods, there is a risk of overfitting to adversarial examples crafted on the original model with the specific attack.
+
+In this paper, we propose a novel adversarial training method that is able to improve the generalization of adversarial training. From the perspective of domain adaptation (DA) (Torralba & Efros, 2011), there is a big domain gap between the distribution of clean examples and the distribution of adversarial examples in the high-level representation space, even though adversarial perturbations are imperceptible to humans. Liao et al. (2018) showed that adversarial perturbations are progressively amplified along the layer hierarchy of neural networks, which maximizes the distance between the original and adversarial subspace representations. In addition, adversarial training simply injects adversarial examples from a specific attack into the training set, but there is still a large sample space for adversarial examples. Accordingly, training with the classification loss on such a training set will probably lead to overfitting on the adversarial examples from the specific attack. Even though Wong & Kolter (2018) showed that adversarial training with iterative noisy attacks has stronger robustness than the adversarial training with single-step attacks, iterative attacks have a large computational cost and there is no theoretical analysis to justify that the adversarial examples sampled in such way could be sufficiently representative for the adversarial domain.
+
+Our contributions are focused on how to improve the generalization of adversarial training on the simple yet scalable attacks, such as FGSM (Goodfellow et al.). The key idea of our approach is to formulate the learning procedure as a domain adaptation problem with limited number of target domain samples, where target domain denotes adversarial domain. Specifically, we introduce unsupervised as well as supervised domain adaptation into adversarial training to minimize the gap and increase the similarity between the distributions of clean examples and adversarial examples. In this way, the learned models generalize well on adversarial examples from different $\ell _ { \infty }$ bounded attacks. We evaluate our ATDA method on standard benchmark datasets. Empirical results show that despite a small decay of accuracy on clean data, ATDA significantly improves the generalization ability of adversarial training and has the transfer ability to extend to adversarial training on PGD (Madry et al., 2018).
+
+# 2 BACKGROUND AND RELATED WORK
+
+In this section, we introduce some notations and provides a brief overview of the current advanced attack methods, as well as the defense methods based on adversarial training.
+
+# 2.1 NOTATION
+
+Denote the clean data domain and the adversarial data domain by $\mathcal { D }$ and $\mathcal { A }$ respectively, we consider a classifier based on a neural network $f ( \boldsymbol { x } ) : \mathbb { R } ^ { d }  \mathbb { R } ^ { k }$ . $f ( x ) { \dot { } }$ outputs the probability distribution for an input $x \in [ 0 , 1 ] ^ { d }$ , and $k$ denotes the number of classes in the classification task. Let $\varphi$ be the mapping at the logits layer (the last neural layer before the final softmax function), so that $f ( x ) = s o f t m a x ( \varphi ( x ) )$ . Let $\epsilon$ be the magnitude of the perturbation. Let $x ^ { a d v }$ be the adversarial image computed by perturbing the original image $x$ . The cost function of image classification is denoted as $J ( x , y )$ . We define the logits as the logits layer representation, and define the logit space as the semantic space of the logits layer representation.
+
+We divide attacks into two types: white-box attacks have the complete knowledge of the target model and can fully access the model; black-box attacks have limited knowledge of the target classifier (e.g.,its architecture) but can not access the model weights.
+
+# 2.2 ATTACK METHODS
+
+We consider four attack methods to generate adversarial examples. For all attacks, the components of adversarial examples are clipped in [0, 1].
+
+Fast Gradient Sign Method (FGSM). Goodfellow et al. introduced FGSM to generate adversarial examples by applying perturbations in the direction of the gradient.
+
+$$
+\boldsymbol { x } ^ { a d v } = \boldsymbol { x } + \epsilon \cdot \mathrm { s i g n } ( \nabla _ { x } J ( x , \bar { y _ { t r u e } } ) )
+$$
+
+As compared with other attack methods, FGSM is a simple, yet fast and efficient adversary. Accordingly, FGSM is particularly amenable to adversarial training.
+
+Projected Gradient Descent (PGD). The Projected Gradient Descent (PGD) adversary was introduced by Madry et al. (2018) without random start, which is a stronger iterative variant of FGSM. This method applies FGSM iteratively for $k$ times with a budget $\alpha$ instead of a single step.
+
+$$
+x ^ { a d v _ { 0 } } = x 
+$$
+
+$$
+\begin{array} { c } { { x ^ { a d v _ { t + 1 } } = x ^ { a d v _ { t } } + \alpha \cdot \mathrm { s i g n } ( \nabla _ { x } J ( x ^ { a d v _ { t } } , y _ { t r u e } ) ) } } \\ { { x ^ { a d v _ { t + 1 } } = { \bf c l i p } ( x ^ { a d v _ { t + 1 } } , x ^ { a d v _ { t + 1 } } - \epsilon , x ^ { a d v _ { t + 1 } } + \epsilon ) } } \\ { { x ^ { a d v } = x ^ { a d v _ { k } } } } \end{array}
+$$
+
+Here $\mathbf { c l i p } ( \cdot , a , b )$ function forces its input to reside in the range of $[ a , b ]$ . PGD usually yields a higher success rate than FGSM does in the white-box setting but shows weaker capability in the black-box setting.
+
+RAND $+$ FGSM $\mathbf { \left( R + F G S M \right) }$ . Tramer et al. (2018) proposed\` $\mathrm { R + F G S M }$ against adversarially trained models by applying a small random perturbation of step size $\alpha$ before applying FGSM.
+
+$$
+\begin{array} { c } { x ^ { \prime } = x + \dot { \alpha } \cdot \mathrm { s i g n } ( \mathcal { N } ( \mathbf { 0 } ^ { d } , \mathbf { I } ^ { \dot { d } } ) ) } \\ { x ^ { a d v } = x ^ { \prime } + ( \epsilon - \alpha ) \cdot \mathrm { s i g n } ( \nabla _ { x } J ( x ^ { a d v } , y _ { t r u e } ) ) } \end{array}
+$$
+
+Momentum Iterative Method (MIM). MIM (Dong et al., 2018) is a modification of the iterative FGSM and it won the first place of NIPS 2017 Adversarial Attacks Competition. Its basic idea is to utilize the gradients of the previous $t$ steps with a decay factor $\mu$ to update the gradient at step $t + 1$ before applying FGSM with a budget $\alpha$ .
+
+$$
+x ^ { a d v _ { 0 } } = x , g _ { 0 } = 0
+$$$$
+\begin{array} { c } { { x ^ { a u v _ { 0 } } = x , g _ { 0 } = 0 } } \\ { { } } \\ { { g _ { t + 1 } = \mu \cdot g _ { t } + \frac { \nabla _ { x } J \left( x ^ { a d v _ { t } } , y _ { t r u e } \right) } { \left\| \nabla _ { x } J \left( x ^ { a d v _ { t } } , y _ { t r u e } \right) \right\| _ { 1 } } } } \\ { { } } \\ { { x ^ { a d v _ { t + 1 } } = x ^ { a d v _ { t } } + \alpha \cdot \mathrm { s i g n } ( g _ { t + 1 } ) } } \\ { { } } \\ { { x ^ { a d v _ { t + 1 } } = \mathbf { c l i p } ( x ^ { a d v _ { t + 1 } } , x ^ { a d v _ { t + 1 } } - \epsilon , x ^ { a d v _ { t + 1 } } + \epsilon ) } } \\ { { x ^ { a d v } = x ^ { a d v _ { k } } } } \end{array}
+$$
+
+# 2.3 PROGRESS ON ADVERSARIAL TRAINING
+
+An intuitive technique to defend a deep model against adversarial examples is adversarial training, which injects adversarial examples into the training data during the training process. First, Goodfellow et al. proposed to increase the robustness by feeding the model with both original and adversarial examples generated by FGSM and by learning with the modified objective function.
+
+$$
+\hat { J } ( x , y _ { t r u e } ) = \alpha J ( x , y _ { t r u e } ) + ( 1 - \alpha ) J ( x + \epsilon \cdot \mathrm { s i g n } ( \nabla _ { x } J ( x , y _ { t r u e } ) ) , y _ { t r u e } )
+$$
+
+Kurakin et al. (2016b) scaled the adversarial training to ImageNet (Russakovsky et al., 2015) and showed better results by replacing half the clean example at each batch with the corresponding adversarial examples. Meanwhile, Kurakin et al. (2016b) discovered the label leaking effect and suggested not to use the FGSM defined with respect to the true label $y _ { t r u e }$ . However, their approach has weak robustness to the $\mathrm { R A N D + F G S M }$ adversary. Tramer et al. (2018) proposed an\` ensemble adversarial training to improve robustness on black-box attacks by injecting adversarial examples transferred from a number of fixed pre-trained models into the training data.
+
+For adversarial training, another approach is to train only with adversarial examples. Nøkland (2015) proposed a specialization of the method (Goodfellow et al.) that learned only with the objective function of adversarial examples. Madry et al. (2018) demonstrated successful defenses based on adversarial training with the noisy PGD, which randomly initialize an adversarial example within the allowed norm ball before running iterative attack. However, this technique is difficult to scale to large-scale neural networks (Kurakin et al., 2016a) as the iterative attack increases the training time by a factor that is roughly equal to the number of iterative steps. Wong & Kolter (2018) developed a robust training method by linear programming that minimized the loss for the worst case within the perturbation ball around each clean data point. However, their approach achieved high test error on clean data and it is still challenging to scale to deep or wide neural networks.
+
+As described above, though adversarial training is promising, it is difficult to select a representative adversary to train on and most existing methods are weak in generalization for various adversaries, as the region of the adversarial examples for each clean data is large and contiguous (Tramer et al., \` 2017; Tabacof & Valle, 2016). Furthermore, generating a representative set of adversarial examples for large-scale datasets is computationally expensive.
+
+# 3 ADVERSARIAL TRAINING WITH DOMAIN ADAPTATION
+
+In this work, instead of focusing on a better sampling strategy to obtain representative adversarial data from the adversarial domain, we are especially concerned with the problem of how to train with clean data and adversarial examples from the efficient FGSM, so that the adversarially trained model is strong in generalization for different adversaries and has a low computational cost during the training.
+
+We propose an Adversarial Training with Domain Adaptation (ATDA) method to defense adversarial attacks and expect the learned models generalize well for various adversarial examples. Our motivation is to treat the adversarial training on FGSM as a domain adaptation task with limited number of target domain samples, where the target domain denotes adversarial domain. We combine standard adversarial training with the domain adaptor, which minimizes the domain gap between clean examples and adversarial examples. In this way, our adversarially trained model is effective on adversarial examples crafted by FGSM but also shows great generalization on other adversaries.
+
+# 3.1 DOMAIN ADAPTATION ON LOGIT SPACE
+
+# 3.1.1 UNSUPERVISED DOMAIN ADAPTATION
+
+Suppose we are given some clean training examples $\{ x _ { i } \}$ $( x _ { i } \in \mathbb { R } ^ { d } )$ with labels $\{ y _ { i } \}$ from the clean data domain $\mathcal { D }$ , and adversarial examples $\left\{ x _ { i } ^ { a d v } \right\} ( x _ { i } ^ { a \setminus v } \in \mathbb { R } ^ { d } )$ from adversarial data domain $\mathcal { A }$ . The adversarial examples are obtained by sampling $( x _ { i } , y _ { t r u e } )$ from , computing small perturbations on $x _ { i }$ to generate adversarial perturbations, and outputting $( x _ { i } ^ { a d v } , y _ { t r u e } )$ .
+
+It’s known that there is a huge shift in the distributions of clean data and adversarial data in the high-level representation space. Assume that in the logit space, data from either the clean domain or the adversarial domain follow a multivariate normal distribution, i.e., $\mathcal { D } \sim \mathcal { N } ( \mu _ { \mathcal { D } } , \Sigma _ { \mathcal { D } } ) , \mathcal { A } \sim$ $\mathcal { N } ( \mu _ { \mathcal { A } } , \Sigma _ { \mathcal { A } } )$ . Our goal is to learn the logits representation that minimizes the shift by aligning the covariance matrices and the mean vectors of the clean distribution and the adversarial distribution.
+
+To implement the CORrelation ALignment (CORAL), we define a covariance distance between the clean data and the adversarial data as follows.
+
+$$
+\mathcal { L } _ { C O R A L } ( \mathcal { D } , \mathcal { A } ) = \frac { 1 } { k ^ { 2 } } \left. C _ { \varphi ( \mathcal { D } ) } - C _ { \varphi ( A ) } \right. _ { \ell _ { 1 } }
+$$
+
+where $C _ { \varphi ( \mathcal { D } ) }$ and $C _ { \varphi ( \mathcal { A } ) }$ are the covariance matrices of the clean data and the adversarial data in the logit space respectively, and $\| \cdot \| _ { \ell _ { 1 } }$ denotes the $L _ { 1 }$ norm of a matrix. Note that $\mathcal { L } _ { C O R A L } ( \mathcal { D } , \mathcal { A } )$ is slightly different from the CORAL loss proposed by Sun & Saenko (2016).
+
+Similarly, we use the standard distribution distance metric, Maximum Mean Discrepancy (MMD) (Borgwardt et al., 2006), to minimize the distance of the mean vectors of the clean data and the adversarial data.
+
+$$
+\mathcal { L } _ { M M D } ( \mathcal { D } , \mathcal { A } ) = \frac { 1 } { k } \left\| \frac { 1 } { | \mathcal { D } | } \sum _ { x \in \mathcal { D } } \varphi ( x ) - \frac { 1 } { | \mathcal { A } | } \sum _ { x ^ { a d v } \in \mathcal { A } } \varphi ( x ^ { a d v } ) \right\| _ { 1 }
+$$
+
+The loss function for Unsupervised Domain Adaptation (UDA) can be calculated as follows.
+
+$$
+\mathcal { L } _ { U D A } ( \mathcal { D } , A ) = \mathcal { L } _ { C O R A L } ( \mathcal { D } , A ) + \mathcal { L } _ { M M D } ( \mathcal { D } , A )
+$$
+
+# 3.1.2 SUPERVISED DOMAIN ADAPTATION
+
+Even though the unsupervised domain adaptation achieves perfect confusion alignment, there is no guarantee that samples of the same label from clean domain and adversarial domain would map nearby in the logit space. To effectively utilize the labeled data in the adversarial domain, we introduce a supervised domain adaptation (SDA) by proposing a new loss function, denoted as margin loss, to minimize the intra-class variations and maximize the inter-class variations on samples of different domains. The SDA loss is shown in Eq. (9).
+
+$$
+\begin{array} { r l } & { \mathcal { L } _ { S D A } ( \mathcal { D } , \mathcal { A } ) = \mathcal { L } _ { m a r g i n } ( \mathcal { D } , \mathcal { A } ) } \\ & { \quad \quad \quad = \frac { 1 } { ( k - 1 ) ( | \mathcal { D } | + | A | ) } \cdot } \\ & { \quad \quad \quad \displaystyle \sum _ { x \in \mathcal { D } \cup \mathcal { A } \ : c ^ { n } \in C \backslash \{ c _ { y t r u e } \} } s o f t p l u s ( \| \varphi ( x ) - c _ { y _ { t r u e } } \| _ { 1 } - \| \varphi ( x ) - c ^ { n } \| _ { 1 } ) } \end{array}
+$$
+
+Here sof tplus denotes a function $l n ( 1 + e x p ( \cdot ) )$ ; $c _ { y _ { t r u e } } \in \mathbb { R } ^ { k }$ denotes the center of $y _ { t r u e }$ class in the logit space; $C = \{ c _ { j } \ | \ j = 1 , 2 , . . . , k \}$ is a set consisting of the logits center for each class, which will be updated as the logits changed. Similar to the center loss (Wen et al., 2016), we update center $c _ { j }$ for each class $j$ :
+
+$$
+\Delta c _ { j } ^ { t } = \frac { \sum _ { x \in \mathcal { D } \cup \mathcal { A } } \mathbf { 1 } _ { \mathrm { y _ { t r u e } = j } } \cdot \left( c _ { j } ^ { t } - \varphi ( x ) \right) } { 1 + \sum _ { x \in \mathcal { D } \cup \mathcal { A } } \mathbf { 1 } _ { \mathrm { y _ { t r u e } = j } } }
+$$
+
+where $\mathbf { 1 } _ { \mathrm { c o n d i t i o n } } = 1$ if the condition is true, otherwise $\mathbf { 1 } _ { \mathrm { c o n d i t i o n } } = 0$ ; $\alpha$ denotes the learning rate of the centers. During the training process, the logits center for each class can integrate the logits representation from both the clean domain and the adversarial domain.
+
+# 3.2 ADVERSARIAL TRAINING
+
+For adversarial training, iterative attacks are fairly expensive to compute and single-step attacks are fast to compute. Accordingly, we use a variant of FGSM attack (Kurakin et al., 2016b) that avoids the label leaking effect to generate a new adversarial example $x _ { i } ^ { a d v }$ for each clean example $x _ { i }$ .
+
+$$
+\boldsymbol { x } _ { i } ^ { a d v } = \boldsymbol { x } _ { i } + \epsilon \cdot \mathrm { s i g n } ( \nabla _ { \boldsymbol { x } } J ( x _ { i } , y _ { t a r g e t } ) )
+$$
+
+where $y _ { t a r g e t }$ denotes the predicted class $\arg \operatorname* { m a x } \{ \varphi ( x _ { i } ) \}$ of the model.
+
+However, in this case, the sampled adversarial examples are aggressive but not sufficiently representative due to the fact that the sampled adversarial examples always lie at the boundary of the $\ell _ { \infty }$ ball of radius $\epsilon$ (see Figure 1) and the adversarial examples within the boundary are ignored. For adversarial training, if we train a deep neural network only on the clean data and the adversarial data from the FGSM attack, the adversarially trained model will overfit on these two kinds of data and exhibits weak generalization ability on the adversarial examples sampled from other attacks. From a different perspective, such problem can be viewed as a domain adaptation problem with limited number of labeled target domain samples, as only some special data point can be sampled in the adversarial domain by FGSM adversary.
+
+![](images/6d76daf6b5c79adbc300a71d24eb443091f12ab9d0ce2d8bc271552b22f2d5c1.jpg)  
+Figure 1: Illustration of the adversarial sampling by FGSM for $x _ { i } \in \mathbb { R } ^ { 2 }$ . The blue dot (in the center) represents a clean example and the red dots (along the boundary) represent the potential adversarial examples for the clean example.
+
+Consequently, it is natural to combine the adversarial training with domain adaptation to improve the generalization ability on adversarial data. We generate new adversarial examples by the variant of FGSM attack shown in Eq. (11), then we use the following loss function to meet the criteria of domain adaptation while training a strong classifier.
+
+$$
+\begin{array} { r l } & { \mathcal { L } ( \mathcal { D } , \mathcal { A } ) = \mathcal { L } _ { C } ( \mathcal { D } ) + \mathcal { L } _ { C } ( \mathcal { A } ) + \lambda \cdot \mathcal { L } _ { D A } ( \mathcal { D } , \mathcal { A } ) } \\ & { \quad \quad \quad = \mathcal { L } _ { C } ( \mathcal { D } ) + \mathcal { L } _ { C } ( \mathcal { A } ) + \lambda \cdot ( \mathcal { L } _ { U D A } ( \mathcal { D } , \mathcal { A } ) + \mathcal { L } _ { S D A } ( \mathcal { D } , \mathcal { A } ) ) } \\ & { \quad \quad \quad = \displaystyle \frac { 1 } { m } \sum _ { x \in \mathcal { D } } \mathcal { L } _ { C } ( x | y _ { t r u e } ) + \frac { 1 } { m } \sum _ { x ^ { a d v } \in \mathcal { A } } \mathcal { L } _ { C } ( x ^ { a d v } | y _ { t r u e } ) } \\ & { \quad \quad \quad \quad + \lambda \cdot ( \mathcal { L } _ { C O R A L } ( \mathcal { D } , \mathcal { A } ) + \mathcal { L } _ { M M D } ( \mathcal { D } , \mathcal { A } ) + \mathcal { L } _ { m a r g i n } ( \mathcal { D } , \mathcal { A } ) ) } \end{array}
+$$
+
+Here $\lambda$ is the hyper-parameter to balance the regularization term; $m$ is the number of input clean examples; $\mathcal { D }$ indicates the input clean examples $\{ x _ { i } \}$ , and $\mathcal { A }$ the corresponding adversarial examples $\{ x _ { i } ^ { a d \bar { v } } \}$ ; $\mathcal { L } _ { C }$ denotes the classification loss. The training process is summarized in Algorithm 1.
+
+Algorithm 1 Adversarial training with domain adaptation on network $f ( \boldsymbol { x } ) : \mathbb { R } ^ { d }  \mathbb { R } ^ { k }$ .   
+Parameters: Size of the training minibatch is $m$ .   
+1: Randomly initialize network $f ( x )$ and logits centers $\{ c _ { j } \mid j = 1 , 2 , . . . , k \}$ ;   
+2: Number of iterations $t \gets 0$ ;   
+3: repeat   
+4: $t \gets t + 1$ ;   
+5: Read a minibatch of data $\mathcal { D } _ { b } = \{ x _ { 1 } , . . . , x _ { m } \}$ from the training set;   
+6: Use the current state of network $f$ to generate adversarial examples $\mathcal { A } _ { b } = \{ x _ { 1 } ^ { a d v } , . . . , x _ { m } ^ { a d v } \}$ by the FGSM variant that avoids label leaking;   
+7: Extract logits for examples $\mathcal { D } _ { b }$ , $\mathcal { A } _ { b }$ by performing forward-backward propagation from the input layer to the logits layer $\varphi ( x )$ ;   
+8: Update parameters $c _ { j }$ for each class $j$ by $c _ { j } ^ { t + 1 } = c _ { j } ^ { t } - \alpha \cdot \Delta c _ { j } ^ { t }$ ;   
+9: Compute the loss by Eq. (12) and update parameters of network $f$ by back propagation; 10: until the training converges.
+
+# 4 EXPERIMENTS
+
+In this section, we evaluate our ATDA method on various benchmark datasets to demonstrate the robustness and contrast its performance against other competing methods under different white-box and black-box attacks with bounded $\ell _ { \infty }$ norm. Code for these experiments is available at https: //github.com/JHL-HUST/ATDA.
+
+# 4.1 EXPERIMENTAL SETUP
+
+Datasets. We consider four popular datasets, namely Fashion-MNIST (Xiao et al., 2017), SVHN (Netzer et al., 2011), CIFAR-10 and CIFAR-100 (Krizhevsky & Hinton, 2009). For all experiments, we normalize the pixel values to [0, 1] by dividing 255.
+
+Baselines. To evaluate the generalization power on adversarial examples in both the white-box and black-box settings, we report the clean test accuracy, the defense accuracy on FGSM, PGD, $\mathrm { R + F G S M }$ and MIM in the non-targeted way. The common settings for these attacks are shown in Table 5 of the Appendix. We compare our ATDA method with normal training as well as several state-of-the-art adversarial training methods:
+
+• Normal Training (NT). Training with cross-entropy loss on the clean training data.   
+• Standard Adversarial Training (SAT) (Goodfellow et al.). Training with the cross-entropy on the clean training data and the adversarial examples from the FGSM variant with perturbation $\epsilon$ to avoid label leaking.   
+• Ensemble Adversarial Training (EAT) (Tramer et al., 2018). Training with cross-entropy \` on the clean training data and the adversarial examples crafted from the currently trained model and the static pre-trained models by the FGSM variant with the perturbation $\epsilon$ to avoid label leaking.   
+• Provably Robust Training (PRT) (Wong & Kolter, 2018). Training with cross-entropy loss on the worst case in the $\ell _ { \infty }$ ball of radius $\epsilon$ around each clean training data point. It could be seen as training with a complicated method of sampling in the $\ell _ { \infty }$ ball of radius $\epsilon$ .
+
+Evaluation Setup. For each benchmark dataset, we train a normal model and various adversarial models with perturbation $\epsilon$ on a main model with ConvNet architecture, and evaluate them on various attacks bounded by . Moreover, for Ensemble Adversarial Training (EAT), we use two different models as the static pre-trained models. For black-box attacks, we test trained models on the adversarial examples transferred from a model held out during the training. All experiments are implemented on a single Titan X GPU. For all experiments, we set the hyper-parameter $\lambda$ in Eq. (12) to $1 / 3$ and the hyper-parameter $\alpha$ in Eq. (10) to 0.1. For more details about neural network architectures and training hyper-parameters, see Appendix A. We tune the networks to make sure they work, not to post concentrates on optimizing these settings.
+
+# 4.2 COMPARISON OF DEFENSE PERFORMANCE ON ACCURACY
+
+We evaluate the defense performance of our ATDA method from the perspective of classification accuracy on various datasets, and compare with the baselines.
+
+Evaluation on Fashion-MNIST. The accuracy results on Fashion-MNIST are reported in Table 1a. NT yields the best performance on the clean data, but generalizes poorly on adversarial examples. SAT and EAT overfit on the clean data and the adversarial data from FGSM. PRT achieves lower error against various adversaries, but higher error on the clean data. ATDA achieves stronger robustness against different $\ell _ { \infty }$ bounded adversaries as compared to SAT (adversarial training on FGSM).
+
+Evaluation on SVHN. The classification accuracy on SVHN are summarized in Table 1b. PRT seems to degrade the performance on the clean testing data and exhibits weak robustness on various attacks. As compared to SAT, ATDA achieves stronger generalization ability on adversarial examples from various attacks and higher accuracy on the white-box adversaries, at the same time it only loses a negligible performance on clean data.
+
+Evaluation on CIFAR-10. Compared with Fashion-MNIST and SVHN, CIFAR-10 is a more difficult dataset for classification. As PRT is challenging and expensive to scale to large neural networks due to its complexity, the results of PRT are not reported. The accuracy results on CIFAR-10 are summarized in Table 1c. ATDA outperforms all the competing methods on most adversaries, despite a slightly lower performance on clean data.
+
+Evaluation on CIFAR-100. The CIFAR-100 dataset contains 100 image classes, with 600 images per class. Our goal here is not to achieve state-of-the-art performance on CIFAR-100, but to compare the generalization ability of different training methods on a comparatively large dataset. The results on CIFAR-100 are summarized in Table 1d. Compared to SAT, ATDA achieves better generalization on various adversarial examples and it does not degrade the performance on clean data.
+
+In conclusion, the accuracy results provide empirical evidence that ATDA has great generalization ability on different adversaries as compared to SAT and outperforms other competing methods.
+
+# 4.3 FURTHER ANALYSIS ON THE DEFENSE PERFORMANCE
+
+To further investigate the defence performance of the proposed method, we compute two other metrics: the local loss sensitivity to perturbations and the shift of adversarial data distribution with respect to the clean data distribution.
+
+Local Loss Sensitivity. One method to quantify smoothness and generalization to perturbations for models is the local loss sensitivity (Arpit et al., 2017). It is calculated in the clean testing data as follows. The lower the value is, the smoother the loss function is.
+
+$$
+\mathcal { S } = \frac { 1 } { m } \sum _ { i = 1 } ^ { m } \| \nabla _ { \boldsymbol { x } } J ( x _ { i } , y _ { i } ) \| _ { 2 }
+$$
+
+The results of the local loss sensitivity for the aforementioned learned models are summarized in Table 2. The results suggest that adversarial training methods do increase the smoothness of the model as compared with the normal training and ATDA performs the best.
+
+Distribution Discrepancy. To quantify the dissimilarity of the distributions between the clean data and the adversarial data, we compare our learned logits embeddings with the logits embeddings of the competing methods on Fashion-MNIST. We use t-SNE (Maaten & Hinton, 2008) for the comparison on the training data, testing data and adversarial testing data from the white-box FGSM or PGD. The comparisons are illustrated in Figure 2 and we report the detailed MMD distances across domains in Table 3. Compared with NT, SAT and EAT actually increase the MMD distance across domains of the clean data and the adversarial data. In contrast, PRT and ATDA can learn domain invariance between the clean domain and the adversarial domain. Furthermore, our learned logits representation achieves the best performance on domain invariance.
+
+Table 1: The accuracy of defense methods on the testing datasets and the adversarial examples generated by various adversaries.   
+(a) On Fashion-MNIST. The magnitude of perturbations is 0.1 in $\ell _ { \infty }$ norm.   
+
+<table><tr><td></td><td></td><td colspan="4">White-Box Attack (%)</td><td colspan="4">Black-Box Attack (%)</td></tr><tr><td>Defense</td><td>Clean (%)</td><td>FGSM</td><td>PGD</td><td>R+FGSM</td><td>MIM</td><td>FGSM</td><td>PGD</td><td>R+FGSM</td><td>MIM</td></tr><tr><td>NT</td><td>90.5</td><td>8.3</td><td>0.1</td><td>15.0</td><td>0.1</td><td>52.1</td><td>52.6</td><td>68.2</td><td>44.3</td></tr><tr><td>SAT</td><td>90.9</td><td>88.8</td><td>7.4</td><td>31.2</td><td>9.4</td><td>79.8</td><td>80.1</td><td>81.8</td><td>80.0</td></tr><tr><td>EAT</td><td>90.8</td><td>89.0</td><td>4.3</td><td>31.6</td><td>6.6</td><td>80.8</td><td>81.4</td><td>82.3</td><td>78.8</td></tr><tr><td>PRT</td><td>76.9</td><td>67.4</td><td>66.8</td><td>72.2</td><td>66.7</td><td>75.5</td><td>75.5</td><td>76.4</td><td>75.4</td></tr><tr><td>ATDA</td><td>85.5</td><td>78.2</td><td>68.6</td><td>77.0</td><td>68.8</td><td>83.8</td><td>83.7</td><td>84.5</td><td>83.3</td></tr></table>
+
+(b) On SVHN. The magnitude of perturbations is 0.02 in $\ell _ { \infty }$ norm.
+
+<table><tr><td rowspan="2">Defense</td><td rowspan="2">Clean (%)</td><td colspan="4">White-Box Attack (%)</td><td colspan="4">Black-Box Attack (%)</td></tr><tr><td>FGSM</td><td>PGD</td><td>R+FGSM</td><td>MIM</td><td>FGSM</td><td>PGD</td><td>R+FGSM</td><td>MIM</td></tr><tr><td>NT</td><td>84.9</td><td>19.6</td><td>3.6</td><td>33.3</td><td>4.6</td><td>64.3</td><td>68.0</td><td>76.5</td><td>64.8</td></tr><tr><td>SAT</td><td>86.6</td><td>52.1</td><td>44.4</td><td>70.4</td><td>46.1</td><td>79.0</td><td>79.7</td><td>83.3</td><td>78.7</td></tr><tr><td>EAT</td><td>88.6</td><td>47.1</td><td>34.4</td><td>67.6</td><td>36.6</td><td>80.4</td><td>81.3</td><td>85.3</td><td>80.2</td></tr><tr><td>PRT</td><td>58.5</td><td>41.7</td><td>41.1</td><td>49.5</td><td>41.2</td><td>53.7</td><td>54.9</td><td>56.1</td><td>54.0</td></tr><tr><td>ATDA</td><td>82.9</td><td>57.2</td><td>53.2</td><td>70.6</td><td>53.9</td><td>75.3</td><td>76.4</td><td>79.5</td><td>75.4</td></tr></table>
+
+(c) On CIFAR-10. The magnitude of perturbations is $4 / 2 5 5$ in $\ell _ { \infty }$ norm.   
+
+<table><tr><td></td><td></td><td colspan="4">White-Box Attack (%)</td><td colspan="4">Black-Box Attack (%)</td></tr><tr><td>Defense</td><td>Clean (%)</td><td>FGSM</td><td>PGD</td><td>R+FGSM</td><td>MIM</td><td>FGSM</td><td>PGD</td><td>R+FGSM</td><td>MIM</td></tr><tr><td>NT</td><td>86.9</td><td>4.3</td><td>0.5</td><td>19.6</td><td>0.9</td><td>41.3</td><td>23.8</td><td>60.9</td><td>25.8</td></tr><tr><td>SAT</td><td>86.2</td><td>52.4</td><td>49.5</td><td>70.2</td><td>50.5</td><td>80.5</td><td>80.5</td><td>83.5</td><td>80.3</td></tr><tr><td>EAT</td><td>86.0</td><td>46.7</td><td>43.5</td><td>67.5</td><td>44.5</td><td>80.0</td><td>80.1</td><td>83.2</td><td>79.8</td></tr><tr><td>PRT</td><td>-</td><td>1</td><td>-</td><td>1</td><td>-</td><td>-</td><td>1</td><td>-</td><td>1</td></tr><tr><td>ATDA</td><td>84.8</td><td>60.7</td><td>58.1</td><td>73.2</td><td>59.0</td><td>80.7</td><td>80.7</td><td>83.0</td><td>80.6</td></tr></table>
+
+(d) On CIFAR-100. The magnitude of perturbations is $4 / 2 5 5$ in $\ell _ { \infty }$ norm.
+
+<table><tr><td></td><td></td><td colspan="4">White-Box Attack (%)</td><td colspan="4">Black-Box Attack (%)</td></tr><tr><td>Defense</td><td>Clean (%)</td><td>FGSM</td><td>PGD</td><td>R+FGSM</td><td>MIM</td><td>FGSM</td><td>PGD</td><td>R+FGSM</td><td>MIM</td></tr><tr><td>NT</td><td>59.0</td><td>0.2</td><td>0.4</td><td>6.1</td><td>0.4</td><td>28.8</td><td>23.8</td><td>41.6</td><td>24.2</td></tr><tr><td>SAT</td><td>58.7</td><td>17.7</td><td>18.0</td><td>34.8</td><td>17.9</td><td>53.2</td><td>53.1</td><td>55.8</td><td>53.0</td></tr><tr><td>EAT</td><td>59.1</td><td>12.5</td><td>13.5</td><td>31.1</td><td>13.2</td><td>52.0</td><td>52.2</td><td>55.7</td><td>51.9</td></tr><tr><td>PRT</td><td>-</td><td>1</td><td>1</td><td>-</td><td>-</td><td>-</td><td>1</td><td>1</td><td>1</td></tr><tr><td>ATDA</td><td>61.6</td><td>29.3</td><td>26.2</td><td>43.0</td><td>27.3</td><td>56.0</td><td>56.0</td><td>58.7</td><td>56.0</td></tr></table>
+
+Table 2: The local loss sensitivity analysis for defense methods.   
+
+<table><tr><td rowspan="2">Dataset</td><td colspan="5">Local loss sensitivity</td></tr><tr><td>NT</td><td>SAT</td><td>EAT</td><td>PRT</td><td>ATDA</td></tr><tr><td>Fashion-MNIST</td><td>5.84</td><td>5.52</td><td>3.24</td><td>0.56</td><td>0.49</td></tr><tr><td>SVHN</td><td>13.48</td><td>2.03</td><td>2.41</td><td>1.79</td><td>1.64</td></tr><tr><td>CIFAR-10</td><td>6.56</td><td>1.61</td><td>2.08</td><td>-</td><td>0.90</td></tr><tr><td>CIFAR-100</td><td>23.16</td><td>7.13</td><td>8.40</td><td>-</td><td>2.67</td></tr></table>
+
+# 4.4 ABLATION STUDIES ON ATDA
+
+To individually dissect the effectiveness of different components in ATDA (Standard Adversarial Training (SAT), Unsupervised Domain Adaptation (UDA), and Supervised Domain Adaptation (SDA)), we conduct a series of ablation experiments in Figure 3. For each model, we report the average accuracy rates over all white-box attacks and all black-box attacks, respectively. The results illustrate that, by aligning the covariance matrix and mean vector of the clean and adversarial examples, UDA plays a key role in improving the generalization of SAT on various attacks. In general, the aware of margin loss on SDA can also improve the defense quality on standard adversarial training, but the effectiveness is not very stable over all datasets. By combining UDA and SDA together with SAT, our final algorithm ATDA can exhibits stable improvements on the standard adversarial training. In general, the performance of ATDA is slightly better than SAT+UDA.
+
+Table 3: The MMD distance across domains in the logit space for defense methods on FashionMNIST. $\mathcal { D }$ denotes the distribution of the clean testing data; $\mathbf { \nabla } A _ { F G S M }$ and $\scriptstyle A _ { P G D }$ denote the distributions of the adversarial testing data generated by the white-box FGSM and PGD, respectively.   
+
+<table><tr><td rowspan="2">MMD Distance</td><td colspan="5">Defense Method</td></tr><tr><td>NT</td><td>SAT</td><td>EAT</td><td>PRT</td><td>ATDA</td></tr><tr><td>MMD(D,AFGSm)</td><td>2.174</td><td>5.353</td><td>5.120</td><td>0.098</td><td>0.005</td></tr><tr><td>MMD(D,APGD)</td><td>5.287</td><td>2.909</td><td>1.239</td><td>0.101</td><td>0.019</td></tr></table>
+
+![](images/730b9477b91b9877f4826a97e6bb83d64db0372b8edaf244562de95e2a5f7009.jpg)  
+Figure 2: t-SNE visualizations for the embeddings of training data, testing data, and adversarial testing data from FGSM and PGD in the logit space for Fashion-MNIST. The first row to the fifth row correspond to NT, SAT, EAT, PRT and ATDA, respectively.
+
+![](images/7c06fc8a62b65c83cecb05b113671b85004a9b0a696f4aba338d1efddbfd0116.jpg)  
+Figure 3: Ablation experiments for ATDA to investigate the impact of Standard Adversarial Training (SAT), Unsupervised Domain Adaptation (UDA), and Supervised Domain Adaptation (SDA). We report the average accuracy rates over all white-box attacks and all black-box attacks, respectively.
+
+# 4.5 EXTENSION TO PGD-ADVERSARIAL TRAINING
+
+ATDA can simply be extended to adversarial training on other adversaries. We now consider to extend the ATDA method to PGD-Adversarial Training (PAT) (Madry et al., 2018): adversarial training on the noisy PGD with perturbation $\epsilon$ . By combining adversarial training on the noisy PGD with domain adaptation, we implement an extension of ATDA for PAT, called PATDA. For the noisy PGD, we set the iterated step $k$ as 10 and the budget $\alpha$ as $\epsilon / 4$ according to Madry et al. (2018).
+
+As shown in Table 4, we evaluate the defense performance of PAT and PATDA on various datasets. On Fashion-MNIST, we observe that PATDA fails to increase robustness to most adversaries as compared to PAT. On SVHN, PAT and PATDA fail to converge properly. The results are not surprising, as training with the hard and sufficient adversarial examples (from the noisy PGD) requires the neural networks with more parameters. On CIFAR-10 and CIFAR-100, PATDA achieves stronger robustness to various attacks than PAT. In general, PATDA exhibits stronger robustness to various adversaries as compared to PAT. The results indicate that domain adaptation can be applied flexibly to adversarial training on other adversaries to improve the defense performance.
+
+Table 4: The accuracy of PAT and PATDA on the testing datasets and the adversarial examples generated by various adversaries. The magnitude of perturbations in $\ell _ { \infty }$ norm is 0.1 for FashionMNIST, 0.02 for SVHN, and 4/255 for CIFAR-10 and CIFAR-100.   
+
+<table><tr><td rowspan="2">Dataset</td><td rowspan="2">Defense</td><td rowspan="2">Clean (%)</td><td colspan="4">White-Box Attack (%)</td><td colspan="4">Black-Box Attack(%)</td></tr><tr><td>FGSM</td><td>PGD</td><td>R+FGSM</td><td>MIM</td><td>FGSM</td><td>PGD</td><td>R+FGSM</td><td>MIM</td></tr><tr><td>Fashion-MNIST</td><td>PAT PATDA</td><td>85.3 83.2</td><td>78.7 77.0</td><td>76.5 75.5</td><td>81.7 79.8</td><td>76.7 75.7</td><td>81.8 84.0</td><td>83.9 81.7</td><td>84.8 82.4</td><td>83.8 81.6</td></tr><tr><td>SVHN</td><td>PAT PATDA</td><td>19.6 19.6</td><td>19.6 19.6</td><td>19.6 19.6</td><td>19.6 19.6</td><td>19.6 19.6</td><td>19.6 19.6</td><td>19.6 19.6</td><td>19.6 19.6</td><td>19.6 19.6</td></tr><tr><td>CIFAR-10</td><td>PAT PATDA</td><td>83.4 83.4</td><td>55.1 62.2</td><td>53.0 60.2</td><td>70.2 73.4</td><td>53.8 61.0</td><td>79.9 79.9</td><td>80.0 80.1</td><td>81.8 81.7</td><td>79.9 79.9</td></tr><tr><td>CIFAR-100</td><td>PAT PATDA</td><td>55.4 59.4</td><td>26.2 32.5</td><td>24.0 30.9</td><td>38.9 44.9</td><td>24.9 31.5</td><td>52.4 55.3</td><td>52.3 55.2</td><td>54.1 57.4</td><td>52.3 55.1</td></tr></table>
+
+# 5 CONCLUSION
+
+In this study, we regard the adversarial training as a domain adaptation task with limited number of target labeled data. By combining adversarial training on FGSM adversary with unsupervised and supervised domain adaptation, the generalization ability on adversarial examples from various attacks and the smoothness on the learned models can be highly improved for robust defense. In addition, ATDA can easily be extended to adversarial training on iterative attacks (e.g., PGD) to improve the defense performance. The experimental results on several benchmark datasets suggest that the proposed ATDA and its extension PATDA achieve significantly better generalization results as compared with current competing adversarial training methods.
+
+# ACKNOWLEDGMENTS
+
+This work is supported by National Natural Science Foundation (61772219).
+
+# REFERENCES
+
+Devansh Arpit, Stanislaw K. Jastrzebski, Nicolas Ballas, David Krueger, Emmanuel Bengio, Maxinder S. Kanwal, Tegan Maharaj, Asja Fischer, Aaron C. Courville, Yoshua Bengio, and Simon Lacoste-Julien. A closer look at memorization in deep networks. In Proceedings of the 34th International Conference on Machine Learning, ICML 2017, Sydney, NSW, Australia, 6-11 August 2017, pp. 233–242, 2017.
+
+Karsten M Borgwardt, Arthur Gretton, Malte J Rasch, Hans-Peter Kriegel, Bernhard Scholkopf, ¨ and Alex J Smola. Integrating structured biological data by kernel maximum mean discrepancy. Bioinformatics, 22(14):e49–e57, 2006.
+
+Djork-Arne Clevert, Thomas Unterthiner, and Sepp Hochreiter. Fast and accurate deep network ´ learning by exponential linear units (elus). arXiv preprint arXiv:1511.07289, 2015.
+
+Yinpeng Dong, Fangzhou Liao, Tianyu Pang, Hang Su, Jun Zhu, Xiaolin Hu, and Jianguo Li. Boosting adversarial attacks with momentum. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2018.
+
+Ian J Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples (2014). arXiv preprint arXiv:1412.6572.
+
+Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. Technical report, Citeseer, 2009.
+
+Alexey Kurakin, Ian Goodfellow, and Samy Bengio. Adversarial examples in the physical world. arXiv preprint arXiv:1607.02533, 2016a.
+
+Alexey Kurakin, Ian Goodfellow, and Samy Bengio. Adversarial machine learning at scale. arXiv preprint arXiv:1611.01236, 2016b.
+
+Fangzhou Liao, Ming Liang, Yinpeng Dong, Tianyu Pang, Jun Zhu, and Xiaolin Hu. Defense against adversarial attacks using high-level representation guided denoiser. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 1778–1787, 2018.
+
+Yanpei Liu, Xinyun Chen, Chang Liu, and Dawn Song. Delving into transferable adversarial examples and black-box attacks. In International Conference on Learning Representations(ICLR), 2017.
+
+Laurens van der Maaten and Geoffrey Hinton. Visualizing data using t-sne. Journal of machine learning research, 9(Nov):2579–2605, 2008.
+
+Aleksander Madry, Aleksandar Makelov, Ludwig Schmidt, Dimitris Tsipras, and Adrian Vladu. Towards deep learning models resistant to adversarial attacks. In International Conference on Learning Representations(ICLR), 2018.
+
+Yuval Netzer, Tao Wang, Adam Coates, Alessandro Bissacco, Bo Wu, and Andrew Y Ng. Reading digits in natural images with unsupervised feature learning. In NIPS workshop on deep learning and unsupervised feature learning, volume 2011, pp. 5, 2011.
+
+Arild Nøkland. Improving back-propagation by adding an adversarial gradient. arXiv preprint arXiv:1510.04189, 2015.
+
+Nicolas Papernot, Patrick McDaniel, Somesh Jha, Matt Fredrikson, Z Berkay Celik, and Ananthram Swami. The limitations of deep learning in adversarial settings. In Security and Privacy (EuroS&P), 2016 IEEE European Symposium on, pp. 372–387, 2016.
+
+Nicolas Papernot, Patrick McDaniel, Ian Goodfellow, Somesh Jha, Z Berkay Celik, and Ananthram Swami. Practical black-box attacks against machine learning. In Proceedings of the 2017 ACM on Asia Conference on Computer and Communications Security, pp. 506–519, 2017.
+
+Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael S. Bernstein, Alexander C. Berg, and Fei-Fei Li. Imagenet large scale visual recognition challenge. International Journal of Computer Vision, 115(3):211–252, 2015.
+
+Baochen Sun and Kate Saenko. Deep coral: Correlation alignment for deep domain adaptation. In European Conference on Computer Vision, pp. 443–450, 2016.   
+Christian Szegedy, Google Inc, Wojciech Zaremba, Ilya Sutskever, Google Inc, Joan Bruna, Dumitru Erhan, Google Inc, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. In International Conference on Learning Representations(ICLR), 2014.   
+Pedro Tabacof and Eduardo Valle. Exploring the space of adversarial images. In 2016 International Joint Conference on Neural Networks (IJCNN), pp. 426–433. IEEE, 2016.   
+Antonio Torralba and Alexei A Efros. Unbiased look at dataset bias. In Computer Vision and Pattern Recognition (CVPR), 2011 IEEE Conference on, pp. 1521–1528. IEEE, 2011.   
+Florian Tramer, Nicolas Papernot, Ian J. Goodfellow, Dan Boneh, and Patrick D. McDaniel. The \` space of transferable adversarial examples. arXiv preprint arXiv:1704.03453, 2017.   
+Florian Tramer, Alexey Kurakin, Nicolas Papernot, Ian Goodfellow, Dan Boneh, and Patrick Mc- \` Daniel. Ensemble adversarial training: Attacks and defenses. In International Conference on Learning Representations, 2018.   
+Yandong Wen, Kaipeng Zhang, Zhifeng Li, and Yu Qiao. A discriminative feature learning approach for deep face recognition. In European Conference on Computer Vision, pp. 499–515, 2016.   
+Eric Wong and J. Zico Kolter. Provable defenses against adversarial examples via the convex outer adversarial polytope. In Proceedings of the 35th International Conference on Machine Learning, ICML 2018, Stockholmsmassan, Stockholm, Sweden, July 10-15, 2018 ¨ , pp. 5283–5292, 2018.   
+Yuxin Wu and Kaiming He. Group normalization. arXiv preprint arXiv:1803.08494, 2018.   
+Han Xiao, Kashif Rasul, and Roland Vollgraf. Fashion-mnist: a novel image dataset for benchmarking machine learning algorithms. arXiv preprint arXiv:1708.07747, 2017.
+
+# A EXPERIMENTAL DETAILS
+
+In the appendix, we show all details of the common settings, neural network architectures and training hyper-parameters for the experiments.
+
+# A.1 HYPER-PARAMETERS FOR ADVERSARIES.
+
+For each dataset, the details about the hyper-parameters of various adversaries are shown in Table 5, where $\epsilon$ denotes the magnitude of adversarial perturbations.
+
+Table 5: Common settings of attacks for all experiments   
+
+<table><tr><td>Attack</td><td>Parameter</td><td>Norm</td></tr><tr><td>FGSM</td><td>N/A</td><td>lo</td></tr><tr><td>PGD</td><td>Iterated step k = 20,α = ∈/10</td><td>l</td></tr><tr><td>R+FGSM</td><td>Random perturbation α = ε/2</td><td>lo</td></tr><tr><td>MIM</td><td>Iterated step k = 10,α= ε/5,μ = 1.0</td><td>l8</td></tr></table>
+
+# A.2 NEURAL NETWORK ARCHITECTURES AND TRAINING HYPER-PARAMETERS
+
+Fashion-MNIST. In the training phase, we use Adam optimizer with a learning rate of 0.001 and set the batch size to 64. For Fashion-MNIST, the neural network architectures for the main model, the static pre-trained models and the model held out during training are depicted in Table 6. For all adversarial training methods, the magnitude of perturbations is 0.1 in $\ell _ { \infty }$ norm.
+
+SVHN. In the training phase, we use Adam optimizer with a learning rate of 0.001 and set the batch size to 32 and use the same architectures as in Fashion-MNIST. For all adversarial training methods, the magnitude of perturbations is 0.02 in $\ell _ { \infty }$ norm.
+
+Table 6: Neural network architectures used for the Fashion-MNIST and SVHN datasets. Conv: convolutional layer with Relu, FC: fully connected layer.   
+
+<table><tr><td>Main model</td><td>Pre-trained modelA</td><td>Pre-trained modelA</td><td>Holdout model</td></tr><tr><td>Conv(16, 4x4)</td><td>Conv(32,5x5)</td><td>Dropout(0.2)</td><td>Conv(64,3x3)</td></tr><tr><td>Conv(32, 4x4)</td><td>Conv(32, 5x5)</td><td>Conv(32,3x3)</td><td>FC(300) + Relu</td></tr><tr><td>FC(100) + Relu</td><td>Dropout(0.1)</td><td>Conv(32, 3x3)</td><td>Dropout(0.5)</td></tr><tr><td>FC(10)</td><td>FC(128) + Relu</td><td>FC(128) + Relu</td><td>FC(300) + Relu</td></tr><tr><td></td><td>Dropout(0.5)</td><td>Dropout(0.5)</td><td>Dropout(0.5)</td></tr><tr><td></td><td>FC(10)</td><td>FC(10)</td><td>FC(10)</td></tr></table>
+
+CIFAR-10. In the training phase, we use the same training settings as in SVHN. we use Adam optimizer with a learning rate of 0.001 and set the batch size to 32. In order to enhance the expressive power of deep neural networks, we use Exponential Linear Unit (ELU) (Clevert et al., 2015) as the activation function and introduce Group Normalization (Wu & He, 2018) into the architectures. The neural network architectures for CIFAR-10 are shown in Table 7. For all adversarial training methods, the magnitude of perturbations is $4 / 2 5 5$ in $\ell _ { \infty }$ norm.
+
+CIFAR-100. We use the same training settings as in CIFAR-10. For CIFAR-100, the neural network architectures for the main model, the static pre-trained models and the model held out during training are shown in Table 8. For all adversarial training methods, the magnitude of perturbations is $4 / 2 5 5$ in $\ell _ { \infty }$ norm.
+
+Table 7: Neural network architectures used for the CIFAR-10 dataset. Conv: convolutional layer with Group Normalization and ELU; GAP: global average pooling.   
+
+<table><tr><td>Main model</td><td>Pre-trained modelA</td><td>Pre-trained modelb</td><td>Holdout model</td></tr><tr><td>Conv(96, 3x3)</td><td>Conv(96, 5x5)</td><td>Conv(192, 5x5)</td><td>Conv(96, 3x3)</td></tr><tr><td>Conv(96,3x3)</td><td>Conv(96, 1x1)</td><td>Conv(96,1x1)</td><td>Dropout(0.2)</td></tr><tr><td>Conv(96, 3x3)</td><td>MaxPooling(3x3,2)</td><td>MaxPooling(3x3,2)</td><td>Conv(96,3x3) x 2</td></tr><tr><td>Dropout(0.5)</td><td>Dropout(0.5)</td><td>Dropout(0.5)</td><td>Dropout(0.5)</td></tr><tr><td>Conv(192,3x3) x 3</td><td>Conv(192, 5x5)</td><td>Conv(192, 5x5)</td><td>Conv(192,3x3) x 2</td></tr><tr><td>Dropout(0.5)</td><td>Conv(192,1x1)</td><td>Conv(192,1x1)</td><td>Dropout(0.5)</td></tr><tr><td>Conv(192, 3x3)</td><td>MaxPooling(3x3,2)</td><td>MaxPooling(3x3,2)</td><td>Conv(256, 3x3)</td></tr><tr><td>Conv(192, 1x1)</td><td>Dropout(0.5)</td><td>Dropout(0.5)</td><td>Conv(256, 1x1)</td></tr><tr><td>Conv(10,1x1)</td><td>Conv(256,3x3)</td><td>Conv(256,3x3)</td><td></td></tr><tr><td>GAP</td><td></td><td></td><td>Conv(10, 1x1)</td></tr><tr><td></td><td>Conv(256, 1x1)</td><td>Conv(256, 1x1)</td><td>GAP</td></tr><tr><td></td><td>Conv(10, 1x1)</td><td>Conv(10, 1x1)</td><td></td></tr><tr><td></td><td>GAP</td><td>GAP</td><td></td></tr></table>
+
+Table 8: Neural network architectures used for the CIFAR-100 dataset. Conv: convolutional layer with Group Normalization and ELU; GAP: global average pooling.   
+
+<table><tr><td>Main model</td><td>Pre-trained modelA</td><td>Pre-trained modelB</td><td>Holdout model</td></tr><tr><td>Conv(96, 3x3)</td><td>Conv(96, 5x5)</td><td>Conv(192, 5x5)</td><td>Conv(96,3x3)</td></tr><tr><td>Conv(96, 3x3)</td><td>Conv(96,1x1)</td><td>Conv(96, 1x1)</td><td>Dropout(0.2)</td></tr><tr><td>Conv(96, 3x3)</td><td>MaxPooling(3x3,2)</td><td>MaxPooling(3x3,2)</td><td>Conv(96,3x3) x 2</td></tr><tr><td>Dropout(0.5)</td><td>Dropout(0.5)</td><td>Dropout(0.5)</td><td>Dropout(0.5)</td></tr><tr><td>Conv(192,3x3) x 3</td><td>Conv(192, 5x5)</td><td>Conv(192, 5x5)</td><td>Conv(192,3x3) x 2</td></tr><tr><td>Dropout(0.5)</td><td>Conv(192,1x1)</td><td>Conv(192, 1x1)</td><td>Dropout(0.5)</td></tr><tr><td>Conv(192,3x3)</td><td>MaxPooling(3x3,2)</td><td>MaxPooling(3x3,2)</td><td>Conv(256, 3x3)</td></tr><tr><td>Conv(192, 1x1)</td><td>Dropout(0.5)</td><td>Dropout(0.5)</td><td>Conv(256,1x1)</td></tr><tr><td>Conv(100, 1x1)</td><td>Conv(256,3x3)</td><td>Conv(256,3x3)</td><td>Conv(100, 1x1)</td></tr><tr><td>GAP</td><td>Conv(256,1x1)</td><td>Conv(256,1x1)</td><td>GAP</td></tr><tr><td></td><td>Conv(100,1x1)</td><td>Conv(100, 1x1)</td><td></td></tr><tr><td></td><td>GAP</td><td>GAP</td><td></td></tr></table>

parse/train/SyfIfnC5Ym/SyfIfnC5Ym_content_list.json

@@ -0,0 +1,1691 @@
+[
+    {
+        "type": "text",
+        "text": "IMPROVING THE GENERALIZATION OF ADVERSARIAL TRAINING WITH DOMAIN ADAPTATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            99,
+            818,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Chuanbiao Song   \nDepartment of Computer Science   \nHuazhong University of Science and Technology   \nWuhan 430074, China   \ncbsong@hust.edu.cn   \nKun He∗   \nDepartment of Computer Science   \nHuazhong University of Science and Technology   \nWuhan 430074, China   \nbrooklet60@hust.edu.cn   \nLiwei Wang   \nDepartment of Machine Intelligence   \nPeking University   \nwanglw@pku.edu.cn   \nJohn E. Hopcroft   \nDepartment of Computer Science   \nCornell University   \nIthaca 14850, NY, USA   \njeh@cs.cornell.edu ",
+        "bbox": [
+            184,
+            170,
+            504,
+            239
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            522,
+            170,
+            844,
+            239
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            184,
+            261,
+            423,
+            316
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            516,
+            261,
+            736,
+            330
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            368,
+            544,
+            382
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "By injecting adversarial examples into training data, adversarial training is promising for improving the robustness of deep learning models. However, most existing adversarial training approaches are based on a specific type of adversarial attack. It may not provide sufficiently representative samples from the adversarial domain, leading to a weak generalization ability on adversarial examples from other attacks. Moreover, during the adversarial training, adversarial perturbations on inputs are usually crafted by fast single-step adversaries so as to scale to large datasets. This work is mainly focused on the adversarial training yet efficient FGSM adversary. In this scenario, it is difficult to train a model with great generalization due to the lack of representative adversarial samples, aka the samples are unable to accurately reflect the adversarial domain. To alleviate this problem, we propose a novel Adversarial Training with Domain Adaptation (ATDA) method. Our intuition is to regard the adversarial training on FGSM adversary as a domain adaption task with limited number of target domain samples. The main idea is to learn a representation that is semantically meaningful and domain invariant on the clean domain as well as the adversarial domain. Empirical evaluations on Fashion-MNIST, SVHN, CIFAR-10 and CIFAR-100 demonstrate that ATDA can greatly improve the generalization of adversarial training and the smoothness of the learned models, and outperforms state-of-the-art methods on standard benchmark datasets. To show the transfer ability of our method, we also extend ATDA to the adversarial training on iterative attacks such as PGD-Adversial Training (PAT) and the defense performance is improved considerably. ",
+        "bbox": [
+            232,
+            397,
+            764,
+            703
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            727,
+            336,
+            743
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep learning techniques have shown impressive performance on image classification and many other computer vision tasks. However, recent works have revealed that deep learning models are often vulnerable to adversarial examples (Szegedy et al., 2014; Goodfellow et al.; Papernot et al., 2016), which are maliciously designed to deceive the target model by generating carefully crafted adversarial perturbations on original clean inputs. Moreover, adversarial examples can transfer across models to mislead other models with a high probability (Papernot et al., 2017; Liu et al., 2017). How to effectively defense against adversarial attacks is crucial for security-critical computer vision systems, such as autonomous driving. ",
+        "bbox": [
+            174,
+            756,
+            825,
+            867
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "As a promising approach, adversarial training defends from adversarial perturbations by training a target classifier with adversarial examples. Researchers have found (Goodfellow et al.; Kurakin et al., 2016b; Madry et al., 2018) that adversarial training could increase the robustness of neural networks. However, adversarial training often obtains adversarial examples by taking a specific attack technique (e.g., FGSM) into consideration, so the defense targeted such attack and the trained model exhibits weak generalization ability on adversarial examples from other adversaries (Kurakin et al., 2016b). Tramer et al. (2018) showed that the robustness of adversarial training can be easily cir- \\` cumvented by the attack that combines with random perturbation from other models. Accordingly, for most existing adversarial training methods, there is a risk of overfitting to adversarial examples crafted on the original model with the specific attack. ",
+        "bbox": [
+            176,
+            875,
+            823,
+            902
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            214
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we propose a novel adversarial training method that is able to improve the generalization of adversarial training. From the perspective of domain adaptation (DA) (Torralba & Efros, 2011), there is a big domain gap between the distribution of clean examples and the distribution of adversarial examples in the high-level representation space, even though adversarial perturbations are imperceptible to humans. Liao et al. (2018) showed that adversarial perturbations are progressively amplified along the layer hierarchy of neural networks, which maximizes the distance between the original and adversarial subspace representations. In addition, adversarial training simply injects adversarial examples from a specific attack into the training set, but there is still a large sample space for adversarial examples. Accordingly, training with the classification loss on such a training set will probably lead to overfitting on the adversarial examples from the specific attack. Even though Wong & Kolter (2018) showed that adversarial training with iterative noisy attacks has stronger robustness than the adversarial training with single-step attacks, iterative attacks have a large computational cost and there is no theoretical analysis to justify that the adversarial examples sampled in such way could be sufficiently representative for the adversarial domain. ",
+        "bbox": [
+            174,
+            222,
+            825,
+            416
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our contributions are focused on how to improve the generalization of adversarial training on the simple yet scalable attacks, such as FGSM (Goodfellow et al.). The key idea of our approach is to formulate the learning procedure as a domain adaptation problem with limited number of target domain samples, where target domain denotes adversarial domain. Specifically, we introduce unsupervised as well as supervised domain adaptation into adversarial training to minimize the gap and increase the similarity between the distributions of clean examples and adversarial examples. In this way, the learned models generalize well on adversarial examples from different $\\ell _ { \\infty }$ bounded attacks. We evaluate our ATDA method on standard benchmark datasets. Empirical results show that despite a small decay of accuracy on clean data, ATDA significantly improves the generalization ability of adversarial training and has the transfer ability to extend to adversarial training on PGD (Madry et al., 2018). ",
+        "bbox": [
+            174,
+            422,
+            825,
+            575
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 BACKGROUND AND RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            597,
+            511,
+            613
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this section, we introduce some notations and provides a brief overview of the current advanced attack methods, as well as the defense methods based on adversarial training. ",
+        "bbox": [
+            173,
+            627,
+            823,
+            655
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 NOTATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            669,
+            287,
+            683
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Denote the clean data domain and the adversarial data domain by $\\mathcal { D }$ and $\\mathcal { A }$ respectively, we consider a classifier based on a neural network $f ( \\boldsymbol { x } ) : \\mathbb { R } ^ { d }  \\mathbb { R } ^ { k }$ . $f ( x ) { \\dot { } }$ outputs the probability distribution for an input $x \\in [ 0 , 1 ] ^ { d }$ , and $k$ denotes the number of classes in the classification task. Let $\\varphi$ be the mapping at the logits layer (the last neural layer before the final softmax function), so that $f ( x ) = s o f t m a x ( \\varphi ( x ) )$ . Let $\\epsilon$ be the magnitude of the perturbation. Let $x ^ { a d v }$ be the adversarial image computed by perturbing the original image $x$ . The cost function of image classification is denoted as $J ( x , y )$ . We define the logits as the logits layer representation, and define the logit space as the semantic space of the logits layer representation. ",
+        "bbox": [
+            174,
+            695,
+            825,
+            808
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We divide attacks into two types: white-box attacks have the complete knowledge of the target model and can fully access the model; black-box attacks have limited knowledge of the target classifier (e.g.,its architecture) but can not access the model weights. ",
+        "bbox": [
+            176,
+            814,
+            823,
+            856
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.2 ATTACK METHODS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            869,
+            346,
+            883
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We consider four attack methods to generate adversarial examples. For all attacks, the components of adversarial examples are clipped in [0, 1]. ",
+        "bbox": [
+            176,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Fast Gradient Sign Method (FGSM). Goodfellow et al. introduced FGSM to generate adversarial examples by applying perturbations in the direction of the gradient. ",
+        "bbox": [
+            171,
+            103,
+            821,
+            132
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/08f2a37d64e6d2eea668e44db7e2d2f16af455b6c9d3ef5d0255f93c67f3cb09.jpg",
+        "text": "$$\n\\boldsymbol { x } ^ { a d v } = \\boldsymbol { x } + \\epsilon \\cdot \\mathrm { s i g n } ( \\nabla _ { x } J ( x , \\bar { y _ { t r u e } } ) )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            379,
+            131,
+            619,
+            148
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "As compared with other attack methods, FGSM is a simple, yet fast and efficient adversary. Accordingly, FGSM is particularly amenable to adversarial training. ",
+        "bbox": [
+            171,
+            154,
+            823,
+            183
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Projected Gradient Descent (PGD). The Projected Gradient Descent (PGD) adversary was introduced by Madry et al. (2018) without random start, which is a stronger iterative variant of FGSM. This method applies FGSM iteratively for $k$ times with a budget $\\alpha$ instead of a single step. ",
+        "bbox": [
+            173,
+            189,
+            823,
+            232
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/16e4cffe22479f0d421952f40b0acbc249ac453d6180f83b71b8cca317171631.jpg",
+        "text": "$$\nx ^ { a d v _ { 0 } } = x \n$$",
+        "text_format": "latex",
+        "bbox": [
+            464,
+            231,
+            534,
+            246
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a12c3631abbd18ae61432309aafd4fb100db6ed8fcd44d338e543adb5de98fc6.jpg",
+        "text": "$$\n\\begin{array} { c } { { x ^ { a d v _ { t + 1 } } = x ^ { a d v _ { t } } + \\alpha \\cdot \\mathrm { s i g n } ( \\nabla _ { x } J ( x ^ { a d v _ { t } } , y _ { t r u e } ) ) } } \\\\ { { x ^ { a d v _ { t + 1 } } = { \\bf c l i p } ( x ^ { a d v _ { t + 1 } } , x ^ { a d v _ { t + 1 } } - \\epsilon , x ^ { a d v _ { t + 1 } } + \\epsilon ) } } \\\\ { { x ^ { a d v } = x ^ { a d v _ { k } } } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            333,
+            250,
+            665,
+            309
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Here $\\mathbf { c l i p } ( \\cdot , a , b )$ function forces its input to reside in the range of $[ a , b ]$ . PGD usually yields a higher success rate than FGSM does in the white-box setting but shows weaker capability in the black-box setting. ",
+        "bbox": [
+            176,
+            315,
+            825,
+            359
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "RAND $+$ FGSM $\\mathbf { \\left( R + F G S M \\right) }$ . Tramer et al. (2018) proposed\\` $\\mathrm { R + F G S M }$ against adversarially trained models by applying a small random perturbation of step size $\\alpha$ before applying FGSM. ",
+        "bbox": [
+            173,
+            364,
+            821,
+            393
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/88abf6e8c934c3afd99346ea2a8e2e6515383abbbd564750ba6bf89de068837b.jpg",
+        "text": "$$\n\\begin{array} { c } { x ^ { \\prime } = x + \\dot { \\alpha } \\cdot \\mathrm { s i g n } ( \\mathcal { N } ( \\mathbf { 0 } ^ { d } , \\mathbf { I } ^ { \\dot { d } } ) ) } \\\\ { x ^ { a d v } = x ^ { \\prime } + ( \\epsilon - \\alpha ) \\cdot \\mathrm { s i g n } ( \\nabla _ { x } J ( x ^ { a d v } , y _ { t r u e } ) ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            343,
+            392,
+            655,
+            433
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Momentum Iterative Method (MIM). MIM (Dong et al., 2018) is a modification of the iterative FGSM and it won the first place of NIPS 2017 Adversarial Attacks Competition. Its basic idea is to utilize the gradients of the previous $t$ steps with a decay factor $\\mu$ to update the gradient at step $t + 1$ before applying FGSM with a budget $\\alpha$ . ",
+        "bbox": [
+            174,
+            436,
+            825,
+            492
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6a0e6b4770cfe3f91908457c7b104bcd3a73e095ebde25992b829fb42c7d5432.jpg",
+        "text": "$$\nx ^ { a d v _ { 0 } } = x , g _ { 0 } = 0\n$$$$\n\\begin{array} { c } { { x ^ { a u v _ { 0 } } = x , g _ { 0 } = 0 } } \\\\ { { } } \\\\ { { g _ { t + 1 } = \\mu \\cdot g _ { t } + \\frac { \\nabla _ { x } J \\left( x ^ { a d v _ { t } } , y _ { t r u e } \\right) } { \\left\\| \\nabla _ { x } J \\left( x ^ { a d v _ { t } } , y _ { t r u e } \\right) \\right\\| _ { 1 } } } } \\\\ { { } } \\\\ { { x ^ { a d v _ { t + 1 } } = x ^ { a d v _ { t } } + \\alpha \\cdot \\mathrm { s i g n } ( g _ { t + 1 } ) } } \\\\ { { } } \\\\ { { x ^ { a d v _ { t + 1 } } = \\mathbf { c l i p } ( x ^ { a d v _ { t + 1 } } , x ^ { a d v _ { t + 1 } } - \\epsilon , x ^ { a d v _ { t + 1 } } + \\epsilon ) } } \\\\ { { x ^ { a d v } = x ^ { a d v _ { k } } } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            331,
+            497,
+            666,
+            604
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.3 PROGRESS ON ADVERSARIAL TRAINING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            628,
+            490,
+            642
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "An intuitive technique to defend a deep model against adversarial examples is adversarial training, which injects adversarial examples into the training data during the training process. First, Goodfellow et al. proposed to increase the robustness by feeding the model with both original and adversarial examples generated by FGSM and by learning with the modified objective function. ",
+        "bbox": [
+            173,
+            656,
+            825,
+            712
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5c7a4ace065de022d5e29e65b84c86800891d23cccde98ed63b1f8f756f61297.jpg",
+        "text": "$$\n\\hat { J } ( x , y _ { t r u e } ) = \\alpha J ( x , y _ { t r u e } ) + ( 1 - \\alpha ) J ( x + \\epsilon \\cdot \\mathrm { s i g n } ( \\nabla _ { x } J ( x , y _ { t r u e } ) ) , y _ { t r u e } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            246,
+            712,
+            750,
+            729
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Kurakin et al. (2016b) scaled the adversarial training to ImageNet (Russakovsky et al., 2015) and showed better results by replacing half the clean example at each batch with the corresponding adversarial examples. Meanwhile, Kurakin et al. (2016b) discovered the label leaking effect and suggested not to use the FGSM defined with respect to the true label $y _ { t r u e }$ . However, their approach has weak robustness to the $\\mathrm { R A N D + F G S M }$ adversary. Tramer et al. (2018) proposed an\\` ensemble adversarial training to improve robustness on black-box attacks by injecting adversarial examples transferred from a number of fixed pre-trained models into the training data. ",
+        "bbox": [
+            173,
+            734,
+            825,
+            834
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "For adversarial training, another approach is to train only with adversarial examples. Nøkland (2015) proposed a specialization of the method (Goodfellow et al.) that learned only with the objective function of adversarial examples. Madry et al. (2018) demonstrated successful defenses based on adversarial training with the noisy PGD, which randomly initialize an adversarial example within the allowed norm ball before running iterative attack. However, this technique is difficult to scale to large-scale neural networks (Kurakin et al., 2016a) as the iterative attack increases the training time by a factor that is roughly equal to the number of iterative steps. Wong & Kolter (2018) developed a robust training method by linear programming that minimized the loss for the worst case within the perturbation ball around each clean data point. However, their approach achieved high test error on clean data and it is still challenging to scale to deep or wide neural networks. ",
+        "bbox": [
+            173,
+            839,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            160
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "As described above, though adversarial training is promising, it is difficult to select a representative adversary to train on and most existing methods are weak in generalization for various adversaries, as the region of the adversarial examples for each clean data is large and contiguous (Tramer et al., \\` 2017; Tabacof & Valle, 2016). Furthermore, generating a representative set of adversarial examples for large-scale datasets is computationally expensive. ",
+        "bbox": [
+            174,
+            166,
+            825,
+            236
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 ADVERSARIAL TRAINING WITH DOMAIN ADAPTATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            262,
+            661,
+            279
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In this work, instead of focusing on a better sampling strategy to obtain representative adversarial data from the adversarial domain, we are especially concerned with the problem of how to train with clean data and adversarial examples from the efficient FGSM, so that the adversarially trained model is strong in generalization for different adversaries and has a low computational cost during the training. ",
+        "bbox": [
+            174,
+            295,
+            825,
+            366
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We propose an Adversarial Training with Domain Adaptation (ATDA) method to defense adversarial attacks and expect the learned models generalize well for various adversarial examples. Our motivation is to treat the adversarial training on FGSM as a domain adaptation task with limited number of target domain samples, where the target domain denotes adversarial domain. We combine standard adversarial training with the domain adaptor, which minimizes the domain gap between clean examples and adversarial examples. In this way, our adversarially trained model is effective on adversarial examples crafted by FGSM but also shows great generalization on other adversaries. ",
+        "bbox": [
+            174,
+            371,
+            825,
+            470
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 DOMAIN ADAPTATION ON LOGIT SPACE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            488,
+            493,
+            502
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1.1 UNSUPERVISED DOMAIN ADAPTATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            516,
+            493,
+            530
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Suppose we are given some clean training examples $\\{ x _ { i } \\}$ $( x _ { i } \\in \\mathbb { R } ^ { d } )$ with labels $\\{ y _ { i } \\}$ from the clean data domain $\\mathcal { D }$ , and adversarial examples $\\left\\{ x _ { i } ^ { a d v } \\right\\} ( x _ { i } ^ { a \\setminus v } \\in \\mathbb { R } ^ { d } )$ from adversarial data domain $\\mathcal { A }$ . The adversarial examples are obtained by sampling $( x _ { i } , y _ { t r u e } )$ from , computing small perturbations on $x _ { i }$ to generate adversarial perturbations, and outputting $( x _ { i } ^ { a d v } , y _ { t r u e } )$ . ",
+        "bbox": [
+            174,
+            542,
+            825,
+            599
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "It’s known that there is a huge shift in the distributions of clean data and adversarial data in the high-level representation space. Assume that in the logit space, data from either the clean domain or the adversarial domain follow a multivariate normal distribution, i.e., $\\mathcal { D } \\sim \\mathcal { N } ( \\mu _ { \\mathcal { D } } , \\Sigma _ { \\mathcal { D } } ) , \\mathcal { A } \\sim$ $\\mathcal { N } ( \\mu _ { \\mathcal { A } } , \\Sigma _ { \\mathcal { A } } )$ . Our goal is to learn the logits representation that minimizes the shift by aligning the covariance matrices and the mean vectors of the clean distribution and the adversarial distribution. ",
+        "bbox": [
+            173,
+            606,
+            825,
+            676
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To implement the CORrelation ALignment (CORAL), we define a covariance distance between the clean data and the adversarial data as follows. ",
+        "bbox": [
+            176,
+            681,
+            820,
+            710
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c0b8e2cdbb9d87830d2b249a118de18e8ccc27f3ed24dde5f140752ea11a430e.jpg",
+        "text": "$$\n\\mathcal { L } _ { C O R A L } ( \\mathcal { D } , \\mathcal { A } ) = \\frac { 1 } { k ^ { 2 } } \\left. C _ { \\varphi ( \\mathcal { D } ) } - C _ { \\varphi ( A ) } \\right. _ { \\ell _ { 1 } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            354,
+            710,
+            643,
+            739
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $C _ { \\varphi ( \\mathcal { D } ) }$ and $C _ { \\varphi ( \\mathcal { A } ) }$ are the covariance matrices of the clean data and the adversarial data in the logit space respectively, and $\\| \\cdot \\| _ { \\ell _ { 1 } }$ denotes the $L _ { 1 }$ norm of a matrix. Note that $\\mathcal { L } _ { C O R A L } ( \\mathcal { D } , \\mathcal { A } )$ is slightly different from the CORAL loss proposed by Sun & Saenko (2016). ",
+        "bbox": [
+            174,
+            744,
+            825,
+            789
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Similarly, we use the standard distribution distance metric, Maximum Mean Discrepancy (MMD) (Borgwardt et al., 2006), to minimize the distance of the mean vectors of the clean data and the adversarial data. ",
+        "bbox": [
+            174,
+            794,
+            825,
+            835
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8ee5e8625eb21fa4ee447733cd4c53686b34f65782466e00010efa1f292bc6a2.jpg",
+        "text": "$$\n\\mathcal { L } _ { M M D } ( \\mathcal { D } , \\mathcal { A } ) = \\frac { 1 } { k } \\left\\| \\frac { 1 } { | \\mathcal { D } | } \\sum _ { x \\in \\mathcal { D } } \\varphi ( x ) - \\frac { 1 } { | \\mathcal { A } | } \\sum _ { x ^ { a d v } \\in \\mathcal { A } } \\varphi ( x ^ { a d v } ) \\right\\| _ { 1 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            295,
+            832,
+            702,
+            882
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The loss function for Unsupervised Domain Adaptation (UDA) can be calculated as follows. ",
+        "bbox": [
+            168,
+            887,
+            779,
+            901
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/613ee4bea2f6ada997a1ec55c29a29dc04944240dfec54b34e8bf328d6cc9e51.jpg",
+        "text": "$$\n\\mathcal { L } _ { U D A } ( \\mathcal { D } , A ) = \\mathcal { L } _ { C O R A L } ( \\mathcal { D } , A ) + \\mathcal { L } _ { M M D } ( \\mathcal { D } , A )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            331,
+            905,
+            668,
+            922
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1.2 SUPERVISED DOMAIN ADAPTATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            472,
+            117
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Even though the unsupervised domain adaptation achieves perfect confusion alignment, there is no guarantee that samples of the same label from clean domain and adversarial domain would map nearby in the logit space. To effectively utilize the labeled data in the adversarial domain, we introduce a supervised domain adaptation (SDA) by proposing a new loss function, denoted as margin loss, to minimize the intra-class variations and maximize the inter-class variations on samples of different domains. The SDA loss is shown in Eq. (9). ",
+        "bbox": [
+            174,
+            127,
+            825,
+            212
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ee13dc7c6b744d195f80c3776fad4f189b290bba5afd737e4816f50c203ad4dd.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\mathcal { L } _ { S D A } ( \\mathcal { D } , \\mathcal { A } ) = \\mathcal { L } _ { m a r g i n } ( \\mathcal { D } , \\mathcal { A } ) } \\\\ & { \\quad \\quad \\quad = \\frac { 1 } { ( k - 1 ) ( | \\mathcal { D } | + | A | ) } \\cdot } \\\\ & { \\quad \\quad \\quad \\displaystyle \\sum _ { x \\in \\mathcal { D } \\cup \\mathcal { A } \\ : c ^ { n } \\in C \\backslash \\{ c _ { y t r u e } \\} } s o f t p l u s ( \\| \\varphi ( x ) - c _ { y _ { t r u e } } \\| _ { 1 } - \\| \\varphi ( x ) - c ^ { n } \\| _ { 1 } ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            220,
+            210,
+            776,
+            301
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Here sof tplus denotes a function $l n ( 1 + e x p ( \\cdot ) )$ ; $c _ { y _ { t r u e } } \\in \\mathbb { R } ^ { k }$ denotes the center of $y _ { t r u e }$ class in the logit space; $C = \\{ c _ { j } \\ | \\ j = 1 , 2 , . . . , k \\}$ is a set consisting of the logits center for each class, which will be updated as the logits changed. Similar to the center loss (Wen et al., 2016), we update center $c _ { j }$ for each class $j$ : ",
+        "bbox": [
+            176,
+            306,
+            825,
+            363
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bcd7070b9e271a1f3bb0f57a5836434061ca9ee0da4b474e9f1dfc93cf069902.jpg",
+        "text": "$$\n\\Delta c _ { j } ^ { t } = \\frac { \\sum _ { x \\in \\mathcal { D } \\cup \\mathcal { A } } \\mathbf { 1 } _ { \\mathrm { y _ { t r u e } = j } } \\cdot \\left( c _ { j } ^ { t } - \\varphi ( x ) \\right) } { 1 + \\sum _ { x \\in \\mathcal { D } \\cup \\mathcal { A } } \\mathbf { 1 } _ { \\mathrm { y _ { t r u e } = j } } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            364,
+            361,
+            632,
+            422
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbf { 1 } _ { \\mathrm { c o n d i t i o n } } = 1$ if the condition is true, otherwise $\\mathbf { 1 } _ { \\mathrm { c o n d i t i o n } } = 0$ ; $\\alpha$ denotes the learning rate of the centers. During the training process, the logits center for each class can integrate the logits representation from both the clean domain and the adversarial domain. ",
+        "bbox": [
+            174,
+            426,
+            825,
+            468
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 ADVERSARIAL TRAINING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            479,
+            393,
+            494
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For adversarial training, iterative attacks are fairly expensive to compute and single-step attacks are fast to compute. Accordingly, we use a variant of FGSM attack (Kurakin et al., 2016b) that avoids the label leaking effect to generate a new adversarial example $x _ { i } ^ { a d v }$ for each clean example $x _ { i }$ . ",
+        "bbox": [
+            173,
+            506,
+            825,
+            549
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/beb329b5c17caa6aaadf1c6920848c18b031e45515e70a4740c742966f7d4d64.jpg",
+        "text": "$$\n\\boldsymbol { x } _ { i } ^ { a d v } = \\boldsymbol { x } _ { i } + \\epsilon \\cdot \\mathrm { s i g n } ( \\nabla _ { \\boldsymbol { x } } J ( x _ { i } , y _ { t a r g e t } ) )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            367,
+            551,
+            629,
+            569
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $y _ { t a r g e t }$ denotes the predicted class $\\arg \\operatorname* { m a x } \\{ \\varphi ( x _ { i } ) \\}$ of the model. ",
+        "bbox": [
+            176,
+            574,
+            648,
+            590
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "However, in this case, the sampled adversarial examples are aggressive but not sufficiently representative due to the fact that the sampled adversarial examples always lie at the boundary of the $\\ell _ { \\infty }$ ball of radius $\\epsilon$ (see Figure 1) and the adversarial examples within the boundary are ignored. For adversarial training, if we train a deep neural network only on the clean data and the adversarial data from the FGSM attack, the adversarially trained model will overfit on these two kinds of data and exhibits weak generalization ability on the adversarial examples sampled from other attacks. From a different perspective, such problem can be viewed as a domain adaptation problem with limited number of labeled target domain samples, as only some special data point can be sampled in the adversarial domain by FGSM adversary. ",
+        "bbox": [
+            173,
+            595,
+            825,
+            722
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/6d76daf6b5c79adbc300a71d24eb443091f12ab9d0ce2d8bc271552b22f2d5c1.jpg",
+        "image_caption": [
+            "Figure 1: Illustration of the adversarial sampling by FGSM for $x _ { i } \\in \\mathbb { R } ^ { 2 }$ . The blue dot (in the center) represents a clean example and the red dots (along the boundary) represent the potential adversarial examples for the clean example. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            436,
+            723,
+            563,
+            808
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Consequently, it is natural to combine the adversarial training with domain adaptation to improve the generalization ability on adversarial data. We generate new adversarial examples by the variant of FGSM attack shown in Eq. (11), then we use the following loss function to meet the criteria of domain adaptation while training a strong classifier. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e9467db89a0c7eb7be9c3ffa154f565c532ae4e88b85d5d8658ab96de73479fc.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\mathcal { L } ( \\mathcal { D } , \\mathcal { A } ) = \\mathcal { L } _ { C } ( \\mathcal { D } ) + \\mathcal { L } _ { C } ( \\mathcal { A } ) + \\lambda \\cdot \\mathcal { L } _ { D A } ( \\mathcal { D } , \\mathcal { A } ) } \\\\ & { \\quad \\quad \\quad = \\mathcal { L } _ { C } ( \\mathcal { D } ) + \\mathcal { L } _ { C } ( \\mathcal { A } ) + \\lambda \\cdot ( \\mathcal { L } _ { U D A } ( \\mathcal { D } , \\mathcal { A } ) + \\mathcal { L } _ { S D A } ( \\mathcal { D } , \\mathcal { A } ) ) } \\\\ & { \\quad \\quad \\quad = \\displaystyle \\frac { 1 } { m } \\sum _ { x \\in \\mathcal { D } } \\mathcal { L } _ { C } ( x | y _ { t r u e } ) + \\frac { 1 } { m } \\sum _ { x ^ { a d v } \\in \\mathcal { A } } \\mathcal { L } _ { C } ( x ^ { a d v } | y _ { t r u e } ) } \\\\ & { \\quad \\quad \\quad \\quad + \\lambda \\cdot ( \\mathcal { L } _ { C O R A L } ( \\mathcal { D } , \\mathcal { A } ) + \\mathcal { L } _ { M M D } ( \\mathcal { D } , \\mathcal { A } ) + \\mathcal { L } _ { m a r g i n } ( \\mathcal { D } , \\mathcal { A } ) ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            258,
+            94,
+            738,
+            191
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Here $\\lambda$ is the hyper-parameter to balance the regularization term; $m$ is the number of input clean examples; $\\mathcal { D }$ indicates the input clean examples $\\{ x _ { i } \\}$ , and $\\mathcal { A }$ the corresponding adversarial examples $\\{ x _ { i } ^ { a d \\bar { v } } \\}$ ; $\\mathcal { L } _ { C }$ denotes the classification loss. The training process is summarized in Algorithm 1. ",
+        "bbox": [
+            176,
+            195,
+            821,
+            237
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 Adversarial training with domain adaptation on network $f ( \\boldsymbol { x } ) : \\mathbb { R } ^ { d }  \\mathbb { R } ^ { k }$ .   \nParameters: Size of the training minibatch is $m$ .   \n1: Randomly initialize network $f ( x )$ and logits centers $\\{ c _ { j } \\mid j = 1 , 2 , . . . , k \\}$ ;   \n2: Number of iterations $t \\gets 0$ ;   \n3: repeat   \n4: $t \\gets t + 1$ ;   \n5: Read a minibatch of data $\\mathcal { D } _ { b } = \\{ x _ { 1 } , . . . , x _ { m } \\}$ from the training set;   \n6: Use the current state of network $f$ to generate adversarial examples $\\mathcal { A } _ { b } = \\{ x _ { 1 } ^ { a d v } , . . . , x _ { m } ^ { a d v } \\}$ by the FGSM variant that avoids label leaking;   \n7: Extract logits for examples $\\mathcal { D } _ { b }$ , $\\mathcal { A } _ { b }$ by performing forward-backward propagation from the input layer to the logits layer $\\varphi ( x )$ ;   \n8: Update parameters $c _ { j }$ for each class $j$ by $c _ { j } ^ { t + 1 } = c _ { j } ^ { t } - \\alpha \\cdot \\Delta c _ { j } ^ { t }$ ;   \n9: Compute the loss by Eq. (12) and update parameters of network $f$ by back propagation; 10: until the training converges. ",
+        "bbox": [
+            176,
+            251,
+            825,
+            462
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            481,
+            326,
+            497
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In this section, we evaluate our ATDA method on various benchmark datasets to demonstrate the robustness and contrast its performance against other competing methods under different white-box and black-box attacks with bounded $\\ell _ { \\infty }$ norm. Code for these experiments is available at https: //github.com/JHL-HUST/ATDA. ",
+        "bbox": [
+            174,
+            510,
+            825,
+            565
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 EXPERIMENTAL SETUP ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            577,
+            375,
+            590
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Datasets. We consider four popular datasets, namely Fashion-MNIST (Xiao et al., 2017), SVHN (Netzer et al., 2011), CIFAR-10 and CIFAR-100 (Krizhevsky & Hinton, 2009). For all experiments, we normalize the pixel values to [0, 1] by dividing 255. ",
+        "bbox": [
+            176,
+            603,
+            823,
+            645
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Baselines. To evaluate the generalization power on adversarial examples in both the white-box and black-box settings, we report the clean test accuracy, the defense accuracy on FGSM, PGD, $\\mathrm { R + F G S M }$ and MIM in the non-targeted way. The common settings for these attacks are shown in Table 5 of the Appendix. We compare our ATDA method with normal training as well as several state-of-the-art adversarial training methods: ",
+        "bbox": [
+            174,
+            651,
+            825,
+            722
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "• Normal Training (NT). Training with cross-entropy loss on the clean training data.   \n• Standard Adversarial Training (SAT) (Goodfellow et al.). Training with the cross-entropy on the clean training data and the adversarial examples from the FGSM variant with perturbation $\\epsilon$ to avoid label leaking.   \n• Ensemble Adversarial Training (EAT) (Tramer et al., 2018). Training with cross-entropy \\` on the clean training data and the adversarial examples crafted from the currently trained model and the static pre-trained models by the FGSM variant with the perturbation $\\epsilon$ to avoid label leaking.   \n• Provably Robust Training (PRT) (Wong & Kolter, 2018). Training with cross-entropy loss on the worst case in the $\\ell _ { \\infty }$ ball of radius $\\epsilon$ around each clean training data point. It could be seen as training with a complicated method of sampling in the $\\ell _ { \\infty }$ ball of radius $\\epsilon$ . ",
+        "bbox": [
+            215,
+            726,
+            825,
+            891
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Evaluation Setup. For each benchmark dataset, we train a normal model and various adversarial models with perturbation $\\epsilon$ on a main model with ConvNet architecture, and evaluate them on various attacks bounded by \u000f. Moreover, for Ensemble Adversarial Training (EAT), we use two different models as the static pre-trained models. For black-box attacks, we test trained models on the adversarial examples transferred from a model held out during the training. All experiments are implemented on a single Titan X GPU. For all experiments, we set the hyper-parameter $\\lambda$ in Eq. (12) to $1 / 3$ and the hyper-parameter $\\alpha$ in Eq. (10) to 0.1. For more details about neural network architectures and training hyper-parameters, see Appendix A. We tune the networks to make sure they work, not to post concentrates on optimizing these settings. ",
+        "bbox": [
+            173,
+            896,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            202
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 COMPARISON OF DEFENSE PERFORMANCE ON ACCURACY ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            212,
+            620,
+            227
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We evaluate the defense performance of our ATDA method from the perspective of classification accuracy on various datasets, and compare with the baselines. ",
+        "bbox": [
+            173,
+            238,
+            823,
+            267
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Evaluation on Fashion-MNIST. The accuracy results on Fashion-MNIST are reported in Table 1a. NT yields the best performance on the clean data, but generalizes poorly on adversarial examples. SAT and EAT overfit on the clean data and the adversarial data from FGSM. PRT achieves lower error against various adversaries, but higher error on the clean data. ATDA achieves stronger robustness against different $\\ell _ { \\infty }$ bounded adversaries as compared to SAT (adversarial training on FGSM). ",
+        "bbox": [
+            174,
+            273,
+            825,
+            344
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Evaluation on SVHN. The classification accuracy on SVHN are summarized in Table 1b. PRT seems to degrade the performance on the clean testing data and exhibits weak robustness on various attacks. As compared to SAT, ATDA achieves stronger generalization ability on adversarial examples from various attacks and higher accuracy on the white-box adversaries, at the same time it only loses a negligible performance on clean data. ",
+        "bbox": [
+            174,
+            351,
+            823,
+            420
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Evaluation on CIFAR-10. Compared with Fashion-MNIST and SVHN, CIFAR-10 is a more difficult dataset for classification. As PRT is challenging and expensive to scale to large neural networks due to its complexity, the results of PRT are not reported. The accuracy results on CIFAR-10 are summarized in Table 1c. ATDA outperforms all the competing methods on most adversaries, despite a slightly lower performance on clean data. ",
+        "bbox": [
+            174,
+            426,
+            825,
+            497
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Evaluation on CIFAR-100. The CIFAR-100 dataset contains 100 image classes, with 600 images per class. Our goal here is not to achieve state-of-the-art performance on CIFAR-100, but to compare the generalization ability of different training methods on a comparatively large dataset. The results on CIFAR-100 are summarized in Table 1d. Compared to SAT, ATDA achieves better generalization on various adversarial examples and it does not degrade the performance on clean data. ",
+        "bbox": [
+            174,
+            503,
+            825,
+            574
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In conclusion, the accuracy results provide empirical evidence that ATDA has great generalization ability on different adversaries as compared to SAT and outperforms other competing methods. ",
+        "bbox": [
+            173,
+            580,
+            823,
+            609
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.3 FURTHER ANALYSIS ON THE DEFENSE PERFORMANCE ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            626,
+            593,
+            640
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To further investigate the defence performance of the proposed method, we compute two other metrics: the local loss sensitivity to perturbations and the shift of adversarial data distribution with respect to the clean data distribution. ",
+        "bbox": [
+            176,
+            651,
+            821,
+            694
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Local Loss Sensitivity. One method to quantify smoothness and generalization to perturbations for models is the local loss sensitivity (Arpit et al., 2017). It is calculated in the clean testing data as follows. The lower the value is, the smoother the loss function is. ",
+        "bbox": [
+            173,
+            700,
+            825,
+            742
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/38264dc23d699caecabcc3920ac8f74ff5826f0f178842c6fc939b911f115a60.jpg",
+        "text": "$$\n\\mathcal { S } = \\frac { 1 } { m } \\sum _ { i = 1 } ^ { m } \\| \\nabla _ { \\boldsymbol { x } } J ( x _ { i } , y _ { i } ) \\| _ { 2 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            405,
+            746,
+            593,
+            786
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The results of the local loss sensitivity for the aforementioned learned models are summarized in Table 2. The results suggest that adversarial training methods do increase the smoothness of the model as compared with the normal training and ATDA performs the best. ",
+        "bbox": [
+            173,
+            790,
+            825,
+            833
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Distribution Discrepancy. To quantify the dissimilarity of the distributions between the clean data and the adversarial data, we compare our learned logits embeddings with the logits embeddings of the competing methods on Fashion-MNIST. We use t-SNE (Maaten & Hinton, 2008) for the comparison on the training data, testing data and adversarial testing data from the white-box FGSM or PGD. The comparisons are illustrated in Figure 2 and we report the detailed MMD distances across domains in Table 3. Compared with NT, SAT and EAT actually increase the MMD distance across domains of the clean data and the adversarial data. In contrast, PRT and ATDA can learn domain invariance between the clean domain and the adversarial domain. Furthermore, our learned logits representation achieves the best performance on domain invariance. ",
+        "bbox": [
+            173,
+            839,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            103,
+            821,
+            146
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/e69a92a4e94f1e0a02bb5350194911f69b9e4ea39857b07c96a3ea2cfe451c62.jpg",
+        "table_caption": [
+            "Table 1: The accuracy of defense methods on the testing datasets and the adversarial examples generated by various adversaries. ",
+            "(a) On Fashion-MNIST. The magnitude of perturbations is 0.1 in $\\ell _ { \\infty }$ norm. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td></td><td colspan=\"4\">White-Box Attack (%)</td><td colspan=\"4\">Black-Box Attack (%)</td></tr><tr><td>Defense</td><td>Clean (%)</td><td>FGSM</td><td>PGD</td><td>R+FGSM</td><td>MIM</td><td>FGSM</td><td>PGD</td><td>R+FGSM</td><td>MIM</td></tr><tr><td>NT</td><td>90.5</td><td>8.3</td><td>0.1</td><td>15.0</td><td>0.1</td><td>52.1</td><td>52.6</td><td>68.2</td><td>44.3</td></tr><tr><td>SAT</td><td>90.9</td><td>88.8</td><td>7.4</td><td>31.2</td><td>9.4</td><td>79.8</td><td>80.1</td><td>81.8</td><td>80.0</td></tr><tr><td>EAT</td><td>90.8</td><td>89.0</td><td>4.3</td><td>31.6</td><td>6.6</td><td>80.8</td><td>81.4</td><td>82.3</td><td>78.8</td></tr><tr><td>PRT</td><td>76.9</td><td>67.4</td><td>66.8</td><td>72.2</td><td>66.7</td><td>75.5</td><td>75.5</td><td>76.4</td><td>75.4</td></tr><tr><td>ATDA</td><td>85.5</td><td>78.2</td><td>68.6</td><td>77.0</td><td>68.8</td><td>83.8</td><td>83.7</td><td>84.5</td><td>83.3</td></tr></table>",
+        "bbox": [
+            223,
+            217,
+            777,
+            320
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "(b) On SVHN. The magnitude of perturbations is 0.02 in $\\ell _ { \\infty }$ norm. ",
+        "bbox": [
+            294,
+            329,
+            696,
+            343
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/3be65306905096029550c2682e36811b8e53db894cb9a31c02dbc6d06e443516.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Defense</td><td rowspan=\"2\">Clean (%)</td><td colspan=\"4\">White-Box Attack (%)</td><td colspan=\"4\">Black-Box Attack (%)</td></tr><tr><td>FGSM</td><td>PGD</td><td>R+FGSM</td><td>MIM</td><td>FGSM</td><td>PGD</td><td>R+FGSM</td><td>MIM</td></tr><tr><td>NT</td><td>84.9</td><td>19.6</td><td>3.6</td><td>33.3</td><td>4.6</td><td>64.3</td><td>68.0</td><td>76.5</td><td>64.8</td></tr><tr><td>SAT</td><td>86.6</td><td>52.1</td><td>44.4</td><td>70.4</td><td>46.1</td><td>79.0</td><td>79.7</td><td>83.3</td><td>78.7</td></tr><tr><td>EAT</td><td>88.6</td><td>47.1</td><td>34.4</td><td>67.6</td><td>36.6</td><td>80.4</td><td>81.3</td><td>85.3</td><td>80.2</td></tr><tr><td>PRT</td><td>58.5</td><td>41.7</td><td>41.1</td><td>49.5</td><td>41.2</td><td>53.7</td><td>54.9</td><td>56.1</td><td>54.0</td></tr><tr><td>ATDA</td><td>82.9</td><td>57.2</td><td>53.2</td><td>70.6</td><td>53.9</td><td>75.3</td><td>76.4</td><td>79.5</td><td>75.4</td></tr></table>",
+        "bbox": [
+            223,
+            349,
+            777,
+            450
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/b1e1809766d0d606ed4f8e59359b7fb5c3cf01dedc1f1beefe9ee304d05d45a6.jpg",
+        "table_caption": [
+            "(c) On CIFAR-10. The magnitude of perturbations is $4 / 2 5 5$ in $\\ell _ { \\infty }$ norm. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td></td><td colspan=\"4\">White-Box Attack (%)</td><td colspan=\"4\">Black-Box Attack (%)</td></tr><tr><td>Defense</td><td>Clean (%)</td><td>FGSM</td><td>PGD</td><td>R+FGSM</td><td>MIM</td><td>FGSM</td><td>PGD</td><td>R+FGSM</td><td>MIM</td></tr><tr><td>NT</td><td>86.9</td><td>4.3</td><td>0.5</td><td>19.6</td><td>0.9</td><td>41.3</td><td>23.8</td><td>60.9</td><td>25.8</td></tr><tr><td>SAT</td><td>86.2</td><td>52.4</td><td>49.5</td><td>70.2</td><td>50.5</td><td>80.5</td><td>80.5</td><td>83.5</td><td>80.3</td></tr><tr><td>EAT</td><td>86.0</td><td>46.7</td><td>43.5</td><td>67.5</td><td>44.5</td><td>80.0</td><td>80.1</td><td>83.2</td><td>79.8</td></tr><tr><td>PRT</td><td>-</td><td>1</td><td>-</td><td>1</td><td>-</td><td>-</td><td>1</td><td>-</td><td>1</td></tr><tr><td>ATDA</td><td>84.8</td><td>60.7</td><td>58.1</td><td>73.2</td><td>59.0</td><td>80.7</td><td>80.7</td><td>83.0</td><td>80.6</td></tr></table>",
+        "bbox": [
+            223,
+            481,
+            777,
+            582
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "(d) On CIFAR-100. The magnitude of perturbations is $4 / 2 5 5$ in $\\ell _ { \\infty }$ norm. ",
+        "bbox": [
+            276,
+            590,
+            720,
+            606
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/c5920cc1521815b3056571e0fef45eeb44017916474a6cd49fd2cb946addd272.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td></td><td colspan=\"4\">White-Box Attack (%)</td><td colspan=\"4\">Black-Box Attack (%)</td></tr><tr><td>Defense</td><td>Clean (%)</td><td>FGSM</td><td>PGD</td><td>R+FGSM</td><td>MIM</td><td>FGSM</td><td>PGD</td><td>R+FGSM</td><td>MIM</td></tr><tr><td>NT</td><td>59.0</td><td>0.2</td><td>0.4</td><td>6.1</td><td>0.4</td><td>28.8</td><td>23.8</td><td>41.6</td><td>24.2</td></tr><tr><td>SAT</td><td>58.7</td><td>17.7</td><td>18.0</td><td>34.8</td><td>17.9</td><td>53.2</td><td>53.1</td><td>55.8</td><td>53.0</td></tr><tr><td>EAT</td><td>59.1</td><td>12.5</td><td>13.5</td><td>31.1</td><td>13.2</td><td>52.0</td><td>52.2</td><td>55.7</td><td>51.9</td></tr><tr><td>PRT</td><td>-</td><td>1</td><td>1</td><td>-</td><td>-</td><td>-</td><td>1</td><td>1</td><td>1</td></tr><tr><td>ATDA</td><td>61.6</td><td>29.3</td><td>26.2</td><td>43.0</td><td>27.3</td><td>56.0</td><td>56.0</td><td>58.7</td><td>56.0</td></tr></table>",
+        "bbox": [
+            223,
+            611,
+            777,
+            713
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/278ce26c5f3c3f8b54e6023b2ab18c3e3d44ff2fd4e5c327103e8c9314efd5e8.jpg",
+        "table_caption": [
+            "Table 2: The local loss sensitivity analysis for defense methods. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Dataset</td><td colspan=\"5\">Local loss sensitivity</td></tr><tr><td>NT</td><td>SAT</td><td>EAT</td><td>PRT</td><td>ATDA</td></tr><tr><td>Fashion-MNIST</td><td>5.84</td><td>5.52</td><td>3.24</td><td>0.56</td><td>0.49</td></tr><tr><td>SVHN</td><td>13.48</td><td>2.03</td><td>2.41</td><td>1.79</td><td>1.64</td></tr><tr><td>CIFAR-10</td><td>6.56</td><td>1.61</td><td>2.08</td><td>-</td><td>0.90</td></tr><tr><td>CIFAR-100</td><td>23.16</td><td>7.13</td><td>8.40</td><td>-</td><td>2.67</td></tr></table>",
+        "bbox": [
+            220,
+            750,
+            772,
+            839
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.4 ABLATION STUDIES ON ATDA ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            856,
+            428,
+            869
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "To individually dissect the effectiveness of different components in ATDA (Standard Adversarial Training (SAT), Unsupervised Domain Adaptation (UDA), and Supervised Domain Adaptation (SDA)), we conduct a series of ablation experiments in Figure 3. For each model, we report the average accuracy rates over all white-box attacks and all black-box attacks, respectively. The results illustrate that, by aligning the covariance matrix and mean vector of the clean and adversarial examples, UDA plays a key role in improving the generalization of SAT on various attacks. In general, the aware of margin loss on SDA can also improve the defense quality on standard adversarial training, but the effectiveness is not very stable over all datasets. By combining UDA and SDA together with SAT, our final algorithm ATDA can exhibits stable improvements on the standard adversarial training. In general, the performance of ATDA is slightly better than SAT+UDA. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/b7ef2e600241eb6c23d1774b25e26bdd408455ffaed752493fac7c1fb3b92e60.jpg",
+        "table_caption": [
+            "Table 3: The MMD distance across domains in the logit space for defense methods on FashionMNIST. $\\mathcal { D }$ denotes the distribution of the clean testing data; $\\mathbf { \\nabla } A _ { F G S M }$ and $\\scriptstyle A _ { P G D }$ denote the distributions of the adversarial testing data generated by the white-box FGSM and PGD, respectively. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">MMD Distance</td><td colspan=\"5\">Defense Method</td></tr><tr><td>NT</td><td>SAT</td><td>EAT</td><td>PRT</td><td>ATDA</td></tr><tr><td>MMD(D,AFGSm)</td><td>2.174</td><td>5.353</td><td>5.120</td><td>0.098</td><td>0.005</td></tr><tr><td>MMD(D,APGD)</td><td>5.287</td><td>2.909</td><td>1.239</td><td>0.101</td><td>0.019</td></tr></table>",
+        "bbox": [
+            218,
+            160,
+            774,
+            228
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/730b9477b91b9877f4826a97e6bb83d64db0372b8edaf244562de95e2a5f7009.jpg",
+        "image_caption": [
+            "Figure 2: t-SNE visualizations for the embeddings of training data, testing data, and adversarial testing data from FGSM and PGD in the logit space for Fashion-MNIST. The first row to the fifth row correspond to NT, SAT, EAT, PRT and ATDA, respectively. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            218,
+            820,
+            757
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/7c06fc8a62b65c83cecb05b113671b85004a9b0a696f4aba338d1efddbfd0116.jpg",
+        "image_caption": [
+            "Figure 3: Ablation experiments for ATDA to investigate the impact of Standard Adversarial Training (SAT), Unsupervised Domain Adaptation (UDA), and Supervised Domain Adaptation (SDA). We report the average accuracy rates over all white-box attacks and all black-box attacks, respectively. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            90,
+            825,
+            217
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "4.5 EXTENSION TO PGD-ADVERSARIAL TRAINING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            281,
+            544,
+            295
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "ATDA can simply be extended to adversarial training on other adversaries. We now consider to extend the ATDA method to PGD-Adversarial Training (PAT) (Madry et al., 2018): adversarial training on the noisy PGD with perturbation $\\epsilon$ . By combining adversarial training on the noisy PGD with domain adaptation, we implement an extension of ATDA for PAT, called PATDA. For the noisy PGD, we set the iterated step $k$ as 10 and the budget $\\alpha$ as $\\epsilon / 4$ according to Madry et al. (2018). ",
+        "bbox": [
+            174,
+            306,
+            825,
+            377
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "As shown in Table 4, we evaluate the defense performance of PAT and PATDA on various datasets. On Fashion-MNIST, we observe that PATDA fails to increase robustness to most adversaries as compared to PAT. On SVHN, PAT and PATDA fail to converge properly. The results are not surprising, as training with the hard and sufficient adversarial examples (from the noisy PGD) requires the neural networks with more parameters. On CIFAR-10 and CIFAR-100, PATDA achieves stronger robustness to various attacks than PAT. In general, PATDA exhibits stronger robustness to various adversaries as compared to PAT. The results indicate that domain adaptation can be applied flexibly to adversarial training on other adversaries to improve the defense performance. ",
+        "bbox": [
+            173,
+            383,
+            825,
+            496
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "table",
+        "img_path": "images/86a3f11885607a019b596b4a534d8c16e89652ef5830da1b2393ad4a0934e492.jpg",
+        "table_caption": [
+            "Table 4: The accuracy of PAT and PATDA on the testing datasets and the adversarial examples generated by various adversaries. The magnitude of perturbations in $\\ell _ { \\infty }$ norm is 0.1 for FashionMNIST, 0.02 for SVHN, and 4/255 for CIFAR-10 and CIFAR-100. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Dataset</td><td rowspan=\"2\">Defense</td><td rowspan=\"2\">Clean (%)</td><td colspan=\"4\">White-Box Attack (%)</td><td colspan=\"4\">Black-Box Attack(%)</td></tr><tr><td>FGSM</td><td>PGD</td><td>R+FGSM</td><td>MIM</td><td>FGSM</td><td>PGD</td><td>R+FGSM</td><td>MIM</td></tr><tr><td>Fashion-MNIST</td><td>PAT PATDA</td><td>85.3 83.2</td><td>78.7 77.0</td><td>76.5 75.5</td><td>81.7 79.8</td><td>76.7 75.7</td><td>81.8 84.0</td><td>83.9 81.7</td><td>84.8 82.4</td><td>83.8 81.6</td></tr><tr><td>SVHN</td><td>PAT PATDA</td><td>19.6 19.6</td><td>19.6 19.6</td><td>19.6 19.6</td><td>19.6 19.6</td><td>19.6 19.6</td><td>19.6 19.6</td><td>19.6 19.6</td><td>19.6 19.6</td><td>19.6 19.6</td></tr><tr><td>CIFAR-10</td><td>PAT PATDA</td><td>83.4 83.4</td><td>55.1 62.2</td><td>53.0 60.2</td><td>70.2 73.4</td><td>53.8 61.0</td><td>79.9 79.9</td><td>80.0 80.1</td><td>81.8 81.7</td><td>79.9 79.9</td></tr><tr><td>CIFAR-100</td><td>PAT PATDA</td><td>55.4 59.4</td><td>26.2 32.5</td><td>24.0 30.9</td><td>38.9 44.9</td><td>24.9 31.5</td><td>52.4 55.3</td><td>52.3 55.2</td><td>54.1 57.4</td><td>52.3 55.1</td></tr></table>",
+        "bbox": [
+            179,
+            560,
+            821,
+            705
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            734,
+            320,
+            751
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this study, we regard the adversarial training as a domain adaptation task with limited number of target labeled data. By combining adversarial training on FGSM adversary with unsupervised and supervised domain adaptation, the generalization ability on adversarial examples from various attacks and the smoothness on the learned models can be highly improved for robust defense. In addition, ATDA can easily be extended to adversarial training on iterative attacks (e.g., PGD) to improve the defense performance. The experimental results on several benchmark datasets suggest that the proposed ATDA and its extension PATDA achieve significantly better generalization results as compared with current competing adversarial training methods. ",
+        "bbox": [
+            174,
+            758,
+            825,
+            871
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            886,
+            326,
+            898
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "This work is supported by National Natural Science Foundation (61772219). ",
+        "bbox": [
+            176,
+            909,
+            676,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            285,
+            117
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Devansh Arpit, Stanislaw K. Jastrzebski, Nicolas Ballas, David Krueger, Emmanuel Bengio, Maxinder S. Kanwal, Tegan Maharaj, Asja Fischer, Aaron C. Courville, Yoshua Bengio, and Simon Lacoste-Julien. A closer look at memorization in deep networks. In Proceedings of the 34th International Conference on Machine Learning, ICML 2017, Sydney, NSW, Australia, 6-11 August 2017, pp. 233–242, 2017. ",
+        "bbox": [
+            173,
+            126,
+            826,
+            194
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Karsten M Borgwardt, Arthur Gretton, Malte J Rasch, Hans-Peter Kriegel, Bernhard Scholkopf, ¨ and Alex J Smola. Integrating structured biological data by kernel maximum mean discrepancy. Bioinformatics, 22(14):e49–e57, 2006. ",
+        "bbox": [
+            174,
+            204,
+            821,
+            246
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Djork-Arne Clevert, Thomas Unterthiner, and Sepp Hochreiter. Fast and accurate deep network ´ learning by exponential linear units (elus). arXiv preprint arXiv:1511.07289, 2015. ",
+        "bbox": [
+            171,
+            253,
+            823,
+            284
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yinpeng Dong, Fangzhou Liao, Tianyu Pang, Hang Su, Jun Zhu, Xiaolin Hu, and Jianguo Li. Boosting adversarial attacks with momentum. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2018. ",
+        "bbox": [
+            176,
+            290,
+            823,
+            333
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ian J Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples (2014). arXiv preprint arXiv:1412.6572. ",
+        "bbox": [
+            168,
+            342,
+            825,
+            371
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. Technical report, Citeseer, 2009. ",
+        "bbox": [
+            169,
+            378,
+            823,
+            407
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alexey Kurakin, Ian Goodfellow, and Samy Bengio. Adversarial examples in the physical world. arXiv preprint arXiv:1607.02533, 2016a. ",
+        "bbox": [
+            171,
+            415,
+            823,
+            445
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alexey Kurakin, Ian Goodfellow, and Samy Bengio. Adversarial machine learning at scale. arXiv preprint arXiv:1611.01236, 2016b. ",
+        "bbox": [
+            171,
+            452,
+            823,
+            481
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Fangzhou Liao, Ming Liang, Yinpeng Dong, Tianyu Pang, Jun Zhu, and Xiaolin Hu. Defense against adversarial attacks using high-level representation guided denoiser. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 1778–1787, 2018. ",
+        "bbox": [
+            174,
+            488,
+            821,
+            532
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yanpei Liu, Xinyun Chen, Chang Liu, and Dawn Song. Delving into transferable adversarial examples and black-box attacks. In International Conference on Learning Representations(ICLR), 2017. ",
+        "bbox": [
+            178,
+            540,
+            821,
+            582
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Laurens van der Maaten and Geoffrey Hinton. Visualizing data using t-sne. Journal of machine learning research, 9(Nov):2579–2605, 2008. ",
+        "bbox": [
+            169,
+            590,
+            825,
+            619
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Aleksander Madry, Aleksandar Makelov, Ludwig Schmidt, Dimitris Tsipras, and Adrian Vladu. Towards deep learning models resistant to adversarial attacks. In International Conference on Learning Representations(ICLR), 2018. ",
+        "bbox": [
+            176,
+            627,
+            823,
+            671
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yuval Netzer, Tao Wang, Adam Coates, Alessandro Bissacco, Bo Wu, and Andrew Y Ng. Reading digits in natural images with unsupervised feature learning. In NIPS workshop on deep learning and unsupervised feature learning, volume 2011, pp. 5, 2011. ",
+        "bbox": [
+            174,
+            678,
+            823,
+            722
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Arild Nøkland. Improving back-propagation by adding an adversarial gradient. arXiv preprint arXiv:1510.04189, 2015. ",
+        "bbox": [
+            171,
+            729,
+            823,
+            758
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nicolas Papernot, Patrick McDaniel, Somesh Jha, Matt Fredrikson, Z Berkay Celik, and Ananthram Swami. The limitations of deep learning in adversarial settings. In Security and Privacy (EuroS&P), 2016 IEEE European Symposium on, pp. 372–387, 2016. ",
+        "bbox": [
+            173,
+            765,
+            825,
+            809
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nicolas Papernot, Patrick McDaniel, Ian Goodfellow, Somesh Jha, Z Berkay Celik, and Ananthram Swami. Practical black-box attacks against machine learning. In Proceedings of the 2017 ACM on Asia Conference on Computer and Communications Security, pp. 506–519, 2017. ",
+        "bbox": [
+            174,
+            816,
+            825,
+            859
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael S. Bernstein, Alexander C. Berg, and Fei-Fei Li. Imagenet large scale visual recognition challenge. International Journal of Computer Vision, 115(3):211–252, 2015. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            922
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Baochen Sun and Kate Saenko. Deep coral: Correlation alignment for deep domain adaptation. In European Conference on Computer Vision, pp. 443–450, 2016.   \nChristian Szegedy, Google Inc, Wojciech Zaremba, Ilya Sutskever, Google Inc, Joan Bruna, Dumitru Erhan, Google Inc, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. In International Conference on Learning Representations(ICLR), 2014.   \nPedro Tabacof and Eduardo Valle. Exploring the space of adversarial images. In 2016 International Joint Conference on Neural Networks (IJCNN), pp. 426–433. IEEE, 2016.   \nAntonio Torralba and Alexei A Efros. Unbiased look at dataset bias. In Computer Vision and Pattern Recognition (CVPR), 2011 IEEE Conference on, pp. 1521–1528. IEEE, 2011.   \nFlorian Tramer, Nicolas Papernot, Ian J. Goodfellow, Dan Boneh, and Patrick D. McDaniel. The \\` space of transferable adversarial examples. arXiv preprint arXiv:1704.03453, 2017.   \nFlorian Tramer, Alexey Kurakin, Nicolas Papernot, Ian Goodfellow, Dan Boneh, and Patrick Mc- \\` Daniel. Ensemble adversarial training: Attacks and defenses. In International Conference on Learning Representations, 2018.   \nYandong Wen, Kaipeng Zhang, Zhifeng Li, and Yu Qiao. A discriminative feature learning approach for deep face recognition. In European Conference on Computer Vision, pp. 499–515, 2016.   \nEric Wong and J. Zico Kolter. Provable defenses against adversarial examples via the convex outer adversarial polytope. In Proceedings of the 35th International Conference on Machine Learning, ICML 2018, Stockholmsmassan, Stockholm, Sweden, July 10-15, 2018 ¨ , pp. 5283–5292, 2018.   \nYuxin Wu and Kaiming He. Group normalization. arXiv preprint arXiv:1803.08494, 2018.   \nHan Xiao, Kashif Rasul, and Roland Vollgraf. Fashion-mnist: a novel image dataset for benchmarking machine learning algorithms. arXiv preprint arXiv:1708.07747, 2017. ",
+        "bbox": [
+            169,
+            102,
+            826,
+            505
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A EXPERIMENTAL DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            418,
+            118
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In the appendix, we show all details of the common settings, neural network architectures and training hyper-parameters for the experiments. ",
+        "bbox": [
+            173,
+            140,
+            823,
+            169
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A.1 HYPER-PARAMETERS FOR ADVERSARIES. ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            196,
+            504,
+            212
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "For each dataset, the details about the hyper-parameters of various adversaries are shown in Table 5, where $\\epsilon$ denotes the magnitude of adversarial perturbations. ",
+        "bbox": [
+            173,
+            227,
+            823,
+            256
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/41b2da7ab21a074a853f2d1cfe91e528da2118c84727511549d1933433eacd74.jpg",
+        "table_caption": [
+            "Table 5: Common settings of attacks for all experiments "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Attack</td><td>Parameter</td><td>Norm</td></tr><tr><td>FGSM</td><td>N/A</td><td>lo</td></tr><tr><td>PGD</td><td>Iterated step k = 20,α = ∈/10</td><td>l</td></tr><tr><td>R+FGSM</td><td>Random perturbation α = ε/2</td><td>lo</td></tr><tr><td>MIM</td><td>Iterated step k = 10,α= ε/5,μ = 1.0</td><td>l8</td></tr></table>",
+        "bbox": [
+            199,
+            304,
+            802,
+            385
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A.2 NEURAL NETWORK ARCHITECTURES AND TRAINING HYPER-PARAMETERS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            438,
+            730,
+            452
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Fashion-MNIST. In the training phase, we use Adam optimizer with a learning rate of 0.001 and set the batch size to 64. For Fashion-MNIST, the neural network architectures for the main model, the static pre-trained models and the model held out during training are depicted in Table 6. For all adversarial training methods, the magnitude of perturbations is 0.1 in $\\ell _ { \\infty }$ norm. ",
+        "bbox": [
+            174,
+            467,
+            825,
+            523
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "SVHN. In the training phase, we use Adam optimizer with a learning rate of 0.001 and set the batch size to 32 and use the same architectures as in Fashion-MNIST. For all adversarial training methods, the magnitude of perturbations is 0.02 in $\\ell _ { \\infty }$ norm. ",
+        "bbox": [
+            174,
+            530,
+            825,
+            573
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/f381c9848b3e96eb27a186d4d69b2c5a2b93c711952c354d51ce024a0245a65b.jpg",
+        "table_caption": [
+            "Table 6: Neural network architectures used for the Fashion-MNIST and SVHN datasets. Conv: convolutional layer with Relu, FC: fully connected layer. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Main model</td><td>Pre-trained modelA</td><td>Pre-trained modelA</td><td>Holdout model</td></tr><tr><td>Conv(16, 4x4)</td><td>Conv(32,5x5)</td><td>Dropout(0.2)</td><td>Conv(64,3x3)</td></tr><tr><td>Conv(32, 4x4)</td><td>Conv(32, 5x5)</td><td>Conv(32,3x3)</td><td>FC(300) + Relu</td></tr><tr><td>FC(100) + Relu</td><td>Dropout(0.1)</td><td>Conv(32, 3x3)</td><td>Dropout(0.5)</td></tr><tr><td>FC(10)</td><td>FC(128) + Relu</td><td>FC(128) + Relu</td><td>FC(300) + Relu</td></tr><tr><td></td><td>Dropout(0.5)</td><td>Dropout(0.5)</td><td>Dropout(0.5)</td></tr><tr><td></td><td>FC(10)</td><td>FC(10)</td><td>FC(10)</td></tr></table>",
+        "bbox": [
+            197,
+            635,
+            799,
+            741
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "CIFAR-10. In the training phase, we use the same training settings as in SVHN. we use Adam optimizer with a learning rate of 0.001 and set the batch size to 32. In order to enhance the expressive power of deep neural networks, we use Exponential Linear Unit (ELU) (Clevert et al., 2015) as the activation function and introduce Group Normalization (Wu & He, 2018) into the architectures. The neural network architectures for CIFAR-10 are shown in Table 7. For all adversarial training methods, the magnitude of perturbations is $4 / 2 5 5$ in $\\ell _ { \\infty }$ norm. ",
+        "bbox": [
+            173,
+            776,
+            825,
+            861
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "CIFAR-100. We use the same training settings as in CIFAR-10. For CIFAR-100, the neural network architectures for the main model, the static pre-trained models and the model held out during training are shown in Table 8. For all adversarial training methods, the magnitude of perturbations is $4 / 2 5 5$ in $\\ell _ { \\infty }$ norm. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/64949b771db679f7a8016eb9a534cedbbc53036d914954229e67c41a2e013f5a.jpg",
+        "table_caption": [
+            "Table 7: Neural network architectures used for the CIFAR-10 dataset. Conv: convolutional layer with Group Normalization and ELU; GAP: global average pooling. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Main model</td><td>Pre-trained modelA</td><td>Pre-trained modelb</td><td>Holdout model</td></tr><tr><td>Conv(96, 3x3)</td><td>Conv(96, 5x5)</td><td>Conv(192, 5x5)</td><td>Conv(96, 3x3)</td></tr><tr><td>Conv(96,3x3)</td><td>Conv(96, 1x1)</td><td>Conv(96,1x1)</td><td>Dropout(0.2)</td></tr><tr><td>Conv(96, 3x3)</td><td>MaxPooling(3x3,2)</td><td>MaxPooling(3x3,2)</td><td>Conv(96,3x3) x 2</td></tr><tr><td>Dropout(0.5)</td><td>Dropout(0.5)</td><td>Dropout(0.5)</td><td>Dropout(0.5)</td></tr><tr><td>Conv(192,3x3) x 3</td><td>Conv(192, 5x5)</td><td>Conv(192, 5x5)</td><td>Conv(192,3x3) x 2</td></tr><tr><td>Dropout(0.5)</td><td>Conv(192,1x1)</td><td>Conv(192,1x1)</td><td>Dropout(0.5)</td></tr><tr><td>Conv(192, 3x3)</td><td>MaxPooling(3x3,2)</td><td>MaxPooling(3x3,2)</td><td>Conv(256, 3x3)</td></tr><tr><td>Conv(192, 1x1)</td><td>Dropout(0.5)</td><td>Dropout(0.5)</td><td>Conv(256, 1x1)</td></tr><tr><td>Conv(10,1x1)</td><td>Conv(256,3x3)</td><td>Conv(256,3x3)</td><td></td></tr><tr><td>GAP</td><td></td><td></td><td>Conv(10, 1x1)</td></tr><tr><td></td><td>Conv(256, 1x1)</td><td>Conv(256, 1x1)</td><td>GAP</td></tr><tr><td></td><td>Conv(10, 1x1)</td><td>Conv(10, 1x1)</td><td></td></tr><tr><td></td><td>GAP</td><td>GAP</td><td></td></tr></table>",
+        "bbox": [
+            199,
+            140,
+            800,
+            321
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/7fb6d534c782431667fdb5e8e10d41ff379c49491839176ce026e738d89555bb.jpg",
+        "table_caption": [
+            "Table 8: Neural network architectures used for the CIFAR-100 dataset. Conv: convolutional layer with Group Normalization and ELU; GAP: global average pooling. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Main model</td><td>Pre-trained modelA</td><td>Pre-trained modelB</td><td>Holdout model</td></tr><tr><td>Conv(96, 3x3)</td><td>Conv(96, 5x5)</td><td>Conv(192, 5x5)</td><td>Conv(96,3x3)</td></tr><tr><td>Conv(96, 3x3)</td><td>Conv(96,1x1)</td><td>Conv(96, 1x1)</td><td>Dropout(0.2)</td></tr><tr><td>Conv(96, 3x3)</td><td>MaxPooling(3x3,2)</td><td>MaxPooling(3x3,2)</td><td>Conv(96,3x3) x 2</td></tr><tr><td>Dropout(0.5)</td><td>Dropout(0.5)</td><td>Dropout(0.5)</td><td>Dropout(0.5)</td></tr><tr><td>Conv(192,3x3) x 3</td><td>Conv(192, 5x5)</td><td>Conv(192, 5x5)</td><td>Conv(192,3x3) x 2</td></tr><tr><td>Dropout(0.5)</td><td>Conv(192,1x1)</td><td>Conv(192, 1x1)</td><td>Dropout(0.5)</td></tr><tr><td>Conv(192,3x3)</td><td>MaxPooling(3x3,2)</td><td>MaxPooling(3x3,2)</td><td>Conv(256, 3x3)</td></tr><tr><td>Conv(192, 1x1)</td><td>Dropout(0.5)</td><td>Dropout(0.5)</td><td>Conv(256,1x1)</td></tr><tr><td>Conv(100, 1x1)</td><td>Conv(256,3x3)</td><td>Conv(256,3x3)</td><td>Conv(100, 1x1)</td></tr><tr><td>GAP</td><td>Conv(256,1x1)</td><td>Conv(256,1x1)</td><td>GAP</td></tr><tr><td></td><td>Conv(100,1x1)</td><td>Conv(100, 1x1)</td><td></td></tr><tr><td></td><td>GAP</td><td>GAP</td><td></td></tr></table>",
+        "bbox": [
+            199,
+            410,
+            797,
+            592
+        ],
+        "page_idx": 13
+    }
+]

parse/train/VzuIzbRDrum/VzuIzbRDrum.md

@@ -0,0 +1,333 @@
+# CSDI: Conditional Score-based Diffusion Models for Probabilistic Time Series Imputation
+
+Yusuke Tashiro123\*, Jiaming $\mathbf { S o n g ^ { 1 } }$ , Yang $\mathbf { S o n g ^ { 1 } }$ , Stefano Ermon1
+
+1Department of Computer Science, Stanford University, Stanford, CA, USA 2Mitsubishi UFJ Trust Investment Technology Institute, Tokyo, Japan 3Japan Digital Design, Tokyo, Japan {ytashiro,tsong,songyang,ermon}@cs.stanford.edu
+
+# Abstract
+
+The imputation of missing values in time series has many applications in healthcare and finance. While autoregressive models are natural candidates for time series imputation, score-based diffusion models have recently outperformed existing counterparts including autoregressive models in many tasks such as image generation and audio synthesis, and would be promising for time series imputation. In this paper, we propose Conditional Score-based Diffusion models for Imputation (CSDI), a novel time series imputation method that utilizes score-based diffusion models conditioned on observed data. Unlike existing score-based approaches, the conditional diffusion model is explicitly trained for imputation and can exploit correlations between observed values. On healthcare and environmental data, CSDI improves by $40 \%$ over existing probabilistic imputation methods on popular performance metrics. In addition, deterministic imputation by CSDI reduces the error by $5 . 2 0 \%$ compared to the state-of-the-art deterministic imputation methods. Furthermore, CSDI can also be applied to time series interpolation and probabilistic forecasting, and is competitive with existing baselines. The code is available at https://github.com/ermongroup/CSDI.
+
+# 1 Introduction
+
+Multivariate time series are abundant in real world applications such as finance, meteorology and healthcare. These time series data often contain missing values due to various reasons, including device failures and human errors [1, 2, 3]. Since missing values can hamper the interpretation of a time series, many studies have addressed the task of imputing missing values using machine learning techniques [4, 5, 6]. In the past few years, imputation methods based on deep neural networks have shown great success for both deterministic imputation [7, 8, 9] and probabilistic imputation [10]. These imputation methods typically utilize autoregressive models to deal with time series.
+
+Score-based diffusion models – a class of deep generative models and generate samples by gradually converting noise into a plausible data sample through denoising – have recently achieved state-ofthe-art sample quality in many tasks such as image generation [11, 12] and audio synthesis [13, 14], outperforming counterparts including autoregressive models. Diffusion models can also be used to impute missing values by approximating the scores of the posterior distribution obtained from the prior by conditioning on the observed values [12, 15, 16]. While these approximations may work well in practice, they do not correspond to the exact conditional distribution.
+
+In this paper, we propose CSDI, a novel probabilistic imputation method that directly learns the conditional distribution with conditional score-based diffusion models. Unlike existing score-based approaches, the conditional diffusion model is designed for imputation and can exploit useful information in observed values. We illustrate the procedure of time series imputation with CSDI in
+
+![](images/bbb84b188cfff95d08bdbe5640c15f0c108368c3767bf881aac104206ab4357c.jpg)  
+Figure 1: The procedure of time series imputation with CSDI. The reverse process $p _ { \theta }$ gradually converts random noise into plausible time series, conditioned on observed values $\mathbf { x } _ { 0 } ^ { \mathrm { { c o } } }$ . Dashed lines in each box represent observed values, which are plotted in order to show the relationship with generated imputation and not included in each ${ \bf x } _ { t } ^ { \mathrm { t a } }$ .
+
+Figure 1. We start imputation from random noise on the left of the figure and gradually convert the noise into plausible time series through the reverse process $p _ { \theta }$ of the conditional diffusion model. At each step $t$ , the reverse process removes noise from the output of the previous step $( t + 1 )$ . Unlike existing score-based diffusion models, the reverse process can take observations (on the top left of the figure) as a conditional input, allowing the model to exploit information in the observations for denoising. We utilize an attention mechanism to capture the temporal and feature dependencies of time series.
+
+For training the conditional diffusion model, we need observed values (i.e., conditional information) and ground-truth missing values (i.e., imputation targets). However, in practice we do not know the ground-truth missing values, or training data may not contain missing values at all. Then, inspired by masked language modeling, we develop a self-supervised training method that separates observed values into conditional information and imputation targets. We note that CSDI is formulated for general imputation tasks, and is not restricted to time series imputation.
+
+Our main contributions are as follows:
+
+• We propose conditional score-based diffusion models for probabilistic imputation (CSDI), and implement CSDI for time series imputation. To train the conditional diffusion model, we develop a self-supervised training method. • We empirically show that CSDI improves the continuous ranked probability score (CRPS) by $40 \%$ over existing probabilistic methods on healthcare and environmental data. Moreover, deterministic imputation with CSDI decreases the mean absolute error (MAE) by $5 - 2 0 \%$ compared to the state-of-the-art methods developed for deterministic imputation. • We demonstrate that CSDI can also be applied to time series interpolations and probabilistic forecasting, and is competitive with existing baselines designed for these tasks.
+
+# 2 Related works
+
+Time series imputations with deep learning Previous studies have shown deep learning models can capture the temporal dependency of time series and give more accurate imputation than statistical methods. A popular approach using deep learning is to use RNNs, including LSTMs and GRUs, for sequence modeling [17, 8, 7]. Subsequent studies combined RNNs with other methods to improve imputation performance, such as GANs [9, 18, 19] and self-training [20]. Among them, the combination of RNNs with attention mechanisms is particularly successful for imputation and interpolation of time series [21, 22]. While these methods focused on deterministic imputation, GP-VAE [10] has been recently developed as a probabilistic imputation method.
+
+Score-based generative models Score-based generative models, including score matching with Langevin dynamics [23] and denoising diffusion probabilistic models [11], have outperformed existing methods with other deep generative models in many domains, such as images [23, 11], audio [13, 14], and graphs [24]. Most recently, TimeGrad [25] utilized diffusion probabilistic models for probabilistic time series forecasting. While the method has shown state-of-the-art performance, it cannot be applied to time series imputation due to the use of RNNs to handle past time series.
+
+# 3 Background
+
+# 3.1 Multivariate time series imputation
+
+We consider $N$ multivariate time series with missing values. Let us denote the values of each time series as $\mathbf { X } = \{ x _ { 1 : K , 1 : L } \} \in \mathbb { R } ^ { K \times L }$ where $K$ is the number of features and $L$ is the length of time series. While the length $L$ can be different for each time series, we treat the length of all time series as the same for simplicity, unless otherwise stated. We also denote an observation mask as $\mathbf { M } = \{ m _ { 1 : K , 1 : L } \} \in \{ 0 , 1 \} ^ { \bar { K } \times L }$ where $m _ { k , l } = 0$ if $x _ { k , l }$ is missing, and $m _ { k , l } = 1$ if $x _ { k , l }$ is observed. We assume time intervals between two consecutive data entries can be different, and define the timestamps of the time series as $\mathbf { s } = \{ s _ { 1 : L } \} \in \mathbb { R } ^ { L }$ . In summary, each time series is expressed as $\{ \mathbf { X } , \mathbf { M } , \mathbf { s } \bar  \}$ .
+
+Probabilistic time series imputation is the task of estimating the distribution of the missing values of $\mathbf { X }$ by exploiting the observed values of $\mathbf { X }$ . We note that this definition of imputation includes other related tasks, such as interpolation, which imputes all features at target time points, and forecasting, which imputes all features at future time points.
+
+# 3.2 Denoising diffusion probabilistic models
+
+Let us consider learning a model distribution $p _ { \theta } ( \mathbf { x } _ { 0 } )$ that approximates a data distribution $q ( \mathbf { x } _ { 0 } )$ . Let $\mathbf { x } _ { t }$ for $t = 1 , \dots , T$ be a sequence of latent variables in the same sample space as $\mathbf { x } _ { \mathrm { 0 } }$ , which is denoted as $\mathcal { X }$ . Diffusion probabilistic models [26] are latent variable models that are composed of two processes: the forward process and the reverse process. The forward process is defined by the following Markov chain:
+
+$$
+q ( \mathbf { x } _ { 1 : T } \mid \mathbf { x } _ { 0 } ) : = \prod _ { t = 1 } ^ { T } q ( \mathbf { x } _ { t } \mid \mathbf { x } _ { t - 1 } ) { \mathrm { ~ w h e r e ~ } } q ( \mathbf { x } _ { t } \mid \mathbf { x } _ { t - 1 } ) : = { \mathcal { N } } \left( { \sqrt { 1 - { \beta _ { t } } } } \mathbf { x } _ { t - 1 } , { \beta _ { t } } \mathbf { I } \right)
+$$
+
+and $\beta _ { t }$ is a small positive constant that represents a noise level. Sampling of $\mathbf { x } _ { t }$ has the closed-form written as $q ( \mathbf { x } _ { t } \mid \mathbf { x } _ { 0 } ) = \mathcal { N } ( \mathbf { x } _ { t } ; \sqrt { \alpha _ { t } } \mathbf { x } _ { 0 } , ( 1 - \alpha _ { t } ) \mathbf { I } )$ where $\hat { \alpha } _ { t } : = 1 - \beta _ { t }$ and $\textstyle \alpha _ { t } : = \prod _ { i = 1 } ^ { t } { \hat { \alpha } } _ { i }$ . Then, $\mathbf { x } _ { t }$ can be expressed as $\mathbf { x } _ { t } = \sqrt { \alpha _ { t } } \mathbf { x } _ { 0 } + ( 1 - \alpha _ { t } ) \boldsymbol { \epsilon }$ where $\mathbf { \epsilon } \gets \mathcal { N } ( \mathbf { 0 } , \mathbf { I } )$ . On the other hand, the reverse process denoises $\mathbf { x } _ { t }$ to recover $\mathbf { x } _ { \mathrm { 0 } }$ , and is defined by the following Markov chain:
+
+$$
+\begin{array} { r l } & { p _ { \theta } ( \mathbf { x } _ { 0 : T } ) : = p ( \mathbf { x } _ { T } ) \displaystyle \prod _ { t = 1 } ^ { T } p _ { \theta } ( \mathbf { x } _ { t - 1 } \mid \mathbf { x } _ { t } ) , \quad \mathbf { x } _ { T } \sim \mathcal { N } ( \mathbf { 0 } , \mathbf { I } ) , } \\ & { p _ { \theta } ( \mathbf { x } _ { t - 1 } \mid \mathbf { x } _ { t } ) : = \mathcal { N } ( \mathbf { x } _ { t - 1 } ; \pmb { \mu } _ { \theta } ( \mathbf { x } _ { t } , t ) , \sigma _ { \theta } ( \mathbf { x } _ { t } , t ) \mathbf { I } ) . } \end{array}
+$$
+
+Ho et al. [11] has recently proposed denoising diffusion probabilistic models (DDPM), which considers the following specific parameterization of $p _ { \theta } ( \mathbf { x } _ { t - 1 } \mathbf { \bar { \rho } } \vert \mathbf { x } _ { t } )$ :
+
+$$
+\mu _ { \theta } ( \mathbf { x } _ { t } , t ) = \frac { 1 } { \alpha _ { t } } \left( \mathbf { x } _ { t } - \frac { \beta _ { t } } { \sqrt { 1 - \alpha _ { t } } } \epsilon _ { \theta } ( \mathbf { x } _ { t } , t ) \right) , \ \sigma _ { \theta } ( \mathbf { x } _ { t } , t ) = \tilde { \beta } _ { t } ^ { 1 / 2 } \ \mathrm { w h e r e } \ \tilde { \beta } _ { t } = \left\{ \begin{array} { l l } { \frac { 1 - \alpha _ { t - 1 } } { 1 - \alpha _ { t } } \beta _ { t } } & { t > 1 } \\ { \beta _ { 1 } } & { t = 1 } \end{array} \right.
+$$
+
+where $\epsilon _ { \theta }$ is a trainable denoising function. We denote $\mu _ { \theta } ( \mathbf { x } _ { t } , t )$ and $\sigma _ { \theta } ( \mathbf { x } _ { t } , t )$ in Eq. (3) as $\mu ^ { \mathrm { D D P M } } ( \mathbf { x } _ { t } , t , \epsilon _ { \theta } ( \mathbf { x } _ { t } , t ) )$ and $\sigma ^ { \mathrm { D D P M } } ( \mathbf { x } _ { t } , t )$ , respectively. The denoising function in Eq. (3) also corresponds to a rescaled score model for score-based generative models [23]. Under this parameterization, Ho et al. [11] have shown that the reverse process can be trained by solving the following optimization problem:
+
+$$
+\operatorname* { m i n } _ { \theta } \mathcal { L } ( \theta ) : = \operatorname* { m i n } _ { \theta } \mathbb { E } _ { \mathbf { x } _ { 0 } \sim q ( \mathbf { x } _ { 0 } ) , \epsilon \sim \mathcal { N } ( \mathbf { 0 } , \mathbf { I } ) , t } | | \epsilon - \epsilon _ { \theta } ( \mathbf { x } _ { t } , t ) | | _ { 2 } ^ { 2 } \quad \mathrm { w h e r e } \ \mathbf { x } _ { t } = \sqrt { \alpha _ { t } } \mathbf { x } _ { 0 } + ( 1 - \alpha _ { t } ) \epsilon .
+$$
+
+The denoising function $\epsilon _ { \theta }$ estimates the noise vector $\epsilon$ that was added to its noisy input $\mathbf { x } _ { t }$ . This training objective also be viewed as a weighted combination of denoising score matching used for training score-based generative models [23, 27, 12]. Once trained, we can sample $\mathbf { x } _ { \mathrm { 0 } }$ from Eq. (2). We provide the details of DDPM in Appendix A.
+
+# 3.3 Imputation with diffusion models
+
+Here, we focus on general imputation tasks that are not restricted to time series imputation. Let us consider the following imputation problem: given a sample $\mathbf { x } _ { \mathrm { 0 } }$ which contains missing values, we generate imputation targets $\mathbf { x } _ { 0 } ^ { \mathrm { { t a } } } \in \mathcal { X } ^ { \mathrm { { t a } } }$ by exploiting conditional observations $\mathbf { x } _ { 0 } ^ { \mathrm { { c o } } } \in \mathcal { X } ^ { \mathrm { { c o } } }$ , where $\bar { \mathcal X } ^ { \mathrm { t a } }$ and $\mathcal { X } ^ { \mathrm { c o } }$ are a part of the sample space $\mathcal { X }$ and vary per sample. Then, the goal of probabilistic imputation is to estimate the true conditional data distribution $q ( \mathbf { \bar { x } } _ { 0 } ^ { \mathrm { t a } } \mid \mathbf { x } _ { 0 } ^ { \mathrm { c o } } )$ with a model distribution $p _ { \theta } ( \mathbf { x } _ { 0 } ^ { \mathrm { { t a } } } \mid \mathbf { x } _ { 0 } ^ { \mathrm { { c o } } } )$ . We typically impute all missing values using all observed values, and set all observed values as $\mathbf { x } _ { 0 } ^ { \mathrm { { c o } } }$ and all missing values as $\mathbf { x } _ { 0 } ^ { \mathrm { { t a } } }$ , respectively. Note that time series imputation in Section 3.1 can be considered as a special case of this task.
+
+Let us consider modeling $p _ { \theta } ( \mathbf { x } _ { 0 } ^ { \mathrm { { t a } } } \mid \mathbf { x } _ { 0 } ^ { \mathrm { { c o } } } )$ with a diffusion model. In the unconditional case, the reverse process $p _ { \theta } ( \mathbf { x } _ { 0 : T } )$ is used to define the final data model $p _ { \theta } ( \mathbf { x } _ { 0 } )$ . Then, a natural approach is to extend the reverse process in Eq. (2) to a conditional one:
+
+$$
+\begin{array} { r l } & { p _ { \theta } ( \mathbf { x } _ { 0 : T } ^ { \mathrm { t a } } \mid \mathbf { x } _ { 0 } ^ { \mathrm { c o } } ) : = p ( \mathbf { x } _ { T } ^ { \mathrm { t a } } ) \displaystyle \prod _ { t = 1 } ^ { T } p _ { \theta } ( \mathbf { x } _ { t - 1 } ^ { \mathrm { t a } } \mid \mathbf { x } _ { t } ^ { \mathrm { t a } } , \mathbf { x } _ { 0 } ^ { \mathrm { c o } } ) , \quad \mathbf { x } _ { T } ^ { \mathrm { t a } } \sim \mathcal { N } ( \mathbf { 0 } , \mathbf { I } ) , } \\ & { p _ { \theta } ( \mathbf { x } _ { t - 1 } ^ { \mathrm { t a } } \mid \mathbf { x } _ { t } ^ { \mathrm { t a } } , \mathbf { x } _ { 0 } ^ { \mathrm { c o } } ) : = \mathcal { N } ( \mathbf { x } _ { t - 1 } ^ { \mathrm { t a } } ; \mu _ { \theta } ( \mathbf { x } _ { t } ^ { \mathrm { t a } } , t \mid \mathbf { x } _ { 0 } ^ { \mathrm { c o } } ) , \sigma _ { \theta } ( \mathbf { x } _ { t } ^ { \mathrm { t a } } , t \mid \mathbf { x } _ { 0 } ^ { \mathrm { c o } } ) \mathbf { I } ) . } \end{array}
+$$
+
+However, existing diffusion models are generally designed for data generation and do not take conditional observations $\mathbf { x } _ { 0 } ^ { \mathrm { { c o } } }$ as inputs. To utilize diffusion models for imputation, previous studies [12, 15, 16] approximated the conditional reverse process $p _ { \theta } ( \mathbf { x } _ { t - 1 } ^ { \mathrm { { t a } } } \mid \mathbf { x } _ { t } ^ { \mathrm { { t a } } } , \mathbf { x } _ { 0 } ^ { \mathrm { { c o } } } )$ with the reverse process in Eq. (2). With this approximation, in the reverse process they add noise to both the target and the conditional observations $\mathbf { x } _ { 0 } ^ { \mathrm { { c o } } }$ . While this approach can impute missing values, the added noise can harm useful information in the observations. This suggests that modeling $p _ { \theta } ( \mathbf { x } _ { t - 1 } ^ { \mathrm { { t a } } } \mid \mathbf { x } _ { t } ^ { \mathrm { { t a } } } , \mathbf { x } _ { 0 } ^ { \mathrm { { c o } } } )$ without approximations can improve the imputation quality. Hereafter, we call the model defined in Section 3.2 as the unconditional diffusion model.
+
+# 4 Conditional score-based diffusion model for imputation (CSDI)
+
+In this section, we propose CSDI, a novel imputation method based on a conditional score-based diffusion model. The conditional diffusion model allows us to exploit useful information in observed values for accurate imputation. We provide the reverse process of the conditional diffusion model, and then develop a self-supervised training method. We note that CSDI is not restricted to time series.
+
+# 4.1 Imputation with CSDI
+
+We focus on the conditional diffusion model with the reverse process in Eq. (5) and aim to model the conditional distribution $p ( \mathbf { x } _ { t - 1 } ^ { \mathrm { t a } } \mid \mathbf { x } _ { t } ^ { \mathrm { t a } } , \mathbf { x } _ { 0 } ^ { \mathrm { c o } } )$ without approximations. Specifically, we extend the parameterization of DDPM in Eq. (3) to the conditional case. We define a conditional denoising function $\epsilon _ { \theta } : ( \mathcal { X } ^ { \mathrm { t a } } \times \mathbb { R } \mid \mathcal { X } ^ { \mathrm { c o } } )  \mathcal { X } ^ { \mathrm { t a } }$ , which takes conditional observations $\mathbf { x } _ { 0 } ^ { \mathrm { { c o } } }$ as inputs. Then, we consider the following parameterization with $\epsilon _ { \theta }$ :
+
+$$
+\mu _ { \boldsymbol { \theta } } ( \mathbf { x } _ { t } ^ { \mathrm { t a } } , t \mid \mathbf { x } _ { 0 } ^ { \mathrm { c o } } ) = \mu ^ { \mathrm { D D P M } } ( \mathbf { x } _ { t } ^ { \mathrm { t a } } , t , \epsilon _ { \boldsymbol { \theta } } ( \mathbf { x } _ { t } ^ { \mathrm { t a } } , t \mid \mathbf { x } _ { 0 } ^ { \mathrm { c o } } ) ) , \quad \sigma _ { \boldsymbol { \theta } } ( \mathbf { x } _ { t } ^ { \mathrm { t a } } , t \mid \mathbf { x } _ { 0 } ^ { \mathrm { c o } } ) = \sigma ^ { \mathrm { D D P M } } ( \mathbf { x } _ { t } ^ { \mathrm { t a } } , t )
+$$
+
+where $\mu ^ { \mathrm { D D P M } }$ and $\sigma ^ { \mathrm { D D P M } }$ are the functions defined in Section 3.2. Given the function $\epsilon _ { \theta }$ and data $\mathbf { x } _ { \mathrm { 0 } }$ , we can sample $\mathbf { x } _ { 0 } ^ { \mathrm { t a } }$ using the reverse process in Eq. (5) and Eq. (6). For the sampling, we set all observed values of $\mathbf { x } _ { \mathrm { 0 } }$ as conditional observations $\mathbf { x } _ { 0 } ^ { \mathrm { { c o } } }$ and all missing values as imputation targets $\mathbf { x } _ { 0 } ^ { \mathrm { { t a } } }$ Note that the conditional model is reduced to the unconditional one under no conditional observations and can also be used for data generation.
+
+# 4.2 Training of CSDI
+
+Since Eq. (6) uses the same parameterization as Eq. (3) and the difference between Eq. (3) and Eq. (6) is only the form of $\epsilon _ { \theta }$ , we can follow the training procedure for the unconditional model in Section 3.2. Namely, given conditional observations √ $\mathbf { x } _ { 0 } ^ { \mathrm { { c o } } }$ and imputation targets $\mathbf { x } _ { 0 } ^ { \mathrm { t a } }$ , we sample noisy targets $\mathbf { x } _ { t } ^ { \mathrm { { t a } } } = \sqrt { \alpha _ { t } } \bar { \mathbf { x } } _ { 0 } ^ { \mathrm { { t a } } } + ( 1 - \alpha _ { t } ) \epsilon$ , and train $\epsilon _ { \theta }$ by minimizing the following loss function:
+
+$$
+\operatorname* { m i n } _ { \theta } \mathcal { L } ( \theta ) : = \operatorname* { m i n } _ { \theta } \mathbb { E } _ { \mathbf { x } _ { 0 } \sim q ( \mathbf { x } _ { 0 } ) , \epsilon \sim \mathcal { N } ( \mathbf { 0 } , \mathbf { I } ) , t } | | ( \epsilon - \epsilon _ { \theta } ( \mathbf { x } _ { t } ^ { \mathrm { t a } } , t \mid \mathbf { x } _ { 0 } ^ { \mathrm { c o } } ) ) | | _ { 2 } ^ { 2 }
+$$
+
+![](images/4d4be6e3883b120cb84f7b40b0f097416121248d7d4d14c7bb15628ef851b269.jpg)  
+Figure 2: The self-supervised training procedure of CSDI. On the middle left rectangle, the green and white areas represent observed and missing values, respectively. The observed values are separated into red imputation targets $\mathbf { x } _ { 0 } ^ { \mathrm { t a } }$ and blue conditional observations $\mathbf { x } _ { 0 } ^ { \mathrm { { c o } } }$ , and used for training of $\epsilon _ { \theta }$ . The colored areas in each rectangle mean the existence of values.
+
+Table 1: Imputation targets $\mathbf { x } _ { 0 } ^ { \mathrm { t a } }$ and conditional observations $\mathbf { x } _ { 0 } ^ { \mathrm { { c o } } }$ for CSDI at training and sampling.   
+
+<table><tr><td></td><td> imputation targets xta</td><td>conditional observations xco</td></tr><tr><td>sampling (imputation)</td><td>all missing values</td><td>all observed values</td></tr><tr><td>training</td><td>a subset of the observed values (sampled by a target choice strategy)</td><td>the remaining observed values</td></tr></table>
+
+where the dimension of $\epsilon$ corresponds to that of the imputation targets $\mathbf { x } _ { 0 } ^ { \mathrm { { t a } } }$
+
+However, this training procedure has an issue. Since we do not know the ground-truth missing values in practice, it is not clear how to select $\mathbf { x } _ { 0 } ^ { \mathrm { { c o } } }$ and $\mathbf { x } _ { 0 } ^ { \mathrm { t a } }$ from a training sample $\mathbf { x } _ { \mathrm { 0 } }$ . To address this issue, we develop a self-supervised learning method inspired by masked language modeling [28]. We illustrate the training procedure in Figure 2. Given a sample $\mathbf { x } _ { \mathrm { 0 } }$ , we separate observed values of $\mathbf { x } _ { \mathrm { 0 } }$ into two parts, and set one of them as imputation targets $\mathbf { x } _ { 0 } ^ { \mathrm { t a } }$ and the other as conditional observations $\mathbf { x } _ { 0 } ^ { \mathrm { { c o } } }$ . We choose the targets $\mathbf { x } _ { 0 } ^ { \mathrm { { t a } } }$ through a target choice strategy, which is discussed in Section 4.3. Then, we sample noisy targets ${ \bf x } _ { t } ^ { \mathrm { t a } }$ and train $\epsilon _ { \theta }$ by solving Eq. (7). We summarize how we set $\mathbf { x } _ { 0 } ^ { \mathrm { { c o } } }$ and $\mathbf { x } _ { 0 } ^ { \mathrm { { t a } } }$ for training and sampling in Table 1. We also provide the algorithm of training and sampling in Appendix B.1.
+
+# 4.3 Choice of imputation targets in self-supervised learning
+
+In the proposed self-supervised learning, the choice of imputation targets is important. We provide four target choice strategies depending on what is known about the missing patterns in the test dataset. We describe the algorithm for these strategies in Appendix B.2.
+
+(1) Random strategy : this strategy is used when we do not know about missing patterns, and randomly chooses a certain percentage of observed values as imputation targets. The percentage is sampled from $[ 0 \% , 1 0 0 \% ]$ to adapt to various missing ratios in the test dataset.
+
+(2) Historical strategy: this strategy exploits missing patterns in the training dataset. Given a training sample $\mathbf { x } _ { \mathrm { 0 } }$ , we randomly draw another sample $\tilde { \mathbf { x } } _ { 0 }$ from the training dataset. Then, we set the intersection of the observed indices of $\mathbf { x } _ { \mathrm { 0 } }$ and the missing indices of $\tilde { \mathbf { x } } _ { 0 }$ as imputation targets. The motivation of this strategy comes from structured missing patterns in the real world. For example, missing values often appear consecutively in time series data. When missing patterns in the training and test dataset are highly correlated, this strategy helps the model learn a good conditional distribution.
+
+(3) Mix strategy: this strategy is the mix of the above two strategies. The historical strategy may lead to overfitting to missing patterns in the training dataset. The Mix strategy can benefit from generalization by the random strategy and structured missing patterns by the historical strategy.
+
+(4) Test pattern strategy: when we know the missing patterns in the test dataset, we just set the patterns as imputation targets. For example, this strategy is used for time series forecasting, since the missing patterns in the test dataset are fixed to given future time points.
+
+# 5 Implementation of CSDI for time series imputation
+
+![](images/4ffe055c5adebee89536c944dfe02db241c2cf7a2e7459a190e50b95a8c73a5c.jpg)  
+Figure 3: The architecture of 2D attention. Given a tensor with $K$ features, $L$ length, and $C$ channels, the temporal Transformer layer takes tensors with $( 1 , L , C )$ shape as inputs and learns temporal dependency. The feature Transformer layer takes tensors with $( K , 1 , C )$ shape as inputs and learns feature dependency. The output shape of each layer is the same as the input shape.
+
+In this section, we implement CSDI for time series imputation. For the implementation, we need the inputs and the architecture of $\epsilon _ { \theta }$ .
+
+First, we describe how we process time series data as inputs for CSDI. As defined in Section 3.1, a time series is denoted as $\{ \mathbf { X } , \mathbf { M } , \mathbf { s } \}$ , and the sample space $\mathcal { X }$ of $\mathbf { X }$ is $\mathbb { R } ^ { K \times L }$ . We want to handle X in the sample space $\mathbb { R } ^ { K \times L }$ for learning dependencies in a time series using a neural network, but the conditional denoising function $\epsilon _ { \theta }$ takes inputs ${ \bf x } _ { t } ^ { \mathrm { t a } }$ and $\mathbf { x } _ { 0 } ^ { \mathrm { { c o } } }$ in varying sample spaces that are a part of $\mathcal { X }$ as shown in white areas of ${ \bf x } _ { t } ^ { \mathrm { t a } }$ and $\mathbf { x } _ { 0 } ^ { \mathrm { { c o } } }$ in Figure 2. To address this issue, we adjust the conditional denoising function $\epsilon _ { \theta }$ to inputs in the fixed sample space $\mathbb { R } ^ { K \times L }$ . Concretely, we fix the shape of the inputs ${ \bf x } _ { t } ^ { \mathrm { t a } }$ and $\mathbf { x } _ { 0 } ^ { \mathrm { { c o } } }$ to $( K \times L )$ by applying zero padding to ${ \bf x } _ { t } ^ { \mathrm { t a } }$ and $\mathbf { x } _ { 0 } ^ { \mathrm { { c o } } }$ . In other words, we set zero values to white areas for ${ \bf x } _ { t } ^ { \mathrm { t a } }$ and ${ \bf x } _ { 0 } ^ { \mathrm { c o } }$ in Figure 2. To indicate which indices are padded, we introduce the conditional mask $\mathbf { m } ^ { \mathrm { c o } } \in \{ 0 , 1 \} ^ { K \times L }$ as an additional input to $\epsilon _ { \theta }$ , which corresponds to $\mathbf { x } _ { 0 } ^ { \mathrm { { c o } } }$ and takes value 1 for indices of conditional observations. For ease of handling, we also fix the output shape in the sample space $\mathbb { R } ^ { K \times L }$ by applying zero padding. Then, the conditional denoising function $\epsilon _ { \theta } ( \mathbf { x } _ { t } ^ { \mathrm { { t a } } } , t \mid \mathbf { x } _ { 0 } ^ { \mathrm { { c o } } } , \mathbf { m } ^ { \mathrm { { c o } } } )$ can be written as $\begin{array} { r } { \overline { { \epsilon } } _ { \theta } : ( \mathbb { R } ^ { K \times L } \times \mathbb { R } ^ { \overline { { } } } \mid \mathbb { R } ^ { K \times L } \times \{ 0 , 1 \} ^ { K \times L } )  \mathbb { R } ^ { K \times \tilde { L } } } \end{array}$ . We discuss the effect of this adjustment on training and sampling in Appendix D.
+
+Under the adjustment, we set conditional observations $\mathbf { x } _ { 0 } ^ { \mathrm { { c o } } }$ and imputation targets $\mathbf { x } _ { 0 } ^ { \mathrm { t a } }$ for time series imputation by following Table 1. At sampling time, since conditional observations $\mathbf { x } _ { 0 } ^ { \mathrm { { c o } } }$ are all observed values, we set $\mathbf { m } ^ { \mathrm { c o } } = \mathbf { M }$ and $\begin{array} { r } { \mathbf { x } _ { 0 } ^ { \mathrm { c o } } = \mathbf { m } ^ { \mathrm { c o } } \odot \mathbf { X } } \end{array}$ where $\odot$ represents element-wise products. For training, we sample $\mathbf { x } _ { 0 } ^ { \mathrm { t a } }$ and $\mathbf { x } _ { 0 } ^ { \mathrm { c o } }$ through a target choice strategy, and set the indices of $\mathbf { x } _ { 0 } ^ { \mathrm { { c o } } }$ as $\mathbf { m } ^ { \mathrm { c o } }$ . Then, $\mathbf { x } _ { 0 } ^ { \mathrm { { c o } } }$ is written as $\mathbf { x } _ { 0 } ^ { \mathrm { c o } } = \mathbf { m } ^ { \mathrm { c o } } \odot \mathbf { X }$ and $\mathbf { x } _ { 0 } ^ { \mathrm { { t a } } }$ is obtained as $\mathbf { \bar { x } } _ { 0 } ^ { \mathrm { t a } } = \left( \mathbf { M } - \mathbf { m } ^ { \mathrm { c o } } \right) \odot \mathbf { X }$ .
+
+Next, we describe the architecture of $\epsilon _ { \theta }$ . We adopt the architecture in DiffWave [13] as the base, which is composed of multiple residual layers with residual channel $C$ . We refine this architecture for time series imputation. We set the diffusion step $T = 5 0$ . We discuss the main differences from DiffWave (see Appendix E.1 for the whole architecture and details).
+
+Attention mechanism To capture temporal and feature dependencies of multivariate time series, we utilize a two dimensional attention mechanism in each residual layer instead of a convolution architecture. As shown in Figure 3, we introduce temporal Transformer layer and a feature Transformer layer, which are 1-layer Transformer encoders. The temporal Transformer layer takes tensors for each feature as inputs to learn temporal dependency, whereas the feature Transformer layer takes tensors for each time point as inputs to learn temporal dependency.
+
+Note that while the length $L$ can be different for each time series as mentioned in Section 3.1, the attention mechanism allows the model to handle various lengths. For batch training, we apply zero padding to each sequence so that the lengths of the sequences are the same.
+
+Side information In addition to the arguments of $\epsilon _ { \theta }$ , we provide some side information as additional inputs to the model. First, we use time embedding of $\mathbf { s } = \left\{ s _ { 1 : L } \right\}$ to learn the temporal dependency. Following previous studies [29, 30], we use 128-dimensions temporal embedding. Second, we exploit categorical feature embedding for $K$ features, where the dimension is 16.
+
+# 6 Experimental results
+
+In this section, we demonstrate the effectiveness of CSDI for time series imputation. Since CSDI can be applied to other related tasks such as interpolation and forecasting, we also evaluate CSDI for these tasks to show the flexibility of CSDI. Due to the page limitation, we provide the detailed setup for experiments including train/validation/test splits and hyperparameters in Appendix E.2.
+
+# 6.1 Time series imputation
+
+Dataset and experiment settings We run experiments for two datasets. The first one is the healthcare dataset in PhysioNet Challenge 2012 [1], which consists of 4000 clinical time series with 35 variables for 48 hours from intensive care unit (ICU). Following previous studies [7, 8], we process the dataset to hourly time series with 48 time steps. The processed dataset contains around $80 \%$ missing values. Since the dataset has no ground-truth, we randomly choose $10 / 5 0 / 9 0 \%$ of observed values as ground-truth on the test data.
+
+The second one is the air quality dataset [2]. Following previous studies [7, 21], we use hourly sampled PM2.5 measurements from 36 stations in Beijing for 12 months and set 36 consecutive time steps as one time series. There are around $13 \%$ missing values and the missing patterns are not random. The dataset contains artificial ground-truth, whose missing patterns are also structured.
+
+For both dataset, we run each experiment five times. As the target choice strategy for training, we adopt the random strategy for the healthcare dataset and the mix of the random and historical strategy for the air quality dataset, based on the missing patterns of each dataset.
+
+Results of probabilistic imputation CSDI is compared with three baselines. 1) Multitask GP [31]: the method learns the covariance between timepoints and features simultaneously. 2) GP-VAE [10]: the method showed the state-of-the-art results for probabilistic imputation. 3) V-RIN [32]: a deterministic imputation method that uses the uncertainty quantified by VAE to improve imputation. For V-RIN, we regard the quantified uncertainty as probabilistic imputation. In addition, we compare CSDI with imputation using the unconditional diffusion model in order to show the effectiveness of the conditional one (see Appendix C for training and imputation with the unconditional diffusion model).
+
+We first show quantitative results. We adopt the continuous ranked probability score (CRPS) [33] as the metric, which is freuquently used for evaluating probabilistic time series forecasting and measures the compatibility of an estimated probability distribution with an observation. We generate 100 samples to approximate the probability distribution over missing values and report the normalized average of CRPS for all missing values following previous studies [34] (see Appendix E.3 for details of the computation).
+
+Table 2: Comparing CRPS for probabilistic imputation baselines and CSDI (lower is better). We report the mean and the standard error of CRPS for five trials.   
+
+<table><tr><td rowspan="2"></td><td colspan="3">healthcare</td><td rowspan="2"> air quality</td></tr><tr><td>10% missing</td><td>50% missing</td><td>90% missing</td></tr><tr><td>Multitask GP [31]</td><td>0.489(0.005)</td><td>0.581(0.003)</td><td>0.942(0.010)</td><td>0.301(0.003)</td></tr><tr><td>GP-VAE [10]</td><td>0.574(0.003)</td><td>0.774(0.004)</td><td>0.998(0.001)</td><td>0.397(0.009)</td></tr><tr><td>V-RIN [32]</td><td>0.808(0.008)</td><td>0.831(0.005)</td><td>0.922(0.003)</td><td>0.526(0.025)</td></tr><tr><td>unconditional</td><td>0.360(0.007)</td><td>0.458(0.008)</td><td>0.671(0.007)</td><td>0.135(0.001)</td></tr><tr><td>CSDI (proposed)</td><td>0.238(0.001)</td><td>0.330(0.002)</td><td>0.522(0.002)</td><td>0.108(0.001)</td></tr></table>
+
+![](images/69ce72ce314c6286db787f6e6e1f2d44bf21b580f69c761d60844f636f49fdf1.jpg)  
+Figure 4: Examples of probabilistic time series imputation for the healthcare dataset with $50 \%$ missing (left) and the air quality dataset (right). The red crosses show the observed values and the blue circles show the ground-truth imputation targets. For each method, median values of imputations are shown as the line and $5 \%$ and $9 5 \%$ quantiles are shown as the shade.
+
+Table 2 represents CRPS for each method. CSDI reduces CRPS by $40 \%$ compared to the existing baselines for both datasets. This indicates that CSDI generates more realistic distributions than other methods. We also observe that the imputation with CSDI outperforms that with the unconditional model. This suggests CSDI benefits from explicitly modeling the conditional distribution.
+
+We provide imputation examples in Figure 4. For the air quality dataset, CSDI (green solid line) provides accurate imputations with high confidence, while those by GP-VAE (gray dashed line) are far from ground-truth. CSDI also gives reasonable imputations for the healthcare dataset. These results indicate that CSDI exploits temporal and feature dependencies to provide accurate imputations. We give more examples in Appendix G.
+
+Table 3: Comparing MAE for deterministic imputation methods and CSDI. We report the mean and the standard error for five trials. The asterisks mean the results of the method are cited from the original paper.   
+
+<table><tr><td rowspan="2"></td><td colspan="3">healthcare</td><td rowspan="2"> air quality</td></tr><tr><td>10% missing</td><td>50% missing</td><td>90% missing</td></tr><tr><td>V-RIN [32]</td><td>0.271(0.001)</td><td>0.365(0.002)</td><td>0.606(0.006)</td><td>25.4(0.62)</td></tr><tr><td>BRITS[7]</td><td>0.284(0.001)</td><td>0.368(0.002)</td><td>0.517(0.002)</td><td>14.11(0.26)</td></tr><tr><td>BRITS [7] (*)</td><td>0.278</td><td></td><td></td><td>11.56</td></tr><tr><td>GLIMA [21](*)</td><td>0.265</td><td></td><td></td><td>10.54</td></tr><tr><td>RDIS [20]</td><td>0.319(0.002)</td><td>0.419(0.002)</td><td>0.631(0.002)</td><td>22.11(0.35)</td></tr><tr><td>unconditional</td><td>0.326(0.008)</td><td>0.417(0.010)</td><td>0.625(0.010)</td><td>12.13(0.07)</td></tr><tr><td>CSDI (proposed)</td><td>0.217(0.001)</td><td>0.301(0.002)</td><td>0.481(0.003)</td><td>9.60(0.04)</td></tr></table>
+
+Results of deterministic imputation We demonstrate that CSDI also provides accurate deterministic imputations, which are obtained as the median of 100 generated samples. We compare CSDI with four baselines developed for deterministic imputation including GLIMA [21], which combined recurrent imputations with an attention mechanism to capture temporal and feature dependencies and showed the state-of-the-art performance. These methods are based on autoregressive models. We use the original implementations except RDIS.
+
+We evaluate each method by the mean absolute error (MAE). In Table 3, CSDI improves MAE by $5 \%$ compared to the baselines. This suggests that the conditional diffusion model is effective to learn temporal and feature dependencies for imputation. For the healthcare dataset, the gap between the baselines and CSDI is particularly significant when the missing ratio is small, because more observed values help CSDI capture dependencies.
+
+Table 4: Comparing the state-of-the-art interpolation methods with CSDI for the healthcare dataset. We report the mean and the standard error of CRPS for five trials.   
+
+<table><tr><td></td><td>10% missing</td><td>50% missing</td><td>90% missing</td></tr><tr><td>Latent ODE [35]</td><td>0.700(0.002)</td><td>0.676(0.003)</td><td>0.761(0.010)</td></tr><tr><td>mTANs [22]</td><td>0.526(0.004)</td><td>0.567(0.003)</td><td>0.689(0.015)</td></tr><tr><td>CSDI (proposed)</td><td>0.380(0.002)</td><td>0.418(0.001)</td><td>0.556(0.003)</td></tr></table>
+
+# 6.2 Interpolation of irregularly sampled time series
+
+Dataset and experiment settings We use the same healthcare dataset as the previous section, but process the dataset as irregularly sampled time series, following previous studies [22, 35]. Since the dataset has no ground-truth, we randomly choose $10 / 5 0 / 9 0 \%$ of time points and use observed values at these time points as ground-truth on the test data. As the target choice strategy for training, we adopt the random strategy, which is adjusted for interpolation so that some time points are sampled.
+
+Results We compare CSDI with two baselines including mTANs [22], which utilized an attention mechanism and showed state-of-the-art results for the interpolation of irregularly sampled time series. We generate 100 samples to approximate the probability distribution as with the previous section. The result is shown in Table 4. CSDI outperforms the baselines for all cases.
+
+Table 5: Comparing probabilistic forecasting methods with CSDI. We report the mean and the standard error of CRPS-sum for three trials. The baseline results are cited from the original paper. ’TransMAF’ is the abbreviation for ’Transformer MAF’.   
+
+<table><tr><td></td><td>solar</td><td>electricity</td><td>traffic</td><td>taxi</td><td>wiki</td></tr><tr><td>GP-copula [34]</td><td>0.337(0.024)</td><td>0.024(0.002)</td><td>0.078(0.002)</td><td>0.208(0.183)</td><td>0.086(0.004)</td></tr><tr><td>TransMAF [36]</td><td>0.301(0.014)</td><td>0.021(0.000)</td><td>0.056(0.001)</td><td>0.179(0.002)</td><td>0.063(0.003)</td></tr><tr><td>TLAE [37]</td><td>0.124(0.033)</td><td>0.040(0.002)</td><td>0.069(0.001)</td><td>0.130(0.006)</td><td>0.241(0.001)</td></tr><tr><td>TimeGrad [25]</td><td>0.287(0.020)</td><td>0.021(0.001)</td><td>0.044(0.006)</td><td>0.114(0.020)</td><td>0.049(0.002)</td></tr><tr><td>CSDI (proposed)</td><td>0.298(0.004)</td><td>0.017(0.000)</td><td>0.020(0.001)</td><td>0.123(0.003)</td><td>0.047(0.003)</td></tr></table>
+
+# 6.3 Time series Forecasting
+
+Dataset and Experiment settings We use five datasets that are commonly used for evaluating probabilistic time series forecasting. Each dataset is composed of around 100 to 2000 features. We predict all features at future time steps using past time series. We use the same prediction steps as previous studies [34, 37]. For the target choice strategy, we adopt the Test pattern strategy.
+
+Results We compare CSDI with four baselines. Specifically, TimeGrad [25] combined the diffusion model with a RNN-based encoder. We evaluate each method for CRPS-sum, which is CRPS for the distribution of the sum of all time series across $K$ features and accounts for joint effect (see Appendix E.3 for details).
+
+In Table 5, CSDI outperforms the baselines for electricity and traffic datasets, and is competitive with the baselines as a whole. The advantage of CSDI over baselines for forecasting is smaller than that for imputation in Section 6.1. We hypothesize it is because the datasets for forecasting seldom contains missing values and are suitable for existing encoders including RNNs. For imputation, it is relatively difficult for RNNs to handle time series due to missing values.
+
+# 7 Conclusion
+
+In this paper, we have proposed CSDI, a novel approach to impute multivariate time series with conditional diffusion models. We have shown that CSDI outperforms the existing probabilistic and deterministic imputation methods.
+
+There are some interesting directions for future work. One direction is to improve the computation efficiency. While diffusion models generate plausible samples, sampling is generally slower than other generative models. To mitigate the issue, several recent studies leverage an ODE solver to accelerate the sampling procedure [12, 38, 13]. Combining our method with these approaches would likely improve the sampling efficiency.
+
+Another direction is to extend CSDI to downstream tasks such as classifications. Many previous studies have shown that accurate imputation improves the performance on downstream tasks [7, 18, 22]. Since conditional diffusion models can learn temporal and feature dependencies with uncertainty, joint training of imputations and downstream tasks using conditional diffusion models would be helpful to improve the performance of the downstream tasks.
+
+Finally, although our focus was on time series, it would be interesting to explore CSDI as imputation technique on other modalities.
+
+# Acknowledgements and Disclosure of Funding
+
+This research was supported by NSF(#1651565, #1522054, #1733686), ONR (N000141912145), AFOSR (FA95501910024), ARO (W911NF-21-1-0125) and Sloan Fellowship.
+
+# References
+
+[1] Ikaro Silva, George Moody, Daniel J Scott, Leo A Celi, and Roger G Mark. Predicting inhospital mortality of icu patients: The physionet/computing in cardiology challenge 2012. In Computing in Cardiology, pages 245–248. IEEE, 2012.   
+[2] Xiuwen Yi, Yu Zheng, Junbo Zhang, and Tianrui Li. ST-MVL: filling missing values in geo-sensory time series data. In Proceedings of International Joint Conference on Artificial Intelligence, pages 2704–2710, 2016.   
+[3] Huachun Tan, Guangdong Feng, Jianshuai Feng, Wuhong Wang, Yu-Jin Zhang, and Feng Li. A tensor-based method for missing traffic data completion. Transportation Research Part C: Emerging Technologies, 28:15–27, 2013.   
+[4] Fulufhelo V Nelwamondo, Shakir Mohamed, and Tshilidzi Marwala. Missing data: A comparison of neural network and expectation maximization techniques. Current Science, pages 1514–1521, 2007.   
+[5] Andrew T Hudak, Nicholas L Crookston, Jeffrey S Evans, David E Hall, and Michael J Falkowski. Nearest neighbor imputation of species-level, plot-scale forest structure attributes from lidar data. Remote Sensing of Environment, 112(5):2232–2245, 2008.   
+[6] S van Buuren and Karin Groothuis-Oudshoorn. MICE: Multivariate imputation by chained equations in r. Journal of statistical software, pages 1–68, 2010.   
+[7] Wei Cao, Dong Wang, Jian Li, Hao Zhou, Lei Li, and Yitan Li. BRITS: Bidirectional recurrent imputation for time series. In Advances in Neural Information Processing Systems, 2018.   
+[8] Zhengping Che, Sanjay Purushotham, Kyunghyun Cho, David Sontag, and Yan Liu. Recurrent neural networks for multivariate time series with missing values. Scientific reports, 8(1):1–12, 2018.   
+[9] Yonghong Luo, Xiangrui Cai, Ying Zhang, Jun Xu, and Xiaojie Yuan. Multivariate time series imputation with generative adversarial networks. In Advances in Neural Information Processing Systems, pages 1603–1614, 2018.   
+[10] Vincent Fortuin, Dmitry Baranchuk, Gunnar Rätsch, and Stephan Mandt. GP-VAE: Deep probabilistic time series imputation. In International Conference on Artificial Intelligence and Statistics, 2020.   
+[11] Jonathan Ho, Ajay Jain, and Pieter Abbeel. Denoising diffusion probabilistic models. In Advances in Neural Information Processing Systems, 2020.
+
+[12] Yang Song, Jascha Sohl-Dickstein, Diederik P Kingma, Abhishek Kumar, Stefano Ermon, and Ben Poole. Score-based generative modeling through stochastic differential equations. In International Conference on Learning Representations, 2021.
+
+[13] Zhifeng Kong, Wei Ping, Jiaji Huang, Kexin Zhao, and Bryan Catanzaro. DiffWave: A versatile diffusion model for audio synthesis. In International Conference on Learning Representations, 2021.
+
+[14] Nanxin Chen, Yu Zhang, Heiga Zen, Ron J Weiss, Mohammad Norouzi, and William Chan. WaveGrad: Estimating gradients for waveform generation. In International Conference on Learning Representations, 2021.
+
+[15] Zahra Kadkhodaie and Eero P Simoncelli. Solving linear inverse problems using the prior implicit in a denoiser. arXiv preprint arXiv:2007.13640, 2020.
+
+[16] Gautam Mittal, Jesse Engel, Hawthorne Curtis, and Ian Simon. Symbolic music generation with diffusion models. arXiv preprint arXiv:2103.16091, 2021.
+
+[17] Jinsung Yoon, William R Zame, and Mihaela van der Schaar. Estimating missing data in temporal data streams using multi-directional recurrent neural networks. IEEE Transactions on Biomedical Engineering, 66(5):1477–1490, 2018.
+
+[18] Yonghong Luo, Ying Zhang, Xiangrui Cai, and Xiaojie Yuan. E2GAN: End-to-end generative adversarial network for multivariate time series imputation. In Proceedings of International Joint Conference on Artificial Intelligence, pages 3094–3100, 2019.
+
+[19] Xiaoye Miao, Yangyang Wu, Jun Wang, Yunjun Gao, Xudong Mao, and Jianwei Yin. Generative semi-supervised learning for multivariate time series imputation. In The Thirty-Fifth AAAI Conference on Artificial Intelligence, 2021.
+
+[20] Tae-Min Choi, Ji-Su Kang, and Jong-Hwan Kim. RDIS: Random drop imputation with selftraining for incomplete time series data. In The Thirty-Fifth AAAI Conference on Artificial Intelligence, 2021.
+
+[21] Qiuling Suo, Weida Zhong, Guangxu Xun, Jianhui Sun, Changyou Chen, and Aidong Zhang. GLIMA: Global and local time series imputation with multi-directional attention learning. In 2020 IEEE International Conference on Big Data (Big Data), pages 798–807. IEEE, 2020.
+
+[22] Satya Narayan Shukla and Benjamin M Marlin. Multi-time attention networks for irregularly sampled time series. In International Conference on Learning Representations, 2021.
+
+[23] Yang Song and Stefano Ermon. Generative modeling by estimating gradients of the data distribution. In Advances in Neural Information Processing Systems, 2019.
+
+[24] Chenhao Niu, Yang Song, Jiaming Song, Shengjia Zhao, Aditya Grover, and Stefano Ermon. Permutation invariant graph generation via score-based generative modeling. In International Conference on Artificial Intelligence and Statistics, pages 4474–4484. PMLR, 2020.
+
+[25] Kashif Rasul, Calvin Seward, Ingmar Schuster, and Roland Vollgraf. Autoregressive denoising diffusion models for multivariate probabilistic time series forecasting. In International Conference on Machine Learning, 2021.
+
+[26] Jascha Sohl-Dickstein, Eric Weiss, Niru Maheswaranathan, and Surya Ganguli. Deep unsupervised learning using nonequilibrium thermodynamics. In International Conference on Machine Learning, 2015.
+
+[27] Yang Song and Stefano Ermon. Improved techniques for training score-based generative models. In Advances in Neural Information Processing Systems, 2020.
+
+[28] Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. BERT: Pre-training of deep bidirectional transformers for language understanding. In Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long and Short Papers), pages 4171–4186, 2019.
+
+[29] Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Lukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Advances in Neural Information Processing Systems, 2017.
+
+[30] Simiao Zuo, Haoming Jiang, Zichong Li, Tuo Zhao, and Hongyuan Zha. Transformer hawkes process. In International Conference on Machine Learning, 2020.
+
+[31] Edwin V Bonilla, Kian Ming A Chai, and Christopher KI Williams. Multi-task gaussian process prediction. In Advances in Neural Information Processing Systems, 2008.
+
+[32] Ahmad Wisnu Mulyadi, Eunji Jun, and Heung-Il Suk. Uncertainty-aware variational-recurrent imputation network for clinical time series. IEEE Transactions on Cybernetics, 2021. to appear.
+
+[33] James E Matheson and Robert L Winkler. Scoring rules for continuous probability distributions. Management science, 22(10):1087–1096, 1976.
+
+[34] David Salinas, Michael Bohlke-Schneider, Laurent Callot, Roberto Medico, and Jan Gasthaus. High-dimensional multivariate forecasting with low-rank gaussian copula processes. In Advances in Neural Information Processing Systems, 2019.
+
+[35] Yulia Rubanova, Ricky TQ Chen, and David Duvenaud. Latent ordinary differential equations for irregularly-sampled time series. In Advances in Neural Information Processing Systems, 2019.
+
+[36] Kashif Rasul, Abdul-Saboor Sheikh, Ingmar Schuster, Urs Bergmann, and Roland Vollgraf. Multi-variate probabilistic time series forecasting via conditioned normalizing flows. In International Conference on Learning Representations, 2021.
+
+[37] Nam Nguyen and Brian Quanz. Temporal latent auto-encoder: A method for probabilistic multivariate time series forecasting. In The Thirty-Fifth AAAI Conference on Artificial Intelligence, 2021.
+
+[38] Jiaming Song, Chenlin Meng, and Stefano Ermon. Denoising diffusion implicit models. In International Conference on Learning Representations, 2021.
+
+[39] Adam Paszke, Sam Gross, Francisco Massa, Adam Lerer, James Bradbury, Gregory Chanan, Trevor Killeen, Zeming Lin, Natalia Gimelshein, Luca Antiga, et al. Pytorch: An imperative style, high-performance deep learning library. In Advances in Neural Information Processing Systems, 2019.
+
+[40] Phil Wang. Linear attention transformer. https://github.com/lucidrains/ linear-attention-transformer, 2020.
+
+[41] Zhuoran Shen, Mingyuan Zhang, Haiyu Zhao, Shuai Yi, and Hongsheng Li. Efficient attention: Attention with linear complexities. In Proceedings of the IEEE/CVF Winter Conference on Applications of Computer Vision, pages 3531–3539, 2021.
+
+[42] Alex Nichol and Prafulla Dhariwal. Improved denoising diffusion probabilistic models. In International Conference on Machine Learning, 2021.
+
+[43] Jacob R Gardner, Geoff Pleiss, David Bindel, Kilian Q Weinberger, and Andrew Gordon Wilson. Gpytorch: Blackbox matrix-matrix gaussian process inference with gpu acceleration. In Advances in Neural Information Processing Systems, 2018.
+
+[44] Alexander Alexandrov, Konstantinos Benidis, Michael Bohlke-Schneider, Valentin Flunkert, Jan Gasthaus, Tim Januschowski, Danielle C. Maddix, Syama Rangapuram, David Salinas, Jasper Schulz, Lorenzo Stella, Ali Caner Türkmen, and Yuyang Wang. GluonTS: Probabilistic and Neural Time Series Modeling in Python. Journal of Machine Learning Research, 21(116):1–6, 2020.
+
+[45] Guokun Lai, Wei-Cheng Chang, Yiming Yang, and Hanxiao Liu. Modeling long-and short-term temporal patterns with deep neural networks. In The 41st International ACM SIGIR Conference on Research & Development in Information Retrieval, pages 95–104, 2018.
+
+# Checklist
+
+1. For all authors...
+
+(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes] We described our proposed method and empirical results in the abstract and introduction.   
+(b) Did you describe the limitations of your work? [Yes] We have mentioned some limitations of our work in Section 7.   
+(c) Did you discuss any potential negative societal impacts of your work? [Yes] Please see Appendix H.   
+(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes] We have read the guidelines and ensured that our paper conforms to them.
+
+2. If you are including theoretical results...
+
+(a) Did you state the full set of assumptions of all theoretical results? [N/A] (b) Did you include complete proofs of all theoretical results? [N/A]
+
+3. If you ran experiments...
+
+(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [Yes] Please see the abstract.   
+(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] Please see Section 6 and Appendix E.2.   
+(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [Yes] We gave error bars in figures and the standard errors in tables.   
+(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [No] We did not focus on computational time.
+
+4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets...
+
+(a) If your work uses existing assets, did you cite the creators? [Yes] We cited packages we used. We also cited papers which provided datasets.   
+(b) Did you mention the license of the assets? [No] We only used open dataset. Please refer to citations for details on licensing.   
+(c) Did you include any new assets either in the supplemental material or as a URL? [No] We did not release new assets.   
+(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [No] We only used open dataset.   
+(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [No] The datasets we used are open numerical time series dataset and do not contain personally identifiable information.
+
+5. If you used crowdsourcing or conducted research with human subjects...
+
+(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   
+(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   
+(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A]

parse/train/VzuIzbRDrum/VzuIzbRDrum_content_list.json

@@ -0,0 +1,1651 @@
+[
+    {
+        "type": "text",
+        "text": "CSDI: Conditional Score-based Diffusion Models for Probabilistic Time Series Imputation ",
+        "text_level": 1,
+        "bbox": [
+            181,
+            122,
+            818,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Yusuke Tashiro123\\*, Jiaming $\\mathbf { S o n g ^ { 1 } }$ , Yang $\\mathbf { S o n g ^ { 1 } }$ , Stefano Ermon1 ",
+        "bbox": [
+            269,
+            224,
+            725,
+            241
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1Department of Computer Science, Stanford University, Stanford, CA, USA 2Mitsubishi UFJ Trust Investment Technology Institute, Tokyo, Japan 3Japan Digital Design, Tokyo, Japan {ytashiro,tsong,songyang,ermon}@cs.stanford.edu ",
+        "bbox": [
+            254,
+            242,
+            745,
+            299
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            333,
+            535,
+            351
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The imputation of missing values in time series has many applications in healthcare and finance. While autoregressive models are natural candidates for time series imputation, score-based diffusion models have recently outperformed existing counterparts including autoregressive models in many tasks such as image generation and audio synthesis, and would be promising for time series imputation. In this paper, we propose Conditional Score-based Diffusion models for Imputation (CSDI), a novel time series imputation method that utilizes score-based diffusion models conditioned on observed data. Unlike existing score-based approaches, the conditional diffusion model is explicitly trained for imputation and can exploit correlations between observed values. On healthcare and environmental data, CSDI improves by $40 \\%$ over existing probabilistic imputation methods on popular performance metrics. In addition, deterministic imputation by CSDI reduces the error by $5 . 2 0 \\%$ compared to the state-of-the-art deterministic imputation methods. Furthermore, CSDI can also be applied to time series interpolation and probabilistic forecasting, and is competitive with existing baselines. The code is available at https://github.com/ermongroup/CSDI. ",
+        "bbox": [
+            233,
+            364,
+            766,
+            585
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            608,
+            310,
+            626
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Multivariate time series are abundant in real world applications such as finance, meteorology and healthcare. These time series data often contain missing values due to various reasons, including device failures and human errors [1, 2, 3]. Since missing values can hamper the interpretation of a time series, many studies have addressed the task of imputing missing values using machine learning techniques [4, 5, 6]. In the past few years, imputation methods based on deep neural networks have shown great success for both deterministic imputation [7, 8, 9] and probabilistic imputation [10]. These imputation methods typically utilize autoregressive models to deal with time series. ",
+        "bbox": [
+            174,
+            640,
+            825,
+            737
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Score-based diffusion models – a class of deep generative models and generate samples by gradually converting noise into a plausible data sample through denoising – have recently achieved state-ofthe-art sample quality in many tasks such as image generation [11, 12] and audio synthesis [13, 14], outperforming counterparts including autoregressive models. Diffusion models can also be used to impute missing values by approximating the scores of the posterior distribution obtained from the prior by conditioning on the observed values [12, 15, 16]. While these approximations may work well in practice, they do not correspond to the exact conditional distribution. ",
+        "bbox": [
+            174,
+            743,
+            825,
+            840
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we propose CSDI, a novel probabilistic imputation method that directly learns the conditional distribution with conditional score-based diffusion models. Unlike existing score-based approaches, the conditional diffusion model is designed for imputation and can exploit useful information in observed values. We illustrate the procedure of time series imputation with CSDI in ",
+        "bbox": [
+            174,
+            847,
+            823,
+            902
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/bbb84b188cfff95d08bdbe5640c15f0c108368c3767bf881aac104206ab4357c.jpg",
+        "image_caption": [
+            "Figure 1: The procedure of time series imputation with CSDI. The reverse process $p _ { \\theta }$ gradually converts random noise into plausible time series, conditioned on observed values $\\mathbf { x } _ { 0 } ^ { \\mathrm { { c o } } }$ . Dashed lines in each box represent observed values, which are plotted in order to show the relationship with generated imputation and not included in each ${ \\bf x } _ { t } ^ { \\mathrm { t a } }$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            218,
+            98,
+            789,
+            233
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Figure 1. We start imputation from random noise on the left of the figure and gradually convert the noise into plausible time series through the reverse process $p _ { \\theta }$ of the conditional diffusion model. At each step $t$ , the reverse process removes noise from the output of the previous step $( t + 1 )$ . Unlike existing score-based diffusion models, the reverse process can take observations (on the top left of the figure) as a conditional input, allowing the model to exploit information in the observations for denoising. We utilize an attention mechanism to capture the temporal and feature dependencies of time series. ",
+        "bbox": [
+            173,
+            334,
+            825,
+            431
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "For training the conditional diffusion model, we need observed values (i.e., conditional information) and ground-truth missing values (i.e., imputation targets). However, in practice we do not know the ground-truth missing values, or training data may not contain missing values at all. Then, inspired by masked language modeling, we develop a self-supervised training method that separates observed values into conditional information and imputation targets. We note that CSDI is formulated for general imputation tasks, and is not restricted to time series imputation. ",
+        "bbox": [
+            174,
+            438,
+            825,
+            521
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our main contributions are as follows: ",
+        "bbox": [
+            176,
+            527,
+            426,
+            541
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• We propose conditional score-based diffusion models for probabilistic imputation (CSDI), and implement CSDI for time series imputation. To train the conditional diffusion model, we develop a self-supervised training method. • We empirically show that CSDI improves the continuous ranked probability score (CRPS) by $40 \\%$ over existing probabilistic methods on healthcare and environmental data. Moreover, deterministic imputation with CSDI decreases the mean absolute error (MAE) by $5 - 2 0 \\%$ compared to the state-of-the-art methods developed for deterministic imputation. • We demonstrate that CSDI can also be applied to time series interpolations and probabilistic forecasting, and is competitive with existing baselines designed for these tasks. ",
+        "bbox": [
+            217,
+            554,
+            825,
+            690
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Related works ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            710,
+            325,
+            727
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Time series imputations with deep learning Previous studies have shown deep learning models can capture the temporal dependency of time series and give more accurate imputation than statistical methods. A popular approach using deep learning is to use RNNs, including LSTMs and GRUs, for sequence modeling [17, 8, 7]. Subsequent studies combined RNNs with other methods to improve imputation performance, such as GANs [9, 18, 19] and self-training [20]. Among them, the combination of RNNs with attention mechanisms is particularly successful for imputation and interpolation of time series [21, 22]. While these methods focused on deterministic imputation, GP-VAE [10] has been recently developed as a probabilistic imputation method. ",
+        "bbox": [
+            174,
+            742,
+            825,
+            853
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Score-based generative models Score-based generative models, including score matching with Langevin dynamics [23] and denoising diffusion probabilistic models [11], have outperformed existing methods with other deep generative models in many domains, such as images [23, 11], audio [13, 14], and graphs [24]. Most recently, TimeGrad [25] utilized diffusion probabilistic models for probabilistic time series forecasting. While the method has shown state-of-the-art performance, it cannot be applied to time series imputation due to the use of RNNs to handle past time series. ",
+        "bbox": [
+            174,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            90,
+            825,
+            133
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 Background ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            151,
+            308,
+            169
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 Multivariate time series imputation ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            181,
+            459,
+            196
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We consider $N$ multivariate time series with missing values. Let us denote the values of each time series as $\\mathbf { X } = \\{ x _ { 1 : K , 1 : L } \\} \\in \\mathbb { R } ^ { K \\times L }$ where $K$ is the number of features and $L$ is the length of time series. While the length $L$ can be different for each time series, we treat the length of all time series as the same for simplicity, unless otherwise stated. We also denote an observation mask as $\\mathbf { M } = \\{ m _ { 1 : K , 1 : L } \\} \\in \\{ 0 , 1 \\} ^ { \\bar { K } \\times L }$ where $m _ { k , l } = 0$ if $x _ { k , l }$ is missing, and $m _ { k , l } = 1$ if $x _ { k , l }$ is observed. We assume time intervals between two consecutive data entries can be different, and define the timestamps of the time series as $\\mathbf { s } = \\{ s _ { 1 : L } \\} \\in \\mathbb { R } ^ { L }$ . In summary, each time series is expressed as $\\{ \\mathbf { X } , \\mathbf { M } , \\mathbf { s } \\bar  \\}$ . ",
+        "bbox": [
+            173,
+            207,
+            825,
+            320
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Probabilistic time series imputation is the task of estimating the distribution of the missing values of $\\mathbf { X }$ by exploiting the observed values of $\\mathbf { X }$ . We note that this definition of imputation includes other related tasks, such as interpolation, which imputes all features at target time points, and forecasting, which imputes all features at future time points. ",
+        "bbox": [
+            173,
+            324,
+            825,
+            381
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2 Denoising diffusion probabilistic models ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            396,
+            493,
+            411
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Let us consider learning a model distribution $p _ { \\theta } ( \\mathbf { x } _ { 0 } )$ that approximates a data distribution $q ( \\mathbf { x } _ { 0 } )$ . Let $\\mathbf { x } _ { t }$ for $t = 1 , \\dots , T$ be a sequence of latent variables in the same sample space as $\\mathbf { x } _ { \\mathrm { 0 } }$ , which is denoted as $\\mathcal { X }$ . Diffusion probabilistic models [26] are latent variable models that are composed of two processes: the forward process and the reverse process. The forward process is defined by the following Markov chain: ",
+        "bbox": [
+            174,
+            420,
+            826,
+            491
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ec1abdaa054c77ee38f849853c8782ba57ae0ab9403c81749dd06b42bb3b9df0.jpg",
+        "text": "$$\nq ( \\mathbf { x } _ { 1 : T } \\mid \\mathbf { x } _ { 0 } ) : = \\prod _ { t = 1 } ^ { T } q ( \\mathbf { x } _ { t } \\mid \\mathbf { x } _ { t - 1 } ) { \\mathrm { ~ w h e r e ~ } } q ( \\mathbf { x } _ { t } \\mid \\mathbf { x } _ { t - 1 } ) : = { \\mathcal { N } } \\left( { \\sqrt { 1 - { \\beta _ { t } } } } \\mathbf { x } _ { t - 1 } , { \\beta _ { t } } \\mathbf { I } \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            232,
+            494,
+            764,
+            537
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "and $\\beta _ { t }$ is a small positive constant that represents a noise level. Sampling of $\\mathbf { x } _ { t }$ has the closed-form written as $q ( \\mathbf { x } _ { t } \\mid \\mathbf { x } _ { 0 } ) = \\mathcal { N } ( \\mathbf { x } _ { t } ; \\sqrt { \\alpha _ { t } } \\mathbf { x } _ { 0 } , ( 1 - \\alpha _ { t } ) \\mathbf { I } )$ where $\\hat { \\alpha } _ { t } : = 1 - \\beta _ { t }$ and $\\textstyle \\alpha _ { t } : = \\prod _ { i = 1 } ^ { t } { \\hat { \\alpha } } _ { i }$ . Then, $\\mathbf { x } _ { t }$ can be expressed as $\\mathbf { x } _ { t } = \\sqrt { \\alpha _ { t } } \\mathbf { x } _ { 0 } + ( 1 - \\alpha _ { t } ) \\boldsymbol { \\epsilon }$ where $\\mathbf { \\epsilon } \\gets \\mathcal { N } ( \\mathbf { 0 } , \\mathbf { I } )$ . On the other hand, the reverse process denoises $\\mathbf { x } _ { t }$ to recover $\\mathbf { x } _ { \\mathrm { 0 } }$ , and is defined by the following Markov chain: ",
+        "bbox": [
+            174,
+            540,
+            825,
+            598
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f7c8e60d037e27d0f613ea097edae89d278df2ac717a99cd7b377530f28e42d7.jpg",
+        "text": "$$\n\\begin{array} { r l } & { p _ { \\theta } ( \\mathbf { x } _ { 0 : T } ) : = p ( \\mathbf { x } _ { T } ) \\displaystyle \\prod _ { t = 1 } ^ { T } p _ { \\theta } ( \\mathbf { x } _ { t - 1 } \\mid \\mathbf { x } _ { t } ) , \\quad \\mathbf { x } _ { T } \\sim \\mathcal { N } ( \\mathbf { 0 } , \\mathbf { I } ) , } \\\\ & { p _ { \\theta } ( \\mathbf { x } _ { t - 1 } \\mid \\mathbf { x } _ { t } ) : = \\mathcal { N } ( \\mathbf { x } _ { t - 1 } ; \\pmb { \\mu } _ { \\theta } ( \\mathbf { x } _ { t } , t ) , \\sigma _ { \\theta } ( \\mathbf { x } _ { t } , t ) \\mathbf { I } ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            313,
+            601,
+            684,
+            662
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Ho et al. [11] has recently proposed denoising diffusion probabilistic models (DDPM), which considers the following specific parameterization of $p _ { \\theta } ( \\mathbf { x } _ { t - 1 } \\mathbf { \\bar { \\rho } } \\vert \\mathbf { x } _ { t } )$ : ",
+        "bbox": [
+            171,
+            665,
+            821,
+            694
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c5653a09084466c4f7462b8095b624ba72ea964929cade6213d7567478eedff1.jpg",
+        "text": "$$\n\\mu _ { \\theta } ( \\mathbf { x } _ { t } , t ) = \\frac { 1 } { \\alpha _ { t } } \\left( \\mathbf { x } _ { t } - \\frac { \\beta _ { t } } { \\sqrt { 1 - \\alpha _ { t } } } \\epsilon _ { \\theta } ( \\mathbf { x } _ { t } , t ) \\right) , \\ \\sigma _ { \\theta } ( \\mathbf { x } _ { t } , t ) = \\tilde { \\beta } _ { t } ^ { 1 / 2 } \\ \\mathrm { w h e r e } \\ \\tilde { \\beta } _ { t } = \\left\\{ \\begin{array} { l l } { \\frac { 1 - \\alpha _ { t - 1 } } { 1 - \\alpha _ { t } } \\beta _ { t } } & { t > 1 } \\\\ { \\beta _ { 1 } } & { t = 1 } \\end{array} \\right.\n$$",
+        "text_format": "latex",
+        "bbox": [
+            184,
+            698,
+            812,
+            739
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\epsilon _ { \\theta }$ is a trainable denoising function. We denote $\\mu _ { \\theta } ( \\mathbf { x } _ { t } , t )$ and $\\sigma _ { \\theta } ( \\mathbf { x } _ { t } , t )$ in Eq. (3) as $\\mu ^ { \\mathrm { D D P M } } ( \\mathbf { x } _ { t } , t , \\epsilon _ { \\theta } ( \\mathbf { x } _ { t } , t ) )$ and $\\sigma ^ { \\mathrm { D D P M } } ( \\mathbf { x } _ { t } , t )$ , respectively. The denoising function in Eq. (3) also corresponds to a rescaled score model for score-based generative models [23]. Under this parameterization, Ho et al. [11] have shown that the reverse process can be trained by solving the following optimization problem: ",
+        "bbox": [
+            173,
+            756,
+            826,
+            827
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fe6c1ff26adbe4cf08b4f7c8f6e33db7b84fc7c154695f430e595b5195e3127b.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { \\theta } \\mathcal { L } ( \\theta ) : = \\operatorname* { m i n } _ { \\theta } \\mathbb { E } _ { \\mathbf { x } _ { 0 } \\sim q ( \\mathbf { x } _ { 0 } ) , \\epsilon \\sim \\mathcal { N } ( \\mathbf { 0 } , \\mathbf { I } ) , t } | | \\epsilon - \\epsilon _ { \\theta } ( \\mathbf { x } _ { t } , t ) | | _ { 2 } ^ { 2 } \\quad \\mathrm { w h e r e } \\ \\mathbf { x } _ { t } = \\sqrt { \\alpha _ { t } } \\mathbf { x } _ { 0 } + ( 1 - \\alpha _ { t } ) \\epsilon .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            189,
+            828,
+            789,
+            852
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The denoising function $\\epsilon _ { \\theta }$ estimates the noise vector $\\epsilon$ that was added to its noisy input $\\mathbf { x } _ { t }$ . This training objective also be viewed as a weighted combination of denoising score matching used for training score-based generative models [23, 27, 12]. Once trained, we can sample $\\mathbf { x } _ { \\mathrm { 0 } }$ from Eq. (2). We provide the details of DDPM in Appendix A. ",
+        "bbox": [
+            174,
+            854,
+            825,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.3 Imputation with diffusion models ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            90,
+            444,
+            106
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Here, we focus on general imputation tasks that are not restricted to time series imputation. Let us consider the following imputation problem: given a sample $\\mathbf { x } _ { \\mathrm { 0 } }$ which contains missing values, we generate imputation targets $\\mathbf { x } _ { 0 } ^ { \\mathrm { { t a } } } \\in \\mathcal { X } ^ { \\mathrm { { t a } } }$ by exploiting conditional observations $\\mathbf { x } _ { 0 } ^ { \\mathrm { { c o } } } \\in \\mathcal { X } ^ { \\mathrm { { c o } } }$ , where $\\bar { \\mathcal X } ^ { \\mathrm { t a } }$ and $\\mathcal { X } ^ { \\mathrm { c o } }$ are a part of the sample space $\\mathcal { X }$ and vary per sample. Then, the goal of probabilistic imputation is to estimate the true conditional data distribution $q ( \\mathbf { \\bar { x } } _ { 0 } ^ { \\mathrm { t a } } \\mid \\mathbf { x } _ { 0 } ^ { \\mathrm { c o } } )$ with a model distribution $p _ { \\theta } ( \\mathbf { x } _ { 0 } ^ { \\mathrm { { t a } } } \\mid \\mathbf { x } _ { 0 } ^ { \\mathrm { { c o } } } )$ . We typically impute all missing values using all observed values, and set all observed values as $\\mathbf { x } _ { 0 } ^ { \\mathrm { { c o } } }$ and all missing values as $\\mathbf { x } _ { 0 } ^ { \\mathrm { { t a } } }$ , respectively. Note that time series imputation in Section 3.1 can be considered as a special case of this task. ",
+        "bbox": [
+            173,
+            116,
+            825,
+            228
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Let us consider modeling $p _ { \\theta } ( \\mathbf { x } _ { 0 } ^ { \\mathrm { { t a } } } \\mid \\mathbf { x } _ { 0 } ^ { \\mathrm { { c o } } } )$ with a diffusion model. In the unconditional case, the reverse process $p _ { \\theta } ( \\mathbf { x } _ { 0 : T } )$ is used to define the final data model $p _ { \\theta } ( \\mathbf { x } _ { 0 } )$ . Then, a natural approach is to extend the reverse process in Eq. (2) to a conditional one: ",
+        "bbox": [
+            174,
+            233,
+            825,
+            276
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/cb9fe1a6250c2fa132c4b9c90538a315c2b11fb1ae96662c26c510e0126b2bd4.jpg",
+        "text": "$$\n\\begin{array} { r l } & { p _ { \\theta } ( \\mathbf { x } _ { 0 : T } ^ { \\mathrm { t a } } \\mid \\mathbf { x } _ { 0 } ^ { \\mathrm { c o } } ) : = p ( \\mathbf { x } _ { T } ^ { \\mathrm { t a } } ) \\displaystyle \\prod _ { t = 1 } ^ { T } p _ { \\theta } ( \\mathbf { x } _ { t - 1 } ^ { \\mathrm { t a } } \\mid \\mathbf { x } _ { t } ^ { \\mathrm { t a } } , \\mathbf { x } _ { 0 } ^ { \\mathrm { c o } } ) , \\quad \\mathbf { x } _ { T } ^ { \\mathrm { t a } } \\sim \\mathcal { N } ( \\mathbf { 0 } , \\mathbf { I } ) , } \\\\ & { p _ { \\theta } ( \\mathbf { x } _ { t - 1 } ^ { \\mathrm { t a } } \\mid \\mathbf { x } _ { t } ^ { \\mathrm { t a } } , \\mathbf { x } _ { 0 } ^ { \\mathrm { c o } } ) : = \\mathcal { N } ( \\mathbf { x } _ { t - 1 } ^ { \\mathrm { t a } } ; \\mu _ { \\theta } ( \\mathbf { x } _ { t } ^ { \\mathrm { t a } } , t \\mid \\mathbf { x } _ { 0 } ^ { \\mathrm { c o } } ) , \\sigma _ { \\theta } ( \\mathbf { x } _ { t } ^ { \\mathrm { t a } } , t \\mid \\mathbf { x } _ { 0 } ^ { \\mathrm { c o } } ) \\mathbf { I } ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            274,
+            281,
+            722,
+            347
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "However, existing diffusion models are generally designed for data generation and do not take conditional observations $\\mathbf { x } _ { 0 } ^ { \\mathrm { { c o } } }$ as inputs. To utilize diffusion models for imputation, previous studies [12, 15, 16] approximated the conditional reverse process $p _ { \\theta } ( \\mathbf { x } _ { t - 1 } ^ { \\mathrm { { t a } } } \\mid \\mathbf { x } _ { t } ^ { \\mathrm { { t a } } } , \\mathbf { x } _ { 0 } ^ { \\mathrm { { c o } } } )$ with the reverse process in Eq. (2). With this approximation, in the reverse process they add noise to both the target and the conditional observations $\\mathbf { x } _ { 0 } ^ { \\mathrm { { c o } } }$ . While this approach can impute missing values, the added noise can harm useful information in the observations. This suggests that modeling $p _ { \\theta } ( \\mathbf { x } _ { t - 1 } ^ { \\mathrm { { t a } } } \\mid \\mathbf { x } _ { t } ^ { \\mathrm { { t a } } } , \\mathbf { x } _ { 0 } ^ { \\mathrm { { c o } } } )$ without approximations can improve the imputation quality. Hereafter, we call the model defined in Section 3.2 as the unconditional diffusion model. ",
+        "bbox": [
+            173,
+            349,
+            826,
+            462
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 Conditional score-based diffusion model for imputation (CSDI) ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            479,
+            732,
+            498
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In this section, we propose CSDI, a novel imputation method based on a conditional score-based diffusion model. The conditional diffusion model allows us to exploit useful information in observed values for accurate imputation. We provide the reverse process of the conditional diffusion model, and then develop a self-supervised training method. We note that CSDI is not restricted to time series. ",
+        "bbox": [
+            173,
+            511,
+            826,
+            568
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.1 Imputation with CSDI ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            583,
+            370,
+            598
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We focus on the conditional diffusion model with the reverse process in Eq. (5) and aim to model the conditional distribution $p ( \\mathbf { x } _ { t - 1 } ^ { \\mathrm { t a } } \\mid \\mathbf { x } _ { t } ^ { \\mathrm { t a } } , \\mathbf { x } _ { 0 } ^ { \\mathrm { c o } } )$ without approximations. Specifically, we extend the parameterization of DDPM in Eq. (3) to the conditional case. We define a conditional denoising function $\\epsilon _ { \\theta } : ( \\mathcal { X } ^ { \\mathrm { t a } } \\times \\mathbb { R } \\mid \\mathcal { X } ^ { \\mathrm { c o } } )  \\mathcal { X } ^ { \\mathrm { t a } }$ , which takes conditional observations $\\mathbf { x } _ { 0 } ^ { \\mathrm { { c o } } }$ as inputs. Then, we consider the following parameterization with $\\epsilon _ { \\theta }$ : ",
+        "bbox": [
+            173,
+            608,
+            825,
+            679
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ead384821978246c7c52082c432d3466ad3a95b72d6c445402bda8731e5db088.jpg",
+        "text": "$$\n\\mu _ { \\boldsymbol { \\theta } } ( \\mathbf { x } _ { t } ^ { \\mathrm { t a } } , t \\mid \\mathbf { x } _ { 0 } ^ { \\mathrm { c o } } ) = \\mu ^ { \\mathrm { D D P M } } ( \\mathbf { x } _ { t } ^ { \\mathrm { t a } } , t , \\epsilon _ { \\boldsymbol { \\theta } } ( \\mathbf { x } _ { t } ^ { \\mathrm { t a } } , t \\mid \\mathbf { x } _ { 0 } ^ { \\mathrm { c o } } ) ) , \\quad \\sigma _ { \\boldsymbol { \\theta } } ( \\mathbf { x } _ { t } ^ { \\mathrm { t a } } , t \\mid \\mathbf { x } _ { 0 } ^ { \\mathrm { c o } } ) = \\sigma ^ { \\mathrm { D D P M } } ( \\mathbf { x } _ { t } ^ { \\mathrm { t a } } , t )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            214,
+            684,
+            784,
+            703
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\mu ^ { \\mathrm { D D P M } }$ and $\\sigma ^ { \\mathrm { D D P M } }$ are the functions defined in Section 3.2. Given the function $\\epsilon _ { \\theta }$ and data $\\mathbf { x } _ { \\mathrm { 0 } }$ , we can sample $\\mathbf { x } _ { 0 } ^ { \\mathrm { t a } }$ using the reverse process in Eq. (5) and Eq. (6). For the sampling, we set all observed values of $\\mathbf { x } _ { \\mathrm { 0 } }$ as conditional observations $\\mathbf { x } _ { 0 } ^ { \\mathrm { { c o } } }$ and all missing values as imputation targets $\\mathbf { x } _ { 0 } ^ { \\mathrm { { t a } } }$ Note that the conditional model is reduced to the unconditional one under no conditional observations and can also be used for data generation. ",
+        "bbox": [
+            173,
+            709,
+            825,
+            780
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.2 Training of CSDI ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            796,
+            334,
+            811
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Since Eq. (6) uses the same parameterization as Eq. (3) and the difference between Eq. (3) and Eq. (6) is only the form of $\\epsilon _ { \\theta }$ , we can follow the training procedure for the unconditional model in Section 3.2. Namely, given conditional observations √ $\\mathbf { x } _ { 0 } ^ { \\mathrm { { c o } } }$ and imputation targets $\\mathbf { x } _ { 0 } ^ { \\mathrm { t a } }$ , we sample noisy targets $\\mathbf { x } _ { t } ^ { \\mathrm { { t a } } } = \\sqrt { \\alpha _ { t } } \\bar { \\mathbf { x } } _ { 0 } ^ { \\mathrm { { t a } } } + ( 1 - \\alpha _ { t } ) \\epsilon$ , and train $\\epsilon _ { \\theta }$ by minimizing the following loss function: ",
+        "bbox": [
+            174,
+            820,
+            825,
+            878
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/665eb49215383dd87b5b48dc5499fc76d76caa271cb7749717c9ca857038e1ae.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { \\theta } \\mathcal { L } ( \\theta ) : = \\operatorname* { m i n } _ { \\theta } \\mathbb { E } _ { \\mathbf { x } _ { 0 } \\sim q ( \\mathbf { x } _ { 0 } ) , \\epsilon \\sim \\mathcal { N } ( \\mathbf { 0 } , \\mathbf { I } ) , t } | | ( \\epsilon - \\epsilon _ { \\theta } ( \\mathbf { x } _ { t } ^ { \\mathrm { t a } } , t \\mid \\mathbf { x } _ { 0 } ^ { \\mathrm { c o } } ) ) | | _ { 2 } ^ { 2 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            285,
+            886,
+            710,
+            909
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/4d4be6e3883b120cb84f7b40b0f097416121248d7d4d14c7bb15628ef851b269.jpg",
+        "image_caption": [
+            "Figure 2: The self-supervised training procedure of CSDI. On the middle left rectangle, the green and white areas represent observed and missing values, respectively. The observed values are separated into red imputation targets $\\mathbf { x } _ { 0 } ^ { \\mathrm { t a } }$ and blue conditional observations $\\mathbf { x } _ { 0 } ^ { \\mathrm { { c o } } }$ , and used for training of $\\epsilon _ { \\theta }$ . The colored areas in each rectangle mean the existence of values. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            238,
+            92,
+            750,
+            262
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/6e90d17e73ce9397a3265e11f6669cf80d63d1497b76b60d53afa7ebdd09f766.jpg",
+        "table_caption": [
+            "Table 1: Imputation targets $\\mathbf { x } _ { 0 } ^ { \\mathrm { t a } }$ and conditional observations $\\mathbf { x } _ { 0 } ^ { \\mathrm { { c o } } }$ for CSDI at training and sampling. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td> imputation targets xta</td><td>conditional observations xco</td></tr><tr><td>sampling (imputation)</td><td>all missing values</td><td>all observed values</td></tr><tr><td>training</td><td>a subset of the observed values (sampled by a target choice strategy)</td><td>the remaining observed values</td></tr></table>",
+        "bbox": [
+            178,
+            388,
+            820,
+            469
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where the dimension of $\\epsilon$ corresponds to that of the imputation targets $\\mathbf { x } _ { 0 } ^ { \\mathrm { { t a } } }$ ",
+        "bbox": [
+            176,
+            512,
+            661,
+            526
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "However, this training procedure has an issue. Since we do not know the ground-truth missing values in practice, it is not clear how to select $\\mathbf { x } _ { 0 } ^ { \\mathrm { { c o } } }$ and $\\mathbf { x } _ { 0 } ^ { \\mathrm { t a } }$ from a training sample $\\mathbf { x } _ { \\mathrm { 0 } }$ . To address this issue, we develop a self-supervised learning method inspired by masked language modeling [28]. We illustrate the training procedure in Figure 2. Given a sample $\\mathbf { x } _ { \\mathrm { 0 } }$ , we separate observed values of $\\mathbf { x } _ { \\mathrm { 0 } }$ into two parts, and set one of them as imputation targets $\\mathbf { x } _ { 0 } ^ { \\mathrm { t a } }$ and the other as conditional observations $\\mathbf { x } _ { 0 } ^ { \\mathrm { { c o } } }$ . We choose the targets $\\mathbf { x } _ { 0 } ^ { \\mathrm { { t a } } }$ through a target choice strategy, which is discussed in Section 4.3. Then, we sample noisy targets ${ \\bf x } _ { t } ^ { \\mathrm { t a } }$ and train $\\epsilon _ { \\theta }$ by solving Eq. (7). We summarize how we set $\\mathbf { x } _ { 0 } ^ { \\mathrm { { c o } } }$ and $\\mathbf { x } _ { 0 } ^ { \\mathrm { { t a } } }$ for training and sampling in Table 1. We also provide the algorithm of training and sampling in Appendix B.1. ",
+        "bbox": [
+            173,
+            532,
+            825,
+            657
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.3 Choice of imputation targets in self-supervised learning ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            686,
+            598,
+            702
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In the proposed self-supervised learning, the choice of imputation targets is important. We provide four target choice strategies depending on what is known about the missing patterns in the test dataset. We describe the algorithm for these strategies in Appendix B.2. ",
+        "bbox": [
+            176,
+            717,
+            823,
+            760
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "(1) Random strategy : this strategy is used when we do not know about missing patterns, and randomly chooses a certain percentage of observed values as imputation targets. The percentage is sampled from $[ 0 \\% , 1 0 0 \\% ]$ to adapt to various missing ratios in the test dataset. ",
+        "bbox": [
+            173,
+            766,
+            821,
+            808
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "(2) Historical strategy: this strategy exploits missing patterns in the training dataset. Given a training sample $\\mathbf { x } _ { \\mathrm { 0 } }$ , we randomly draw another sample $\\tilde { \\mathbf { x } } _ { 0 }$ from the training dataset. Then, we set the intersection of the observed indices of $\\mathbf { x } _ { \\mathrm { 0 } }$ and the missing indices of $\\tilde { \\mathbf { x } } _ { 0 }$ as imputation targets. The motivation of this strategy comes from structured missing patterns in the real world. For example, missing values often appear consecutively in time series data. When missing patterns in the training and test dataset are highly correlated, this strategy helps the model learn a good conditional distribution. ",
+        "bbox": [
+            174,
+            814,
+            825,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "(3) Mix strategy: this strategy is the mix of the above two strategies. The historical strategy may lead to overfitting to missing patterns in the training dataset. The Mix strategy can benefit from generalization by the random strategy and structured missing patterns by the historical strategy. ",
+        "bbox": [
+            171,
+            90,
+            825,
+            133
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "(4) Test pattern strategy: when we know the missing patterns in the test dataset, we just set the patterns as imputation targets. For example, this strategy is used for time series forecasting, since the missing patterns in the test dataset are fixed to given future time points. ",
+        "bbox": [
+            173,
+            140,
+            823,
+            181
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 Implementation of CSDI for time series imputation ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            204,
+            632,
+            222
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/4ffe055c5adebee89536c944dfe02db241c2cf7a2e7459a190e50b95a8c73a5c.jpg",
+        "image_caption": [
+            "Figure 3: The architecture of 2D attention. Given a tensor with $K$ features, $L$ length, and $C$ channels, the temporal Transformer layer takes tensors with $( 1 , L , C )$ shape as inputs and learns temporal dependency. The feature Transformer layer takes tensors with $( K , 1 , C )$ shape as inputs and learns feature dependency. The output shape of each layer is the same as the input shape. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            191,
+            246,
+            808,
+            321
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In this section, we implement CSDI for time series imputation. For the implementation, we need the inputs and the architecture of $\\epsilon _ { \\theta }$ . ",
+        "bbox": [
+            174,
+            410,
+            821,
+            438
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "First, we describe how we process time series data as inputs for CSDI. As defined in Section 3.1, a time series is denoted as $\\{ \\mathbf { X } , \\mathbf { M } , \\mathbf { s } \\}$ , and the sample space $\\mathcal { X }$ of $\\mathbf { X }$ is $\\mathbb { R } ^ { K \\times L }$ . We want to handle X in the sample space $\\mathbb { R } ^ { K \\times L }$ for learning dependencies in a time series using a neural network, but the conditional denoising function $\\epsilon _ { \\theta }$ takes inputs ${ \\bf x } _ { t } ^ { \\mathrm { t a } }$ and $\\mathbf { x } _ { 0 } ^ { \\mathrm { { c o } } }$ in varying sample spaces that are a part of $\\mathcal { X }$ as shown in white areas of ${ \\bf x } _ { t } ^ { \\mathrm { t a } }$ and $\\mathbf { x } _ { 0 } ^ { \\mathrm { { c o } } }$ in Figure 2. To address this issue, we adjust the conditional denoising function $\\epsilon _ { \\theta }$ to inputs in the fixed sample space $\\mathbb { R } ^ { K \\times L }$ . Concretely, we fix the shape of the inputs ${ \\bf x } _ { t } ^ { \\mathrm { t a } }$ and $\\mathbf { x } _ { 0 } ^ { \\mathrm { { c o } } }$ to $( K \\times L )$ by applying zero padding to ${ \\bf x } _ { t } ^ { \\mathrm { t a } }$ and $\\mathbf { x } _ { 0 } ^ { \\mathrm { { c o } } }$ . In other words, we set zero values to white areas for ${ \\bf x } _ { t } ^ { \\mathrm { t a } }$ and ${ \\bf x } _ { 0 } ^ { \\mathrm { c o } }$ in Figure 2. To indicate which indices are padded, we introduce the conditional mask $\\mathbf { m } ^ { \\mathrm { c o } } \\in \\{ 0 , 1 \\} ^ { K \\times L }$ as an additional input to $\\epsilon _ { \\theta }$ , which corresponds to $\\mathbf { x } _ { 0 } ^ { \\mathrm { { c o } } }$ and takes value 1 for indices of conditional observations. For ease of handling, we also fix the output shape in the sample space $\\mathbb { R } ^ { K \\times L }$ by applying zero padding. Then, the conditional denoising function $\\epsilon _ { \\theta } ( \\mathbf { x } _ { t } ^ { \\mathrm { { t a } } } , t \\mid \\mathbf { x } _ { 0 } ^ { \\mathrm { { c o } } } , \\mathbf { m } ^ { \\mathrm { { c o } } } )$ can be written as $\\begin{array} { r } { \\overline { { \\epsilon } } _ { \\theta } : ( \\mathbb { R } ^ { K \\times L } \\times \\mathbb { R } ^ { \\overline { { } } } \\mid \\mathbb { R } ^ { K \\times L } \\times \\{ 0 , 1 \\} ^ { K \\times L } )  \\mathbb { R } ^ { K \\times \\tilde { L } } } \\end{array}$ . We discuss the effect of this adjustment on training and sampling in Appendix D. ",
+        "bbox": [
+            173,
+            444,
+            826,
+            625
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Under the adjustment, we set conditional observations $\\mathbf { x } _ { 0 } ^ { \\mathrm { { c o } } }$ and imputation targets $\\mathbf { x } _ { 0 } ^ { \\mathrm { t a } }$ for time series imputation by following Table 1. At sampling time, since conditional observations $\\mathbf { x } _ { 0 } ^ { \\mathrm { { c o } } }$ are all observed values, we set $\\mathbf { m } ^ { \\mathrm { c o } } = \\mathbf { M }$ and $\\begin{array} { r } { \\mathbf { x } _ { 0 } ^ { \\mathrm { c o } } = \\mathbf { m } ^ { \\mathrm { c o } } \\odot \\mathbf { X } } \\end{array}$ where $\\odot$ represents element-wise products. For training, we sample $\\mathbf { x } _ { 0 } ^ { \\mathrm { t a } }$ and $\\mathbf { x } _ { 0 } ^ { \\mathrm { c o } }$ through a target choice strategy, and set the indices of $\\mathbf { x } _ { 0 } ^ { \\mathrm { { c o } } }$ as $\\mathbf { m } ^ { \\mathrm { c o } }$ . Then, $\\mathbf { x } _ { 0 } ^ { \\mathrm { { c o } } }$ is written as $\\mathbf { x } _ { 0 } ^ { \\mathrm { c o } } = \\mathbf { m } ^ { \\mathrm { c o } } \\odot \\mathbf { X }$ and $\\mathbf { x } _ { 0 } ^ { \\mathrm { { t a } } }$ is obtained as $\\mathbf { \\bar { x } } _ { 0 } ^ { \\mathrm { t a } } = \\left( \\mathbf { M } - \\mathbf { m } ^ { \\mathrm { c o } } \\right) \\odot \\mathbf { X }$ . ",
+        "bbox": [
+            174,
+            631,
+            825,
+            700
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Next, we describe the architecture of $\\epsilon _ { \\theta }$ . We adopt the architecture in DiffWave [13] as the base, which is composed of multiple residual layers with residual channel $C$ . We refine this architecture for time series imputation. We set the diffusion step $T = 5 0$ . We discuss the main differences from DiffWave (see Appendix E.1 for the whole architecture and details). ",
+        "bbox": [
+            174,
+            705,
+            825,
+            761
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Attention mechanism To capture temporal and feature dependencies of multivariate time series, we utilize a two dimensional attention mechanism in each residual layer instead of a convolution architecture. As shown in Figure 3, we introduce temporal Transformer layer and a feature Transformer layer, which are 1-layer Transformer encoders. The temporal Transformer layer takes tensors for each feature as inputs to learn temporal dependency, whereas the feature Transformer layer takes tensors for each time point as inputs to learn temporal dependency. ",
+        "bbox": [
+            174,
+            779,
+            825,
+            863
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Note that while the length $L$ can be different for each time series as mentioned in Section 3.1, the attention mechanism allows the model to handle various lengths. For batch training, we apply zero padding to each sequence so that the lengths of the sequences are the same. ",
+        "bbox": [
+            176,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Side information In addition to the arguments of $\\epsilon _ { \\theta }$ , we provide some side information as additional inputs to the model. First, we use time embedding of $\\mathbf { s } = \\left\\{ s _ { 1 : L } \\right\\}$ to learn the temporal dependency. Following previous studies [29, 30], we use 128-dimensions temporal embedding. Second, we exploit categorical feature embedding for $K$ features, where the dimension is 16. ",
+        "bbox": [
+            174,
+            92,
+            826,
+            147
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "6 Experimental results ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            169,
+            379,
+            186
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this section, we demonstrate the effectiveness of CSDI for time series imputation. Since CSDI can be applied to other related tasks such as interpolation and forecasting, we also evaluate CSDI for these tasks to show the flexibility of CSDI. Due to the page limitation, we provide the detailed setup for experiments including train/validation/test splits and hyperparameters in Appendix E.2. ",
+        "bbox": [
+            174,
+            202,
+            825,
+            258
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "6.1 Time series imputation ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            276,
+            372,
+            291
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Dataset and experiment settings We run experiments for two datasets. The first one is the healthcare dataset in PhysioNet Challenge 2012 [1], which consists of 4000 clinical time series with 35 variables for 48 hours from intensive care unit (ICU). Following previous studies [7, 8], we process the dataset to hourly time series with 48 time steps. The processed dataset contains around $80 \\%$ missing values. Since the dataset has no ground-truth, we randomly choose $10 / 5 0 / 9 0 \\%$ of observed values as ground-truth on the test data. ",
+        "bbox": [
+            174,
+            303,
+            825,
+            386
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The second one is the air quality dataset [2]. Following previous studies [7, 21], we use hourly sampled PM2.5 measurements from 36 stations in Beijing for 12 months and set 36 consecutive time steps as one time series. There are around $13 \\%$ missing values and the missing patterns are not random. The dataset contains artificial ground-truth, whose missing patterns are also structured. ",
+        "bbox": [
+            174,
+            393,
+            825,
+            449
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "For both dataset, we run each experiment five times. As the target choice strategy for training, we adopt the random strategy for the healthcare dataset and the mix of the random and historical strategy for the air quality dataset, based on the missing patterns of each dataset. ",
+        "bbox": [
+            176,
+            455,
+            821,
+            497
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Results of probabilistic imputation CSDI is compared with three baselines. 1) Multitask GP [31]: the method learns the covariance between timepoints and features simultaneously. 2) GP-VAE [10]: the method showed the state-of-the-art results for probabilistic imputation. 3) V-RIN [32]: a deterministic imputation method that uses the uncertainty quantified by VAE to improve imputation. For V-RIN, we regard the quantified uncertainty as probabilistic imputation. In addition, we compare CSDI with imputation using the unconditional diffusion model in order to show the effectiveness of the conditional one (see Appendix C for training and imputation with the unconditional diffusion model). ",
+        "bbox": [
+            173,
+            515,
+            825,
+            626
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We first show quantitative results. We adopt the continuous ranked probability score (CRPS) [33] as the metric, which is freuquently used for evaluating probabilistic time series forecasting and measures the compatibility of an estimated probability distribution with an observation. We generate 100 samples to approximate the probability distribution over missing values and report the normalized average of CRPS for all missing values following previous studies [34] (see Appendix E.3 for details of the computation). ",
+        "bbox": [
+            174,
+            632,
+            825,
+            715
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/519cc69f658c5ddf3911492077d8a8e62b380289ba71e699a303fa2279c82bf3.jpg",
+        "table_caption": [
+            "Table 2: Comparing CRPS for probabilistic imputation baselines and CSDI (lower is better). We report the mean and the standard error of CRPS for five trials. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\"></td><td colspan=\"3\">healthcare</td><td rowspan=\"2\"> air quality</td></tr><tr><td>10% missing</td><td>50% missing</td><td>90% missing</td></tr><tr><td>Multitask GP [31]</td><td>0.489(0.005)</td><td>0.581(0.003)</td><td>0.942(0.010)</td><td>0.301(0.003)</td></tr><tr><td>GP-VAE [10]</td><td>0.574(0.003)</td><td>0.774(0.004)</td><td>0.998(0.001)</td><td>0.397(0.009)</td></tr><tr><td>V-RIN [32]</td><td>0.808(0.008)</td><td>0.831(0.005)</td><td>0.922(0.003)</td><td>0.526(0.025)</td></tr><tr><td>unconditional</td><td>0.360(0.007)</td><td>0.458(0.008)</td><td>0.671(0.007)</td><td>0.135(0.001)</td></tr><tr><td>CSDI (proposed)</td><td>0.238(0.001)</td><td>0.330(0.002)</td><td>0.522(0.002)</td><td>0.108(0.001)</td></tr></table>",
+        "bbox": [
+            194,
+            771,
+            803,
+            892
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/69ce72ce314c6286db787f6e6e1f2d44bf21b580f69c761d60844f636f49fdf1.jpg",
+        "image_caption": [
+            "Figure 4: Examples of probabilistic time series imputation for the healthcare dataset with $50 \\%$ missing (left) and the air quality dataset (right). The red crosses show the observed values and the blue circles show the ground-truth imputation targets. For each method, median values of imputations are shown as the line and $5 \\%$ and $9 5 \\%$ quantiles are shown as the shade. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            230,
+            90,
+            764,
+            234
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 2 represents CRPS for each method. CSDI reduces CRPS by $40 \\%$ compared to the existing baselines for both datasets. This indicates that CSDI generates more realistic distributions than other methods. We also observe that the imputation with CSDI outperforms that with the unconditional model. This suggests CSDI benefits from explicitly modeling the conditional distribution. ",
+        "bbox": [
+            174,
+            338,
+            825,
+            393
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We provide imputation examples in Figure 4. For the air quality dataset, CSDI (green solid line) provides accurate imputations with high confidence, while those by GP-VAE (gray dashed line) are far from ground-truth. CSDI also gives reasonable imputations for the healthcare dataset. These results indicate that CSDI exploits temporal and feature dependencies to provide accurate imputations. We give more examples in Appendix G. ",
+        "bbox": [
+            173,
+            400,
+            825,
+            469
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/077f6c9e85ba33dd5394d2adbb8e751a761e2e261c8e585fafbc29c3940594cc.jpg",
+        "table_caption": [
+            "Table 3: Comparing MAE for deterministic imputation methods and CSDI. We report the mean and the standard error for five trials. The asterisks mean the results of the method are cited from the original paper. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\"></td><td colspan=\"3\">healthcare</td><td rowspan=\"2\"> air quality</td></tr><tr><td>10% missing</td><td>50% missing</td><td>90% missing</td></tr><tr><td>V-RIN [32]</td><td>0.271(0.001)</td><td>0.365(0.002)</td><td>0.606(0.006)</td><td>25.4(0.62)</td></tr><tr><td>BRITS[7]</td><td>0.284(0.001)</td><td>0.368(0.002)</td><td>0.517(0.002)</td><td>14.11(0.26)</td></tr><tr><td>BRITS [7] (*)</td><td>0.278</td><td></td><td></td><td>11.56</td></tr><tr><td>GLIMA [21](*)</td><td>0.265</td><td></td><td></td><td>10.54</td></tr><tr><td>RDIS [20]</td><td>0.319(0.002)</td><td>0.419(0.002)</td><td>0.631(0.002)</td><td>22.11(0.35)</td></tr><tr><td>unconditional</td><td>0.326(0.008)</td><td>0.417(0.010)</td><td>0.625(0.010)</td><td>12.13(0.07)</td></tr><tr><td>CSDI (proposed)</td><td>0.217(0.001)</td><td>0.301(0.002)</td><td>0.481(0.003)</td><td>9.60(0.04)</td></tr></table>",
+        "bbox": [
+            207,
+            549,
+            790,
+            696
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Results of deterministic imputation We demonstrate that CSDI also provides accurate deterministic imputations, which are obtained as the median of 100 generated samples. We compare CSDI with four baselines developed for deterministic imputation including GLIMA [21], which combined recurrent imputations with an attention mechanism to capture temporal and feature dependencies and showed the state-of-the-art performance. These methods are based on autoregressive models. We use the original implementations except RDIS. ",
+        "bbox": [
+            173,
+            752,
+            825,
+            835
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We evaluate each method by the mean absolute error (MAE). In Table 3, CSDI improves MAE by $5 \\%$ compared to the baselines. This suggests that the conditional diffusion model is effective to learn temporal and feature dependencies for imputation. For the healthcare dataset, the gap between the baselines and CSDI is particularly significant when the missing ratio is small, because more observed values help CSDI capture dependencies. ",
+        "bbox": [
+            174,
+            842,
+            825,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/3f311274d65ed1a4ea4b089dfcd38e234bfbb0a29698ee68053f18edde7631d6.jpg",
+        "table_caption": [
+            "Table 4: Comparing the state-of-the-art interpolation methods with CSDI for the healthcare dataset. We report the mean and the standard error of CRPS for five trials. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>10% missing</td><td>50% missing</td><td>90% missing</td></tr><tr><td>Latent ODE [35]</td><td>0.700(0.002)</td><td>0.676(0.003)</td><td>0.761(0.010)</td></tr><tr><td>mTANs [22]</td><td>0.526(0.004)</td><td>0.567(0.003)</td><td>0.689(0.015)</td></tr><tr><td>CSDI (proposed)</td><td>0.380(0.002)</td><td>0.418(0.001)</td><td>0.556(0.003)</td></tr></table>",
+        "bbox": [
+            254,
+            130,
+            741,
+            203
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6.2 Interpolation of irregularly sampled time series ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            232,
+            544,
+            247
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Dataset and experiment settings We use the same healthcare dataset as the previous section, but process the dataset as irregularly sampled time series, following previous studies [22, 35]. Since the dataset has no ground-truth, we randomly choose $10 / 5 0 / 9 0 \\%$ of time points and use observed values at these time points as ground-truth on the test data. As the target choice strategy for training, we adopt the random strategy, which is adjusted for interpolation so that some time points are sampled. ",
+        "bbox": [
+            173,
+            257,
+            825,
+            328
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Results We compare CSDI with two baselines including mTANs [22], which utilized an attention mechanism and showed state-of-the-art results for the interpolation of irregularly sampled time series. We generate 100 samples to approximate the probability distribution as with the previous section. The result is shown in Table 4. CSDI outperforms the baselines for all cases. ",
+        "bbox": [
+            173,
+            342,
+            825,
+            397
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/7c6eb55d78bba5ce9e32c86d69399b803955da222288d0c10b70179dc8c22379.jpg",
+        "table_caption": [
+            "Table 5: Comparing probabilistic forecasting methods with CSDI. We report the mean and the standard error of CRPS-sum for three trials. The baseline results are cited from the original paper. ’TransMAF’ is the abbreviation for ’Transformer MAF’. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>solar</td><td>electricity</td><td>traffic</td><td>taxi</td><td>wiki</td></tr><tr><td>GP-copula [34]</td><td>0.337(0.024)</td><td>0.024(0.002)</td><td>0.078(0.002)</td><td>0.208(0.183)</td><td>0.086(0.004)</td></tr><tr><td>TransMAF [36]</td><td>0.301(0.014)</td><td>0.021(0.000)</td><td>0.056(0.001)</td><td>0.179(0.002)</td><td>0.063(0.003)</td></tr><tr><td>TLAE [37]</td><td>0.124(0.033)</td><td>0.040(0.002)</td><td>0.069(0.001)</td><td>0.130(0.006)</td><td>0.241(0.001)</td></tr><tr><td>TimeGrad [25]</td><td>0.287(0.020)</td><td>0.021(0.001)</td><td>0.044(0.006)</td><td>0.114(0.020)</td><td>0.049(0.002)</td></tr><tr><td>CSDI (proposed)</td><td>0.298(0.004)</td><td>0.017(0.000)</td><td>0.020(0.001)</td><td>0.123(0.003)</td><td>0.047(0.003)</td></tr></table>",
+        "bbox": [
+            174,
+            463,
+            825,
+            563
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6.3 Time series Forecasting ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            592,
+            377,
+            607
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Dataset and Experiment settings We use five datasets that are commonly used for evaluating probabilistic time series forecasting. Each dataset is composed of around 100 to 2000 features. We predict all features at future time steps using past time series. We use the same prediction steps as previous studies [34, 37]. For the target choice strategy, we adopt the Test pattern strategy. ",
+        "bbox": [
+            174,
+            617,
+            825,
+            672
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Results We compare CSDI with four baselines. Specifically, TimeGrad [25] combined the diffusion model with a RNN-based encoder. We evaluate each method for CRPS-sum, which is CRPS for the distribution of the sum of all time series across $K$ features and accounts for joint effect (see Appendix E.3 for details). ",
+        "bbox": [
+            174,
+            688,
+            825,
+            743
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In Table 5, CSDI outperforms the baselines for electricity and traffic datasets, and is competitive with the baselines as a whole. The advantage of CSDI over baselines for forecasting is smaller than that for imputation in Section 6.1. We hypothesize it is because the datasets for forecasting seldom contains missing values and are suitable for existing encoders including RNNs. For imputation, it is relatively difficult for RNNs to handle time series due to missing values. ",
+        "bbox": [
+            174,
+            750,
+            825,
+            819
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "7 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            838,
+            299,
+            856
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we have proposed CSDI, a novel approach to impute multivariate time series with conditional diffusion models. We have shown that CSDI outperforms the existing probabilistic and deterministic imputation methods. ",
+        "bbox": [
+            176,
+            869,
+            823,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "There are some interesting directions for future work. One direction is to improve the computation efficiency. While diffusion models generate plausible samples, sampling is generally slower than other generative models. To mitigate the issue, several recent studies leverage an ODE solver to accelerate the sampling procedure [12, 38, 13]. Combining our method with these approaches would likely improve the sampling efficiency. ",
+        "bbox": [
+            174,
+            92,
+            825,
+            161
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Another direction is to extend CSDI to downstream tasks such as classifications. Many previous studies have shown that accurate imputation improves the performance on downstream tasks [7, 18, 22]. Since conditional diffusion models can learn temporal and feature dependencies with uncertainty, joint training of imputations and downstream tasks using conditional diffusion models would be helpful to improve the performance of the downstream tasks. ",
+        "bbox": [
+            174,
+            166,
+            825,
+            236
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Finally, although our focus was on time series, it would be interesting to explore CSDI as imputation technique on other modalities. ",
+        "bbox": [
+            173,
+            242,
+            823,
+            270
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgements and Disclosure of Funding ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            290,
+            562,
+            308
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "This research was supported by NSF(#1651565, #1522054, #1733686), ONR (N000141912145), AFOSR (FA95501910024), ARO (W911NF-21-1-0125) and Sloan Fellowship. ",
+        "bbox": [
+            173,
+            321,
+            825,
+            349
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            371,
+            266,
+            386
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "[1] Ikaro Silva, George Moody, Daniel J Scott, Leo A Celi, and Roger G Mark. Predicting inhospital mortality of icu patients: The physionet/computing in cardiology challenge 2012. In Computing in Cardiology, pages 245–248. IEEE, 2012.   \n[2] Xiuwen Yi, Yu Zheng, Junbo Zhang, and Tianrui Li. ST-MVL: filling missing values in geo-sensory time series data. In Proceedings of International Joint Conference on Artificial Intelligence, pages 2704–2710, 2016.   \n[3] Huachun Tan, Guangdong Feng, Jianshuai Feng, Wuhong Wang, Yu-Jin Zhang, and Feng Li. A tensor-based method for missing traffic data completion. Transportation Research Part C: Emerging Technologies, 28:15–27, 2013.   \n[4] Fulufhelo V Nelwamondo, Shakir Mohamed, and Tshilidzi Marwala. Missing data: A comparison of neural network and expectation maximization techniques. Current Science, pages 1514–1521, 2007.   \n[5] Andrew T Hudak, Nicholas L Crookston, Jeffrey S Evans, David E Hall, and Michael J Falkowski. Nearest neighbor imputation of species-level, plot-scale forest structure attributes from lidar data. Remote Sensing of Environment, 112(5):2232–2245, 2008.   \n[6] S van Buuren and Karin Groothuis-Oudshoorn. MICE: Multivariate imputation by chained equations in r. Journal of statistical software, pages 1–68, 2010.   \n[7] Wei Cao, Dong Wang, Jian Li, Hao Zhou, Lei Li, and Yitan Li. BRITS: Bidirectional recurrent imputation for time series. In Advances in Neural Information Processing Systems, 2018.   \n[8] Zhengping Che, Sanjay Purushotham, Kyunghyun Cho, David Sontag, and Yan Liu. Recurrent neural networks for multivariate time series with missing values. Scientific reports, 8(1):1–12, 2018.   \n[9] Yonghong Luo, Xiangrui Cai, Ying Zhang, Jun Xu, and Xiaojie Yuan. Multivariate time series imputation with generative adversarial networks. In Advances in Neural Information Processing Systems, pages 1603–1614, 2018.   \n[10] Vincent Fortuin, Dmitry Baranchuk, Gunnar Rätsch, and Stephan Mandt. GP-VAE: Deep probabilistic time series imputation. In International Conference on Artificial Intelligence and Statistics, 2020.   \n[11] Jonathan Ho, Ajay Jain, and Pieter Abbeel. Denoising diffusion probabilistic models. In Advances in Neural Information Processing Systems, 2020. ",
+        "bbox": [
+            178,
+            387,
+            826,
+            915
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "[12] Yang Song, Jascha Sohl-Dickstein, Diederik P Kingma, Abhishek Kumar, Stefano Ermon, and Ben Poole. Score-based generative modeling through stochastic differential equations. In International Conference on Learning Representations, 2021. ",
+        "bbox": [
+            173,
+            90,
+            823,
+            133
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[13] Zhifeng Kong, Wei Ping, Jiaji Huang, Kexin Zhao, and Bryan Catanzaro. DiffWave: A versatile diffusion model for audio synthesis. In International Conference on Learning Representations, 2021. ",
+        "bbox": [
+            171,
+            142,
+            825,
+            185
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[14] Nanxin Chen, Yu Zhang, Heiga Zen, Ron J Weiss, Mohammad Norouzi, and William Chan. WaveGrad: Estimating gradients for waveform generation. In International Conference on Learning Representations, 2021. ",
+        "bbox": [
+            171,
+            194,
+            821,
+            238
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[15] Zahra Kadkhodaie and Eero P Simoncelli. Solving linear inverse problems using the prior implicit in a denoiser. arXiv preprint arXiv:2007.13640, 2020. ",
+        "bbox": [
+            171,
+            246,
+            823,
+            276
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[16] Gautam Mittal, Jesse Engel, Hawthorne Curtis, and Ian Simon. Symbolic music generation with diffusion models. arXiv preprint arXiv:2103.16091, 2021. ",
+        "bbox": [
+            174,
+            285,
+            825,
+            314
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[17] Jinsung Yoon, William R Zame, and Mihaela van der Schaar. Estimating missing data in temporal data streams using multi-directional recurrent neural networks. IEEE Transactions on Biomedical Engineering, 66(5):1477–1490, 2018. ",
+        "bbox": [
+            173,
+            324,
+            823,
+            366
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[18] Yonghong Luo, Ying Zhang, Xiangrui Cai, and Xiaojie Yuan. E2GAN: End-to-end generative adversarial network for multivariate time series imputation. In Proceedings of International Joint Conference on Artificial Intelligence, pages 3094–3100, 2019. ",
+        "bbox": [
+            174,
+            375,
+            825,
+            419
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[19] Xiaoye Miao, Yangyang Wu, Jun Wang, Yunjun Gao, Xudong Mao, and Jianwei Yin. Generative semi-supervised learning for multivariate time series imputation. In The Thirty-Fifth AAAI Conference on Artificial Intelligence, 2021. ",
+        "bbox": [
+            174,
+            428,
+            823,
+            470
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[20] Tae-Min Choi, Ji-Su Kang, and Jong-Hwan Kim. RDIS: Random drop imputation with selftraining for incomplete time series data. In The Thirty-Fifth AAAI Conference on Artificial Intelligence, 2021. ",
+        "bbox": [
+            174,
+            479,
+            823,
+            522
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[21] Qiuling Suo, Weida Zhong, Guangxu Xun, Jianhui Sun, Changyou Chen, and Aidong Zhang. GLIMA: Global and local time series imputation with multi-directional attention learning. In 2020 IEEE International Conference on Big Data (Big Data), pages 798–807. IEEE, 2020. ",
+        "bbox": [
+            174,
+            531,
+            821,
+            575
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[22] Satya Narayan Shukla and Benjamin M Marlin. Multi-time attention networks for irregularly sampled time series. In International Conference on Learning Representations, 2021. ",
+        "bbox": [
+            174,
+            583,
+            821,
+            613
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[23] Yang Song and Stefano Ermon. Generative modeling by estimating gradients of the data distribution. In Advances in Neural Information Processing Systems, 2019. ",
+        "bbox": [
+            173,
+            621,
+            823,
+            651
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[24] Chenhao Niu, Yang Song, Jiaming Song, Shengjia Zhao, Aditya Grover, and Stefano Ermon. Permutation invariant graph generation via score-based generative modeling. In International Conference on Artificial Intelligence and Statistics, pages 4474–4484. PMLR, 2020. ",
+        "bbox": [
+            173,
+            660,
+            823,
+            704
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[25] Kashif Rasul, Calvin Seward, Ingmar Schuster, and Roland Vollgraf. Autoregressive denoising diffusion models for multivariate probabilistic time series forecasting. In International Conference on Machine Learning, 2021. ",
+        "bbox": [
+            173,
+            713,
+            825,
+            756
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[26] Jascha Sohl-Dickstein, Eric Weiss, Niru Maheswaranathan, and Surya Ganguli. Deep unsupervised learning using nonequilibrium thermodynamics. In International Conference on Machine Learning, 2015. ",
+        "bbox": [
+            173,
+            763,
+            823,
+            808
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[27] Yang Song and Stefano Ermon. Improved techniques for training score-based generative models. In Advances in Neural Information Processing Systems, 2020. ",
+        "bbox": [
+            171,
+            816,
+            825,
+            847
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[28] Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. BERT: Pre-training of deep bidirectional transformers for language understanding. In Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long and Short Papers), pages 4171–4186, 2019. ",
+        "bbox": [
+            174,
+            856,
+            826,
+            912
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[29] Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Lukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Advances in Neural Information Processing Systems, 2017. ",
+        "bbox": [
+            171,
+            90,
+            825,
+            133
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[30] Simiao Zuo, Haoming Jiang, Zichong Li, Tuo Zhao, and Hongyuan Zha. Transformer hawkes process. In International Conference on Machine Learning, 2020. ",
+        "bbox": [
+            171,
+            142,
+            825,
+            172
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[31] Edwin V Bonilla, Kian Ming A Chai, and Christopher KI Williams. Multi-task gaussian process prediction. In Advances in Neural Information Processing Systems, 2008. ",
+        "bbox": [
+            174,
+            180,
+            823,
+            210
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[32] Ahmad Wisnu Mulyadi, Eunji Jun, and Heung-Il Suk. Uncertainty-aware variational-recurrent imputation network for clinical time series. IEEE Transactions on Cybernetics, 2021. to appear. ",
+        "bbox": [
+            173,
+            218,
+            825,
+            247
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[33] James E Matheson and Robert L Winkler. Scoring rules for continuous probability distributions. Management science, 22(10):1087–1096, 1976. ",
+        "bbox": [
+            174,
+            256,
+            823,
+            285
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[34] David Salinas, Michael Bohlke-Schneider, Laurent Callot, Roberto Medico, and Jan Gasthaus. High-dimensional multivariate forecasting with low-rank gaussian copula processes. In Advances in Neural Information Processing Systems, 2019. ",
+        "bbox": [
+            173,
+            294,
+            825,
+            337
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[35] Yulia Rubanova, Ricky TQ Chen, and David Duvenaud. Latent ordinary differential equations for irregularly-sampled time series. In Advances in Neural Information Processing Systems, 2019. ",
+        "bbox": [
+            173,
+            345,
+            825,
+            388
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[36] Kashif Rasul, Abdul-Saboor Sheikh, Ingmar Schuster, Urs Bergmann, and Roland Vollgraf. Multi-variate probabilistic time series forecasting via conditioned normalizing flows. In International Conference on Learning Representations, 2021. ",
+        "bbox": [
+            173,
+            397,
+            825,
+            440
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[37] Nam Nguyen and Brian Quanz. Temporal latent auto-encoder: A method for probabilistic multivariate time series forecasting. In The Thirty-Fifth AAAI Conference on Artificial Intelligence, 2021. ",
+        "bbox": [
+            173,
+            449,
+            823,
+            491
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[38] Jiaming Song, Chenlin Meng, and Stefano Ermon. Denoising diffusion implicit models. In International Conference on Learning Representations, 2021. ",
+        "bbox": [
+            173,
+            501,
+            821,
+            530
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[39] Adam Paszke, Sam Gross, Francisco Massa, Adam Lerer, James Bradbury, Gregory Chanan, Trevor Killeen, Zeming Lin, Natalia Gimelshein, Luca Antiga, et al. Pytorch: An imperative style, high-performance deep learning library. In Advances in Neural Information Processing Systems, 2019. ",
+        "bbox": [
+            174,
+            537,
+            825,
+            594
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[40] Phil Wang. Linear attention transformer. https://github.com/lucidrains/ linear-attention-transformer, 2020. ",
+        "bbox": [
+            171,
+            604,
+            825,
+            633
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[41] Zhuoran Shen, Mingyuan Zhang, Haiyu Zhao, Shuai Yi, and Hongsheng Li. Efficient attention: Attention with linear complexities. In Proceedings of the IEEE/CVF Winter Conference on Applications of Computer Vision, pages 3531–3539, 2021. ",
+        "bbox": [
+            173,
+            641,
+            823,
+            685
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[42] Alex Nichol and Prafulla Dhariwal. Improved denoising diffusion probabilistic models. In International Conference on Machine Learning, 2021. ",
+        "bbox": [
+            171,
+            693,
+            823,
+            723
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[43] Jacob R Gardner, Geoff Pleiss, David Bindel, Kilian Q Weinberger, and Andrew Gordon Wilson. Gpytorch: Blackbox matrix-matrix gaussian process inference with gpu acceleration. In Advances in Neural Information Processing Systems, 2018. ",
+        "bbox": [
+            173,
+            731,
+            825,
+            775
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[44] Alexander Alexandrov, Konstantinos Benidis, Michael Bohlke-Schneider, Valentin Flunkert, Jan Gasthaus, Tim Januschowski, Danielle C. Maddix, Syama Rangapuram, David Salinas, Jasper Schulz, Lorenzo Stella, Ali Caner Türkmen, and Yuyang Wang. GluonTS: Probabilistic and Neural Time Series Modeling in Python. Journal of Machine Learning Research, 21(116):1–6, 2020. ",
+        "bbox": [
+            174,
+            784,
+            825,
+            853
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[45] Guokun Lai, Wei-Cheng Chang, Yiming Yang, and Hanxiao Liu. Modeling long-and short-term temporal patterns with deep neural networks. In The 41st International ACM SIGIR Conference on Research & Development in Information Retrieval, pages 95–104, 2018. ",
+        "bbox": [
+            171,
+            862,
+            821,
+            905
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Checklist ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            89,
+            254,
+            106
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "1. For all authors... ",
+        "bbox": [
+            214,
+            116,
+            339,
+            130
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes] We described our proposed method and empirical results in the abstract and introduction.   \n(b) Did you describe the limitations of your work? [Yes] We have mentioned some limitations of our work in Section 7.   \n(c) Did you discuss any potential negative societal impacts of your work? [Yes] Please see Appendix H.   \n(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes] We have read the guidelines and ensured that our paper conforms to them. ",
+        "bbox": [
+            238,
+            135,
+            825,
+            267
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "2. If you are including theoretical results... ",
+        "bbox": [
+            215,
+            272,
+            493,
+            286
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you state the full set of assumptions of all theoretical results? [N/A] (b) Did you include complete proofs of all theoretical results? [N/A] ",
+        "bbox": [
+            238,
+            290,
+            736,
+            321
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "3. If you ran experiments... ",
+        "bbox": [
+            212,
+            325,
+            393,
+            340
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [Yes] Please see the abstract.   \n(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] Please see Section 6 and Appendix E.2.   \n(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [Yes] We gave error bars in figures and the standard errors in tables.   \n(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [No] We did not focus on computational time. ",
+        "bbox": [
+            238,
+            344,
+            825,
+            503
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... ",
+        "bbox": [
+            210,
+            508,
+            823,
+            523
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) If your work uses existing assets, did you cite the creators? [Yes] We cited packages we used. We also cited papers which provided datasets.   \n(b) Did you mention the license of the assets? [No] We only used open dataset. Please refer to citations for details on licensing.   \n(c) Did you include any new assets either in the supplemental material or as a URL? [No] We did not release new assets.   \n(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [No] We only used open dataset.   \n(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [No] The datasets we used are open numerical time series dataset and do not contain personally identifiable information. ",
+        "bbox": [
+            238,
+            527,
+            825,
+            689
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "5. If you used crowdsourcing or conducted research with human subjects... ",
+        "bbox": [
+            214,
+            694,
+            705,
+            708
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   \n(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   \n(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A] ",
+        "bbox": [
+            238,
+            712,
+            825,
+            801
+        ],
+        "page_idx": 12
+    }
+]

parse/train/_0kaDkv3dVf/_0kaDkv3dVf.md

@@ -0,0 +1,351 @@
+# HW-NAS-BENCH: HARDWARE-AWARE NEURAL ARCHITECTURE SEARCH BENCHMARK
+
+Chaojian Li, Zhongzhi Yu, Yonggan Fu, Yongan Zhang, Yang Zhao, Haoran You, Qixuan Yu,   
+Yue Wang & Yingyan Lin   
+Department of Electrical and Computer Engineering   
+Rice University   
+{cl114,zy42,yf22,yz87,zy34,hy34,qy12,yw68,yingyan.lin}@rice.edu
+
+# ABSTRACT
+
+HardWare-aware Neural Architecture Search (HW-NAS) has recently gained tremendous attention by automating the design of deep neural networks deployed in more resource-constrained daily life devices. Despite its promising performance, developing optimal HW-NAS solutions can be prohibitively challenging as it requires cross-disciplinary knowledge in the algorithm, micro-architecture, and device-specific compilation. First, to determine the hardware-cost to be incorporated into the NAS process, existing works mostly adopt either pre-collected hardware-cost look-up tables or device-specific hardware-cost models. The former can be time-consuming due to the required knowledge of the device’s compilation method and how to set up the measurement pipeline, while building the latter is often a barrier for non-hardware experts like NAS researchers. Both of them limit the development of HW-NAS innovations and impose a barrier-to-entry to non-hardware experts. Second, similar to generic NAS, it can be notoriously difficult to benchmark HW-NAS algorithms due to their significant required computational resources and the differences in adopted search spaces, hyperparameters, and hardware devices. To this end, we develop HW-NAS-Bench, the first public dataset for HW-NAS research which aims to democratize HW-NAS research to non-hardware experts and make HW-NAS research more reproducible and accessible. To design HW-NAS-Bench, we carefully collected the measured/estimated hardware performance (e.g., energy cost and latency) of all the networks in the search spaces of both NAS-Bench-201 and FBNet, on six hardware devices that fall into three categories (i.e., commercial edge devices, FPGA, and ASIC). Furthermore, we provide a comprehensive analysis of the collected measurements in HW-NAS-Bench to provide insights for HW-NAS research. Finally, we demonstrate exemplary user cases to (1) show that HW-NAS-Bench allows non-hardware experts to perform HW-NAS by simply querying our premeasured dataset and (2) verify that dedicated device-specific HW-NAS can indeed lead to optimal accuracy-cost trade-offs. The codes and all collected data are available at https://github.com/RICE-EIC/HW-NAS-Bench.
+
+# 1 INTRODUCTION
+
+The recent performance breakthroughs of deep neural networks (DNNs) have attracted an explosion of research in designing efficient DNNs, aiming to bring powerful yet power-hungry DNNs into more resource-constrained daily life devices for enabling various DNN-powered intelligent functions (Ross, 2020; Liu et al., 2018b; Shen et al., 2020; You et al., 2020a). Among them, HardWareaware Neural Architecture Search (HW-NAS) has emerged as one of the most promising techniques as it can automate the process of designing optimal DNN structures for the target applications, each of which often adopts a different hardware device and requires a different hardware-cost metric (e.g., prioritizes latency or energy). For example, HW-NAS in (Wu et al., 2019) develops a differentiable neural architecture search (DNAS) framework and discovers state-of-the-art (SOTA) DNNs balancing both accuracy and hardware efficiency, by incorporating a loss consisting of both the cross-entropy loss that leads to better accuracy and the latency loss that penalizes the network’s latency on a target device.
+
+![](images/4188dc268cb15f00e2fe476ecbe2199db807c269e72006ebddc40c20057dbf9c.jpg)  
+Figure 1: An illustration of our proposed HW-NAS-Bench
+
+Despite the promising performance achieved by SOTA HW-NAS, there exist paramount challenges that limit the development of HW-NAS innovations. First, HW-NAS requires the collection of hardware efficiency data corresponding to (all) the networks in the search space. To do so, current practice either pre-collects these data to construct a hardware-cost look-up table or adopts device-specific hardware-cost estimators/models, both of which can be time-consuming to obtain and impose a barrier-to-entry to non-hardware experts. This is because it requires knowledge about device-specific compilation and properly setting up the hardware measurement pipeline to collect hardware-cost data. Second, similar to generic NAS, it can be notoriously difficult to benchmark HW-NAS algorithms due to the required significant computational resources and the differences in their (1) hardware devices, which are specific for HW-NAS, (2) adopted search spaces, and (3) hyperparameters. Such a difficulty is even higher for HW-NAS considering the numerous choices of hardware devices, each of which can favor very different network structures even under the same target hardware efficiency, as discussed in (Chu et al., 2020). While the number of floating-point operations (FLOPs) has been commonly used to estimate the hardware-cost, many works have pointed out that DNNs with fewer FLOPs are not necessarily faster or more efficient (Wu et al., 2019; 2018; Wang et al., 2019b). For example, NasNet-A (Zoph et al., 2018) has a comparable complexity in terms of FLOPs as MobileNetV1 (Howard et al., 2017), yet can have a larger latency than the latter due to NasNet-A (Zoph et al., 2018)’s adopted hardware-unfriendly structure.
+
+It is thus imperative to address the aforementioned challenges in order to make HW-NAS more accessible and reproducible to unfold HW-NAS’s full potential. Note that although pioneering NAS benchmark datasets (Ying et al., 2019; Dong & Yang, 2020; Klyuchnikov et al., 2020; Siems et al., 2020; Dong et al., 2020) have made a significant step towards providing a unified benchmark dataset for generic NAS works, all of them either merely provide the latency on server-level GPUs (e.g., GTX 1080Ti) or do not provide any hardware-cost data on real hardware, limiting their applicability to HW-NAS (Wu et al., 2019; Wan et al., 2020; Cai et al., 2018) which primarily targets commercial edge devices, FPGA, and ASIC. To this end, as shown in Figure 1, we develop HW-NAS-Bench and make the following contributions in this paper:
+
+• We have developed HW-NAS-Bench, the first public dataset for HW-NAS research aiming to (1) democratize HW-NAS research to non-hardware experts and (2) facilitate a unified benchmark for HW-NAS to make HW-NAS research more reproducible and accessible, covering two SOTA NAS search spaces including NAS-Bench-201 and FBNet, with the former being one of the most popular NAS search spaces and the latter having been shown to be one of the most hardware friendly NAS search spaces. • We provide hardware-cost data collection pipelines for six commonly used hardware devices that fall into three categories (i.e., commercial edge devices, FPGA, and ASIC), in addition to the measured/estimated hardware-cost (e.g., energy cost and latency) on these devices for all the networks in the search spaces of both NAS-Bench-201 and FBNet. • We conduct comprehensive analysis of the collected data in HW-NAS-Bench, such as studying the correlation between the collected hardware-cost and accuracy-cost data of all the networks on the six hardware devices, which provides insights to not only HW-NAS researchers but also DNN accelerator designers. Other researchers can extract useful insights from HW-NAS-Bench that have not been discussed in this work.
+
+• We demonstrate exemplary user cases to show: (1) how HW-NAS-Bench can be easily used by non-hardware experts to develop HW-NAS solutions by simply querying the collected data in our HW-NAS-Bench and (2) dedicated device-specific HW-NAS can indeed lead to optimal accuracy-cost trade-offs, demonstrating the great necessity of HW-NAS benchmarks like our proposed HW-NAS-Bench.
+
+# 2 RELATED WORKS
+
+# 2.1 HARDWARE-AWARE NEURAL ARCHITECTURE SEARCH
+
+Driven by the growing demand for efficient DNN solutions, HW-NAS has been proposed to automate the search for efficient DNN structures under the target efficiency constraints (Fu et al., 2020b;a; Zhang et al., 2020). For example, (Tan et al., 2019; Howard et al., 2019; Tan & Le, 2019) adopt reinforcement learning based NAS with a multi-objective reward consisting of both the task performance and efficiency, achieving promising results yet suffering from prohibitive search time/cost. In parallel, (Wu et al., 2019; Wan et al., 2020; Cai et al., 2018; Stamoulis et al., 2019) explore the design space in a differentiable manner following (Liu et al., 2018a) and significantly improve the search efficiency. The promising performance of HW-NAS has motivated a tremendous interest in applying it to more diverse applications (Fu et al., 2020a; Wang et al., 2020a; Marchisio et al., 2020) paired with target hardware devices, e.g., Edge TPU (Xiong et al., 2020) and NPU (Lee et al., 2020), in addition to the widely explored mobile phones.
+
+As discussed in (Chu et al., 2020), different hardware devices can favor very different network structures under the same hardware-cost metric, and the optimal network structure can differ significantly when considering different application-driven hardware-cost metrics on the same hardware device. As such, it would ideally lead to the optimal accuracy-cost trade-offs if the HW-NAS design is dedicated for the target device and hardware-cost metrics. However, this requires a good understanding of both device-specific compilation and hardware-cost characterization, imposing a barrier-to-entry to non-hardware experts, such as many NAS researchers, and thus limits the development of optimal HW-NAS results for numerous applications, each of which often prioritizes a different application-driven hardware-cost metric and adopts a different type of hardware devices. As such, our proposed HW-NAS-Bench will make HW-NAS more friendly to NAS researchers, who are often non-hardware experts, as it consists of comprehensive hardware-cost data in a wide range of hardware devices for all the networks in two commonly used SOTA NAS search spaces, expediting the development of HW-NAS innovations.
+
+# 2.2 NEURAL ARCHITECTURE SEARCH BENCHMARKS
+
+The importance and difficulty of NAS reproducibility and benchmarking has recently gained increasing attention. Pioneering efforts include (Ying et al., 2019; Dong & Yang, 2020; Klyuchnikov et al., 2020; Siems et al., 2020; Dong et al., 2020). Specifically, NAS-Bench-101 (Ying et al., 2019) presents the first large-scale and open-source architecture dataset for NAS, in which the ground truth test accuracy of all the architectures (i.e., 423k) in its search space on CIFAR-10 (Krizhevsky et al., 2009) are provided. Later, NAS-Bench-201 (Dong & Yang, 2020) further extends NAS-Bench-101 to support more NAS algorithm categories (e.g., differentiable algorithms) and more datasets (e.g., CIFAR-100 (Krizhevsky et al., 2009) and ImageNet16-120 (Chrabaszcz et al., 2017)). Most recently, NAS-Bench-301 (Siems et al., 2020) and NATS-Bench (Dong et al., 2020) are developed to support benchmarking NAS algorithms on larger search spaces. However, all of these works either merely provide latency on the server-level GPU (e.g., GTX 1080Ti) or do not consider any hardware-cost data on real hardware at all, limiting their applicability to HW-NAS (Wu et al., 2019; Wan et al., 2020; Cai et al., 2018) that primarily targets commercial edge devices, FPGA (Wang et al., 2020b), and ASIC (Chen et al., 2016; Lin et al., 2017; 2016; Zhao et al., 2020a). This has motivated us to develop the proposed HW-NAS-Bench, which aims to make HW-NAS more accessible especially for non-hardware experts and reproducible.
+
+A concurrent work (published after our submission) is BRP-NAS (Chau et al., 2020), which presents a benchmark for the latency of all the networks in NAS-Bench-201 (Dong & Yang, 2020) search space. In comparison, our proposed HW-NAS-Bench includes (1) more device categories (i.e., not only commercial devices, but also FPGA (Wang et al., 2020b) and ASIC (Chen et al., 2016)), (2) more hardware-cost metrics (i.e., not only latency, but also energy), and (3) more search spaces (i.e., not only NAS-Bench-201 (Dong & Yang, 2020) but also FBNet (Wu et al., 2019)). Additionally, we (4) add a detailed description of the pipeline to collect the hardware-cost of various devices and (5) analyze the necessity of device-specific HW-NAS solutions based on our collected data.
+
+# 3 THE PROPOSED HW-NAS-BENCH FRAMEWORK
+
+# 3.1 HW-NAS-BENCH’S CONSIDERED SEARCH SPACES
+
+To ensure a wide applicability, our HW-NAS-Bench considers two representative NAS search spaces: (1) NAS-Bench-201’s cell-based search space and (2) FBNet search space. Both contribute valuable aspects to ensure our goal of constructing a comprehensive HW-NAS benchmark. Specifically, the former enables HW-NAS-Bench to naturally integrate the ground truth accuracy data of all NAS-Bench-201’s considered network architectures, while the latter ensures that HW-NASBench includes the most commonly recognized hardware friendly search space.
+
+NAS-Bench-201 Search Space. Inspired from the search space used in the most popular cell-based NAS, NAS-Bench-201 adopts a fixed cell search space, where each architecture consists of a predefined skeleton with a stack of the searched cell that is represented as a densely-connected directed acyclic graph (DAG). Specifically, it considers 4 nodes and 5 representative operation candidates for the operation set, and varies the feature map sizes and the dimensions of the final fully-connected layer to handle its considered three datasets (i.e., CIFAR-10, CIFAR-100 (Krizhevsky et al., 2009), and ImageNet16-120 (Chrabaszcz et al., 2017)), leading to a total of $3 \times 5 ^ { 6 } = 4 6 8 7 5$ architectures. Training log and accuracy are provided for each architecture. However, NAS-Bench-201 can not be directly used for HW-NAS as it only includes theoretical cost metrics (i.e., FLOPs and the number of parameters (#Params)) and the latency on a server-level GPU (i.e., GTX 1080Ti). HW-NASBench enhances NAS-Bench-201 by providing all the 46875 architectures’ measured/estimated hardware-cost on six devices, which are primarily targeted by SOTA HW-NAS works.
+
+FBNet Search Space. FBNet (Wu et al., 2019) constructs a layer-wise search space with a fixed macro-architecture, which defines the number of layers and the input/output dimensions of each layer and fixes the first and last three layers with the remaining layers to be searched. In this way, the network architectures in the FBNet (Wu et al., 2019) search space have more regular structures than those in NAS-Bench-201, and have been shown to be more hardware friendly (Fu et al., 2020a; Ma et al., 2018). The 9 considered pre-defined cell candidates and 22 unique positions lead to a total of $9 ^ { 2 2 } \approx 1 0 ^ { 2 1 }$ unique architectures. While HW-NAS researchers can develop their search algorithms on top of the FBNet (Wu et al., 2019) search space, tedious efforts are required to build the hardware-cost look-up tables or models for each target device. HW-NAS-Bench provides the measured/estimated hardware-cost on six hardware devices for all the $1 0 ^ { 2 1 }$ architectures in the FBNet search space, aiming to make HW-NAS research more friendly to non-hardware experts and easier to be benchmarked.
+
+# 3.2 HARDWARE-COST COLLECTION PIPELINE AND THE CONSIDERED DEVICES
+
+To collect the hardware-cost data for all the architectures in both the NAS-Bench-201 and FBNet search spaces, we construct a generic hardware-cost collection pipeline (see Figure 2) to automate the process. The pipeline mainly consists of the target devices and corresponding deployment tools (e.g., compilers). Specifically, it takes all the networks as its inputs, and then compiles the networks to (1) convert them into the device’s required execution format and (2) optimize the execution flow, the latter of which aims to optimize the hardware performance on the target devices. For example, for collecting the hardware-cost in an Edge GPU, we first set the device in the Max-N mode to fully make use of all available resources following (Wofk et al., 2019), and then set up the embedded power rail monitor (Texas Instruments Inc.) to obtain the real-measured latency and energy via sysfs (Patrick Mochel and Mike Murphy.), averaging over 50 runs. We can see that the hardware-cost collection pipeline requires various hardware domain knowledge, including machine learning development frameworks, device compilation, embedded systems, and device measurements, imposing a barrier-to-entry to non-hardware experts.
+
+![](images/6930869f661da4f5c2287731b45b878afa28f2eaaeea54cc5860b428437743c0.jpg)  
+Figure 2: Illustrating the hardware-cost collection pipeline applicable to various hardware devices.
+
+Next, we briefly introduce the six considered hardware devices (as summarized in Table 1) and the specific configuration required to collect the hardware-cost data on each device.
+
+Edge GPU: NVIDIA Edge GPU Jetson TX2 (Edge GPU) is a commercial device with a 256-core Pascal GPU and a 8GB LPDDR4, targeting IoT applications (NVIDIA Inc., a). When plugging an Edge GPU into the above hardware-cost collection pipeline, we first compile the network architectures in both NAS-Bench-201 and FBNet spaces to (1) convert them to the TensorRT format and (2) optimize the inference implementation within NVIDIA’s recommended TensorRT runtime environment, and then execute them in the Edge GPU to measure the consumed energy and latency.
+
+Raspi 4: Raspberry Pi 4 (Raspi 4) is the latest Raspberry Pi device (Raspberry Pi Limited.), consisting of a Broadcom BCM2711 SoC and a 4GB LPDDR4. To collect the hardware-cost operating on it, we compile the architecture candidates to (1) convert them into the TensorFlow Lite (TFLite) (Abadi et al., 2016) format and (2) optimize the implementation using the official interpreter (Google LLC., 2020) in Raspi 4, where the interpreter will be pre-configured.
+
+Edge TPU: An Edge TPU Dev Board (Edge TPU) (Google LLC., a) is a dedicated ASIC accelerator developed by Google, targeting Artificial Intelligence (AI) inference for edge applications. Similar to the case when using Raspi 4, all the architectures are converted into the TFLite format. After that, an Edge TPU compiler will be used to convert the pre-built TFLite model into a more compressed format which is compatible to the pre-configured runtime environment in the Edge TPU.
+
+Pixel 3: Pixel 3 is one of the latest Pixel mobile phones (Google LLC., e), which are widely used as the target platforms by recent NAS works (Xiong et al., 2020; Howard et al., 2019; Tan et al., 2019). To collect the hardware-cost in Pixel 3, we first convert all the architectures into the TFLite format, then use TFLite’s official benchmark binary file to obtain the latency, when configuring the Pixel 3 device to only use its big cores for reducing the measurement variance as in (Xiong et al., 2020; Tan et al., 2019).
+
+ASIC-Eyeriss: For collecting the hardware-cost data in ASIC, we consider a SOTA ASIC accelerator, Eyeriss (Chen et al., 2016). Specifically, we adopt the SOTA ASIC accelerator’s performance simulators: (1) Accelergy (Wu et al., 2019) $+$ Timeloop (Parashar et al., 2019) and (2) DNN-Chip Predictor (Zhao et al., 2020b), both of which automatically identify the optimal algorithm-to-hardware mapping methods for each architecture and then provide the estimated hardware-cost of the network execution in Eyeriss.
+
+Table 1: Important details about the six hardware devices considered by our HW-NAS-Bench.   
+
+<table><tr><td>Devices</td><td>Edge GPU</td><td>Raspi 4</td><td>Edge TPU</td><td>Pixel3</td><td>ASIC-Eyeriss</td><td>FPGA</td></tr><tr><td>Collected Metrics</td><td>Latency (ms) Energy (mJ)</td><td>Latency (ms)</td><td>Latency (ms)</td><td>Latency (ms)</td><td>Latency (ms) Energy (mJ)</td><td>Latency (ms) Energy (mJ)</td></tr><tr><td>Collecting Method</td><td>Measured</td><td>Measured</td><td>Measured</td><td>Measured</td><td>Estimated</td><td>Estimated</td></tr><tr><td>Runtime Environment</td><td>TensorRT</td><td>TensorFlow Lite</td><td>Edge TPU Runtime</td><td>TensorFlow Lite</td><td>Accelergy+Timeloop / DNN-Chip Predictor</td><td>Vivado HLS</td></tr><tr><td>Customizing Hardware?</td><td>X</td><td>×</td><td>X</td><td>X</td><td>√</td><td>√</td></tr><tr><td>Category I</td><td colspan="3">Commercial Edge Devices</td><td></td><td>ASIC</td><td>FPGA</td></tr></table>
+
+Table 2: Two types of correlation coefficients (larger means more correlated) between the realmeasured hardware-cost of the whole architectures and the approximated hardware-cost based on 100 randomly sampled architectures from the FBNet search space.   
+
+<table><tr><td>Correlation Coefficient Types</td><td>Datasets</td><td>Latency on Edge GPU</td><td>Energy on Edge GPU</td><td>Latency on Raspi 4</td><td>Latency on Edge TPU</td><td>Latency on Pixel3</td></tr><tr><td>Pearson Correlation Coefficient</td><td>CIFAR-100 ImageNet</td><td>0.9200 0.8634</td><td>0.9116 0.9640</td><td>0.9219 0.9897</td><td>0.4935 0.7153</td><td>0.9324 0.9162</td></tr><tr><td>Kendall Rank Correlation Coefficient</td><td>CIFAR-100 ImageNet</td><td>0.7373 0.7111</td><td>0.7240 0.8379</td><td>0.7470 0.9163</td><td>0.3551 0.5806</td><td>0.8593 0.8064</td></tr></table>
+
+FPGA: FPGA is a widely adopted AI acceleration platform featuring a higher hardware flexibility than ASIC and more decent hardware efficiency than commercial edge devices. To collect hardwarecost data in this platform, we first develop a SOTA chunk based pipeline structure (Shen et al., 2017; Zhang et al., 2020) implementation, compile all the architectures using the standard Vivado HLS toolflow (Xilinx Inc., a), and then obtain the hardware-cost on a Xilinx ZC706 board with a Zynq XC7045 SoC (Xilinx Inc., b).
+
+More details about the pipeline for each of the aforementioned devices are provided in the Appendix D for better understanding.
+
+In our HW-NAS-Bench, to estimate the hardware-cost of the networks in the FBNet search space (Wu et al., 2019) when being executed on the commercial edge devices (i.e., Edge GPU, Raspi 4, Edge TPU, and Pixel 3), we sum up the hardware-cost of all unique blocks (i.e., “block” in the FBNet space (Wu et al., 2019)) within the network architectures. To validate that such an approximation is close to the corresponding real-measured results, we conduct experiments, as summarized in Table 2, to calculate two types of correlation coefficients between the measured and the approximated hardware-cost based on 100 randomly sampled architectures from the FBNet search space. We can see that our approximated hardware-cost is highly correlated with the real-measured one, except for the case on the Edge TPU, which we conjecture is caused by the adopted in-house Edge TPU compiler (Google LLC., c). More visualization results can be found in the Appendix A.
+
+# 4 ANALYSIS ON HW-NAS-BENCH
+
+In this section, we provide analysis and visualization of the hardware-cost and corresponding accuracy data (the latter only for architectures in NAS-Bench-201) for all the architectures in the two considered search spaces. Specifically, our analysis and visualization confirm that (1) commonly used theoretical hardware-cost metrics such as FLOPs do not correlate well with the measured/estimated hardware-cost; (2) hardware-cost of the same architectures can differ a lot when executed on different devices; and (3) device-specific HW-NAS is necessary because optimal architectures resulting from HW-NAS targeting on one device can perform poorly in terms of the hardware-cost when being executed on another device.
+
+# 4.1 CORRELATION BETWEEN COLLECTED HARDWARE-COST AND THEORETICAL ONES
+
+To confirm whether commonly used theoretical hardware-cost metrics align with realmeasured/estimated ones, we summarize the calculated correlation between the collected hardwarecost in our HW-NAS-Bench and the theoretical metrics (i.e., FLOPs and #Params), based on the data for all the architectures in both search spaces on all the six considered hardware devices where a total of four different datasets are involved.
+
+Table 3: Kendall Rank Correlation Coefficient between real-measured/estimated hardware-cost and theoretical ones considering the NAS-Bench-201 search space, where coefficients $< 0 . 5$ are bolded.   
+
+<table><tr><td rowspan="2">Dataset</td><td rowspan="2">Metrics</td><td colspan="2">Edge GPU</td><td rowspan="2">Raspi 4 Latency</td><td rowspan="2">Edge TPU Latency</td><td rowspan="2">Pixel3 Latency</td><td colspan="2">ASIC-Eyeriss Energy</td><td colspan="2">FPGA</td></tr><tr><td>Latency</td><td>Energy</td><td></td><td>Latency</td><td>Latency</td><td>Energy</td></tr><tr><td>CIFAR-10</td><td>FLOPs #Params</td><td>0.3571 0.3571</td><td>0.4064 0.4064</td><td>0.7394 0.7394</td><td>0.1847 0.1847</td><td>0.6823 0.6823</td><td>0.4178 0.4178</td><td>0.5359 0.5359</td><td>0.8313 0.8313</td><td>0.8313 0.8313</td></tr><tr><td>CIFAR-100</td><td>FLOPs #Params</td><td>0.3589 0.3589</td><td>0.4073 0.4073</td><td>0.7384 0.7384</td><td>0.1851 0.1851</td><td>0.6844 0.6844</td><td>0.4197 0.4197</td><td>0.5360 0.5360</td><td>0.8313 0.8313</td><td>0.8313 0.8313</td></tr><tr><td>ImageNet16-120</td><td>FLOPs #Params</td><td>0.3544 0.3544</td><td>0.3868 0.3868</td><td>0.6303 0.6303</td><td>0.2635 0.2635</td><td>0.7017 0.7017</td><td>0.4166 0.4166</td><td>0.5363 0.5363</td><td>0.9205 0.9205</td><td>0.9205 0.9205</td></tr></table>
+
+Table 4: Kendall Rank Correlation Coefficient between real-measured/estimated hardware-cost and theoretical ones considering the FBNet search space, where coefficients $< 0 . 5$ are bolded.   
+
+<table><tr><td rowspan="2">Dataset</td><td rowspan="2">Metrics</td><td colspan="2">Edge GPU</td><td rowspan="2">Raspi 4 Latency</td><td rowspan="2">Pixel 3 Latency</td><td colspan="2">ASIC-Eyeriss</td><td colspan="2">FPGA</td></tr><tr><td>Latency</td><td>Energy</td><td>Latency</td><td>Energy</td><td>Latency</td><td>Energy</td></tr><tr><td>CIFAR-100</td><td>FLOPs #Params</td><td>0.0149 -0.0733</td><td>0.1564 0.0202</td><td>0.7713 0.4910</td><td>0.8092 0.3734</td><td>0.8490 0.4297</td><td>0.7854 0.6455</td><td>0.8710 0.5151</td><td>0.8710 0.5151</td></tr><tr><td>ImageNet</td><td>FLOPs #Params</td><td>0.4633 0.0985</td><td>0.6094 0.1840</td><td>0.7531 0.2318</td><td>0.7678 0.2357</td><td>0.8935 0.3202</td><td>0.7970 0.4140</td><td>0.8643 0.4198</td><td>0.8643 0.4198</td></tr></table>
+
+As summarized in Tables 3 - 4, commonly used theoretical hardware-cost metrics (i.e., FLOPs and #Params) do not always correlate well with measured/estimated hardware-cost for the architectures in both the NAS-Bench-201 and FBNet spaces. For example, there exists at least one coefficient $< 0 . 5$ on all devices, especially for the cases with real-measured/estimated hardware-cost on commonly considered edge platforms including Edge GPU, Edge TPU, and ASIC-Eyeriss. As such, HW-NAS based on the theoretical hardware-cost might lead to sub-optimal results, motivating HWNAS benchmarks like our HW-NAS-Bench. Note that we consider the Kendall Rank Correlation Coefficients (Abdi, 2007), which is a commonly used correlation coefficient in both recent NAS frameworks and benchmarks (You et al., 2020b; Siems et al., 2020; Yang et al., 2020).
+
+# 4.2 CORRELATION AMONG COLLECTED HARDWARE-COST ON DIFFERENT DEVICES
+
+To check how much the hardware-cost of the same architectures on different devices correlate, we visualize the correlation between the hardware-cost collected from every two paired devices based on the data for all the architectures in both the NAS-Bench-201 and FBNet search spaces with each of the architectures associated with 9 different hardware-cost metrics.
+
+![](images/5b00a372d68ed46b998416b2c65f7210e4247bee86e06330149e20d42a08d01d.jpg)  
+Figure 3: Kendall Rank Correlation Coefficient between real-measured/estimated hardware-cost in different devices considering the NAS-Bench-201 search space.
+
+![](images/1dd2bfb1186711d15a7282746f71350abeb845fe70f66e4fed31092bb8d8c07e.jpg)  
+Figure 4: Kendall Rank Correlation Coefficient between real-measured/estimated hardware-cost in different devices considering the FBNet search space.
+
+![](images/00dbdf204f58baf47177a9850fc6de86be428b6a7ae3c8dc0026a669da7e268d.jpg)  
+Figure 5: Accuracy vs. hardware-cost on different devices considering NAS-Bench-201, where points in red denote the architectures with the optimal trade-offs between “accuracy on ImageNet16- 120 vs. latency measured on Edge GPU”, of which the architectures represent the ground truth of HW-NAS targeting Edge GPUs.
+
+The visualization in Figures 3 - 4 indicates that hardware-cost of the same network architectures can differ a lot when being executed on different devices. More specifically, the correlation coefficients can be as small as -0.00 (e.g., Edge GPU latency vs. ASIC-Eyeriss energy for the architectures in the FBNet search space), which is resulting from the large difference in their underlying (1) hardware micro-architectures and (2) available hardware resources. Thus, the resulting architecture of HW-NAS targeting one device might perform poorly when being executed on other devices, motivating device-specific HW-NAS; Furthermore, it is crucial to develop comprehensive hardwarecost datasets like our HW-NAS-Bench to enable fast development and ensure optimal results of HW-NAS for different applications.
+
+# 4.3 OPTIMAL ARCHITECTURES ON DIFFERENT HARDWARE DEVICES
+
+To confirm the necessity of performing device-specific HW-NAS from another perspective, we summarize the test accuracy vs. hardware-cost of all the architectures in NAS-Bench-201 considering the ImageNet16-120 dataset, and analyze the architectures with the optimal accuracy-cost trade-offs for different devices.
+
+As shown in Figure 5, such optimal architectures for different devices are not the same. For example, the optimal architectures on Edge GPU (marked as red points) can perform poorly in terms of the hardware-cost in other devices, especially in ASIC-Eyeriss and Edge TPU whose hardware-cost exactly has the smallest correlation coefficient with the hardware-cost measured in Edge GPU, which is shown in Figure 3. Again, this set of analysis and visualization confirms that HW-NAS targeting on one device can perform poorly in terms of the hardware-cost when being executed on another device, thus motivating the necessity of device-specific HW-NAS.
+
+# 5 USER CASES: BENCHMARK SOTA HW-NAS ALGORITHMS
+
+In this section, we will demonstrate the user cases of our HW-NAS-Bench to show (1) how nonhardware experts can use it to develop HW-NAS solutions by simply querying the hardware-cost data and (2) dedicated device-specific HW-NAS can indeed often lead to optimal accuracy-cost trade-offs, again showing the important need for HW-NAS benchmarks like our HW-NAS-Bench to enable more optimal HW-NAS solutions via device-specific HW-NAS.
+
+Table 5: Inference accuracy and latency comparison of the optimal architectures resulting from HW-NAS-Bench when targeting different hardware devices.   
+
+<table><tr><td>Targeted Device in HW-NAS</td><td>Top-1 Acc.(%)</td><td>Latency on Edge GPU (ms)</td><td>Latency on Raspi 4 (ms)</td><td>Latency on FPGA (ms)</td></tr><tr><td>Edge GPU</td><td>74.11</td><td>9.96</td><td>31.01</td><td>20.19</td></tr><tr><td>Raspi 4</td><td>73.46</td><td>13.88</td><td>22.91</td><td>15.39</td></tr><tr><td>FPGA</td><td>73.51</td><td>20.65</td><td>25.43</td><td>13.96</td></tr></table>
+
+Benchmark Setting. We adopt a SOTA HW-NAS algorithm, ProxylessNAS (Cai et al., 2018) for this experiment. As an example to use our HW-NAS-Bench, we use ProxylessNAS to search over the FBNet (Wu et al., 2019) search space on CIFAR-100 (Krizhevsky et al., 2009), when targeting different devices in our HW-NAS-Bench by simply querying the corresponding device’s measured/estimated hardware-cost, which has negligible overhead as compared to the HW-NAS algorithm itself, without the need for hardware expertise or knowledge during the whole HW-NAS.
+
+# 5.1 OPTIMAL ARCHITECTURES RESULTING FROM DEVICE-SPECIFIC HW-NAS
+
+Table 5 illustrates that the searched architectures achieve the lowest latency among all architectures when the target devices of HW-NAS are the same as the one used to measure the architecture’s on-device inference latency. Specifically, when being executed on an Edge GPU, the searched architecture targeting Raspi 4 during HW-NAS leads to about a $5 0 \%$ higher latency, while the searched architecture targeting FPGA during HW-NAS introduces over a $1 0 0 \%$ higher latency, than the architecture specifically target on the Edge GPU during HW-NAS, under the same inference accuracy. This set of experiments shows that non-hardware experts can easily use our HW-NAS-Bench to develop optimal HW-NAS solutions, and demonstrates that device-specific HW-NAS is critical to guarantee the searched architectures’ on-device performance.
+
+# 6 CONCLUSION
+
+We have developed HW-NAS-Bench, the first public dataset for HW-NAS research aiming to (1) democratize HW-NAS research to non-hardware experts and (2) facilitate a unified benchmark for HW-NAS to make HW-NAS research more reproducible and accessible. Our HW-NAS-Bench covers two representative NAS search spaces, and provides all network architectures’ hardware-cost data on six commonly used hardware devices that fall into three categories (i.e., commercial edge devices, FPGA, and ASIC). Furthermore, we conduct comprehensive analysis of the collected data in HW-NAS-Bench, aiming to provide insights to not only HW-NAS researchers but also DNN accelerator designers. Finally, we demonstrate exemplary user cases of HW-NAS-Bench to show: (1) how HW-NAS-Bench can be easily used by non-hardware experts via simply querying the collected data to develop HW-NAS solutions and (2) dedicated device-specific HW-NAS can indeed lead to optimal accuracy-cost trade-offs, demonstrating the great necessity of HW-NAS benchmarks like our proposed HW-NAS-Bench. It is expected that our HW-NAS-Benchcan significantly expedite and facilitate HW-NAS research innovations.
+
+# ACKNOWLEDGEMENT
+
+The work is supported by the National Science Foundation (NSF) through the CNS Division of Computer and Network Systems (Award number: 2016727).
+
+# REFERENCES
+
+Mart´ın Abadi, Paul Barham, Jianmin Chen, Zhifeng Chen, Andy Davis, Jeffrey Dean, Matthieu Devin, Sanjay Ghemawat, Geoffrey Irving, Michael Isard, et al. Tensorflow: A system for large-scale machine learning. In 12th {USENIX} symposium on operating systems design and implementation ({OSDI} 16), pp. 265–283, 2016.
+
+Herve Abdi. The kendall rank correlation coefficient. ´ Encyclopedia of Measurement and Statistics. Sage, Thousand Oaks, CA, pp. 508–510, 2007.
+
+Junjie Bai, Fang Lu, Ke Zhang, et al. Onnx: Open neural network exchange. https://github. com/onnx/onnx, 2020.
+
+Samik Basu, Mahasweta Ghosh, and Soma Barman. Raspberry pi $^ { 3 \mathrm { b + } }$ based smart remote health monitoring system using iot platform. In Proceedings of the 2nd International Conference on Communication, Devices and Computing, pp. 473–484. Springer, 2020.
+
+Jacob Benesty, Jingdong Chen, Yiteng Huang, and Israel Cohen. Pearson correlation coefficient. In Noise reduction in speech processing, pp. 1–4. Springer, 2009.
+
+Han Cai, Ligeng Zhu, and Song Han. Proxylessnas: Direct neural architecture search on target task and hardware. arXiv preprint arXiv:1812.00332, 2018.
+
+Thomas Chau, Łukasz Dudziak, Mohamed S Abdelfattah, Royson Lee, Hyeji Kim, and Nicholas D Lane. Brp-nas: Prediction-based nas using gcns. Advances in Neural Information Processing Systems, 2020.
+
+Y. Chen, T. Krishna, J. Emer, and V. Sze. Eyeriss: An energy-efficient reconfigurable accelerator for deep convolutional neural networks. JSSC 2017, 52(1):127–138, 2017.
+
+Yu-Hsin Chen, Joel Emer, and Vivienne Sze. Eyeriss: A spatial architecture for energy-efficient dataflow for convolutional neural networks. ACM SIGARCH Computer Architecture News, 44 (3):367–379, 2016.
+
+Yu-Hsin Chen, Tushar Krishna, Joel Emer, and Vivienne Sze. Eyeriss: An EnergyEfficient Reconfigurable Accelerator for Deep Convolutional Neural Networks. In IEEE International Solid-State Circuits Conference, ISSCC 2016, Digest of Technical Papers, pp. 262–263, 2016.
+
+Franc¸ois Chollet et al. Keras. https://keras.io, 2015.
+
+Patryk Chrabaszcz, Ilya Loshchilov, and Frank Hutter. A downsampled variant of imagenet as an alternative to the cifar datasets. arXiv preprint arXiv:1707.08819, 2017.
+
+Grace Chu, Okan Arikan, Gabriel Bender, Weijun Wang, Achille Brighton, Pieter-Jan Kindermans, Hanxiao Liu, Berkin Akin, Suyog Gupta, and Andrew Howard. Discovering multi-hardware mobile models via architecture search. arXiv preprint arXiv:2008.08178, 2020.
+
+Xuanyi Dong and Yi Yang. Nas-bench-201: Extending the scope of reproducible neural architecture search. In International Conference on Learning Representations (ICLR), 2020. URL https: //openreview.net/forum?id ${ . } = { }$ HJxyZkBKDr.
+
+Xuanyi Dong, Lu Liu, Katarzyna Musial, and Bogdan Gabrys. Nats-bench: Benchmarking nas algorithms for architecture topology and size. arXiv preprint arXiv:2009.00437, 2020.
+
+Yonggan Fu, Wuyang Chen, Haotao Wang, Haoran Li, Yingyan Lin, and Zhangyang Wang. Autogan-distiller: Searching to compress generative adversarial networks. arXiv preprint arXiv:2006.08198, 2020a.
+
+Yonggan Fu, Zhongzhi Yu, Yongan Zhang, and Yingyan Lin. Auto-agent-distiller: Towards efficient deep reinforcement learning agents via neural architecture search, 2020b.
+
+Lukas Geiger and Plumerai Team. Larq: An open-source library for training binarized neural networks. Journal of Open Source Software, 5(45):1746, January 2020. doi: 10.21105/joss.01746. URL https://doi.org/10.21105/joss.01746.
+
+Google LLC. Edge TPU Compiler, a. https://coral.ai/docs/dev-board/ get-started/, accessed 2020-09-01.   
+Google LLC. Edge TPU Code Examples, b. https://coral.ai/examples/ #code-examples, accessed 2019-11-21.   
+Google LLC. Edge TPU Compiler, c. https://coral.ai/docs/edgetpu/compiler/ #system-requirements, accessed 2020-09-01.   
+Google LLC. Edge TPU FAQ, d. https://coral.ai/docs/edgetpu/faq/, accessed 2019-11-21.   
+Google LLC. Pixel 3, e. https://g.co/kgs/pVRc1Y, accessed 2020-09-01.   
+Google LLC. TensorFlow Lite: Deploy machine learning models on mobile and IoT devices, f. https://www.tensorflow.org/lite, accessed 2019-11-21.   
+Google LLC. Tflite python quickstart. https://www.tensorflow.org/lite/guide/ python, 2020.   
+Andrew Howard, Mark Sandler, Grace Chu, Liang-Chieh Chen, Bo Chen, Mingxing Tan, Weijun Wang, Yukun Zhu, Ruoming Pang, Vijay Vasudevan, et al. Searching for mobilenetv3. In Proceedings of the IEEE International Conference on Computer Vision, pp. 1314–1324, 2019.   
+Andrew G Howard, Menglong Zhu, Bo Chen, Dmitry Kalenichenko, Weijun Wang, Tobias Weyand, Marco Andreetto, and Hartwig Adam. Mobilenets: Efficient convolutional neural networks for mobile vision applications. arXiv preprint arXiv:1704.04861, 2017.   
+Nikita Klyuchnikov, Ilya Trofimov, Ekaterina Artemova, Mikhail Salnikov, Maxim Fedorov, and Evgeny Burnaev. Nas-bench-nlp: Neural architecture search benchmark for natural language processing, 2020.   
+Alex Krizhevsky et al. Learning multiple layers of features from tiny images. 2009.   
+Jaeseong Lee, Duseok Kang, and Soonhoi Ha. S3nas: Fast npu-aware neural architecture search methodology. arXiv preprint arXiv:2009.02009, 2020.   
+Chaojian Li, Tianlong Chen, Haoran You, Zhangyang Wang, and Yingyan Lin. Halo: Hardwareaware learning to optimize. In Proceedings of the European Conference on Computer Vision (ECCV), September 2020.   
+Y. Lin, S. Zhang, and N. R. Shanbhag. Variation-tolerant architectures for convolutional neural networks in the near threshold voltage regime. In 2016 IEEE International Workshop on Signal Processing Systems (SiPS), pp. 17–22, 2016. doi: 10.1109/SiPS.2016.11.   
+Y. Lin, C. Sakr, Y. Kim, and N. Shanbhag. Predictivenet: An energy-efficient convolutional neural network via zero prediction. In 2017 IEEE International Symposium on Circuits and Systems (ISCAS), pp. 1–4, 2017. doi: 10.1109/ISCAS.2017.8050797.   
+Hanxiao Liu, Karen Simonyan, and Yiming Yang. Darts: Differentiable architecture search. arXiv preprint arXiv:1806.09055, 2018a.   
+Sicong Liu, Yingyan Lin, Zimu Zhou, Kaiming Nan, Hui Liu, and Junzhao Du. On-demand deep model compression for mobile devices: A usage-driven model selection framework. MobiSys ’18, pp. 389–400. Association for Computing Machinery, 2018b. ISBN 9781450357203.   
+Ningning Ma, Xiangyu Zhang, Hai-Tao Zheng, and Jian Sun. Shufflenet v2: Practical guidelines for efficient cnn architecture design. In Proceedings of the European Conference on Computer Vision (ECCV), pp. 116–131, 2018.   
+Alberto Marchisio, Andrea Massa, Vojtech Mrazek, Beatrice Bussolino, Maurizio Martina, and Muhammad Shafique. Nascaps: A framework for neural architecture search to optimize the accuracy and hardware efficiency of convolutional capsule networks. arXiv preprint arXiv:2008.08476, 2020.
+
+NVIDIA Inc. NVIDIA Jetson TX2, a. https://www.nvidia.com/en-us/ autonomous-machines/embedded-systems/jetson-tx2/, accessed 2020-09-01.
+
+NVIDIA Inc. Tensorrt, b.
+
+NVIDIA Inc. Benchmark tx2 performance in googlenet with tensorrt, c.
+
+Angshuman Parashar, Priyanka Raina, Yakun Sophia Shao, Yu-Hsin Chen, Victor A Ying, Anurag Mukkara, Rangharajan Venkatesan, Brucek Khailany, Stephen W Keckler, and Joel Emer. Timeloop: A systematic approach to dnn accelerator evaluation. In 2019 IEEE international symposium on performance analysis of systems and software (ISPASS), pp. 304–315. IEEE, 2019.
+
+Adam Paszke, Sam Gross, Francisco Massa, Adam Lerer, James Bradbury, Gregory Chanan, Trevor Killeen, Zeming Lin, Natalia Gimelshein, Luca Antiga, et al. Pytorch: An imperative style, highperformance deep learning library. In Advances in neural information processing systems, pp. 8026–8037, 2019.
+
+Patrick Mochel and Mike Murphy. sysfs - The filesystem for exporting kernel objects. https://www.kernel.org/doc/Documentation/filesystems/sysfs. txt, accessed 2019-11-21.
+
+Raspberry Pi Limited. Raspberry 4. https://www.raspberrypi.org/products/ raspberry-pi-4-model-b/, accessed 2020-09-01.
+
+Benjamin Ross. AI at the Edge Enabling a New Generation of Apps, Smart Devices, March 2020. URL https://www.aitrends.com/edge-computing/ ai-at-the-edge-enabling-a-new-generation-of-apps-smart-devices/.
+
+Jianghao Shen, Yue Wang, Pengfei Xu, Yonggan Fu, Zhangyang Wang, and Yingyan Lin. Fractional skipping: Towards finer-grained dynamic cnn inference. 2020.
+
+Yongming Shen, Michael Ferdman, and Peter Milder. Maximizing cnn accelerator efficiency through resource partitioning. In Proceedings of the 44th Annual International Symposium on Computer Architecture, ISCA ’17, pp. 535–547, New York, NY, USA, 2017. Association for Computing Machinery. ISBN 9781450348928. doi: 10.1145/3079856.3080221. URL https://doi.org/10.1145/3079856.3080221.
+
+Mennatullah Siam, Mostafa Gamal, Moemen Abdel-Razek, Senthil Yogamani, Martin Jagersand, and Hong Zhang. A comparative study of real-time semantic segmentation for autonomous driving. In Proceedings of the IEEE conference on computer vision and pattern recognition workshops, pp. 587–597, 2018.
+
+Julien Siems, Lucas Zimmer, Arber Zela, Jovita Lukasik, Margret Keuper, and Frank Hutter. Nasbench-301 and the case for surrogate benchmarks for neural architecture search. arXiv preprint arXiv:2008.09777, 2020.
+
+Dimitrios Stamoulis, Ruizhou Ding, Di Wang, Dimitrios Lymberopoulos, Bodhi Priyantha, Jie Liu, and Diana Marculescu. Single-path nas: Designing hardware-efficient convnets in less than 4 hours. In Joint European Conference on Machine Learning and Knowledge Discovery in Databases, pp. 481–497. Springer, 2019.
+
+Mingxing Tan and Quoc V Le. Efficientnet: Rethinking model scaling for convolutional neural networks. arXiv preprint arXiv:1905.11946, 2019.
+
+Mingxing Tan, Bo Chen, Ruoming Pang, Vijay Vasudevan, Mark Sandler, Andrew Howard, and Quoc V Le. Mnasnet: Platform-aware neural architecture search for mobile. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 2820–2828, 2019.
+
+Texas Instruments Inc. INA3221 Triple-Channel, High-Side Measurement, Shunt and Bus Voltage Monitor. http://www.ti.com/product/INA3221, accessed 2019-11-21.
+
+Alvin Wan, Xiaoliang Dai, Peizhao Zhang, Zijian He, Yuandong Tian, Saining Xie, Bichen Wu, Matthew Yu, Tao Xu, Kan Chen, et al. Fbnetv2: Differentiable neural architecture search for spatial and channel dimensions. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 12965–12974, 2020.
+
+Chien-Yao Wang, Hong-Yuan Mark Liao, Ping-Yang Chen, and Jun-Wei Hsieh. Enriching variety of layer-wise learning information by gradient combination. In Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV) Workshops, Oct 2019a.
+
+Y. Wang, J. Shen, T. K. Hu, P. Xu, T. Nguyen, R. Baraniuk, Z. Wang, and Y. Lin. Dual dynamic inference: Enabling more efficient, adaptive, and controllable deep inference. IEEE Journal of Selected Topics in Signal Processing, 14(4):623–633, 2020a. doi: 10.1109/JSTSP.2020.2979669.
+
+Y. Wang, J. Shen, T. K. Hu, P. Xu, T. Nguyen, R. Baraniuk, Z. Wang, and Y. Lin. Dual dynamic inference: Enabling more efficient, adaptive, and controllable deep inference. IEEE Journal of Selected Topics in Signal Processing, 14(4):623–633, 2020b. doi: 10.1109/JSTSP.2020.2979669.
+
+Yue Wang, Ziyu Jiang, Xiaohan Chen, Pengfei Xu, Yang Zhao, Yingyan Lin, and Zhangyang Wang. E2-Train: Training state-of-the-art cnns with over $80 \%$ energy savings. In Advances in Neural Information Processing Systems, pp. 5139–5151, 2019b.
+
+Diana Wofk, Fangchang Ma, Tien-Ju Yang, Sertac Karaman, and Vivienne Sze. Fastdepth: Fast monocular depth estimation on embedded systems. In 2019 International Conference on Robotics and Automation (ICRA), pp. 6101–6108. IEEE, 2019.
+
+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. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 10734–10742, 2019.
+
+Junru Wu, Yue Wang, Zhenyu Wu, Zhangyang Wang, Ashok Veeraraghavan, and Yingyan Lin. Deep $k$ -means: Re-training and parameter sharing with harder cluster assignments for compressing deep convolutions. arXiv preprint arXiv:1806.09228, 2018.
+
+Yannan N. Wu, Joel S. Emer, and Vivienne Sze. Accelergy: An ArchitectureLevel Energy Estimation Methodology for Accelerator Designs. In IEEE/ACM International Conference On Computer Aided Design (ICCAD), 2019.
+
+Qingcheng Xiao, Yun Liang, Liqiang Lu, Shengen Yan, and Yu-Wing Tai. Exploring heterogeneous algorithms for accelerating deep convolutional neural networks on fpgas. In Proceedings of the 54th Annual Design Automation Conference 2017, DAC ’17, New York, NY, USA, 2017. Association for Computing Machinery. ISBN 9781450349277. doi: 10.1145/3061639.3062244. URL https://doi.org/10.1145/3061639.3062244.
+
+Xilinx Inc. Vivado High-Level Synthesis, a. https://https://www.xilinx.com/ products/design-tools/vivado/integration/esl-design.html, accessed 2019-09-16.
+
+Xilinx Inc. Xilinx zynq-7000 soc zc706 evaluation kit. https://www.xilinx.com/ products/boards-and-kits/ek-z7-zc706-g.html, b. (Accessed on 09/30/2020).
+
+Yunyang Xiong, Hanxiao Liu, Suyog Gupta, Berkin Akin, Gabriel Bender, Pieter-Jan Kindermans, Mingxing Tan, Vikas Singh, and Bo Chen. Mobiledets: Searching for object detection architectures for mobile accelerators. arXiv preprint arXiv:2004.14525, 2020.
+
+Antoine Yang, Pedro M. Esperanc¸a, and Fabio M. Carlucci. Nas evaluation is frustratingly hard. In International Conference on Learning Representations, 2020. URL https://openreview. net/forum?id ${ . } = { }$ HygrdpVKvr.
+
+Xuan Yang, Jing Pu, Blaine Burton Rister, Nikhil Bhagdikar, Stephen Richardson, Shahar Kvatinsky, Jonathan Ragan-Kelley, Ardavan Pedram, and Mark Horowitz. A systematic approach to blocking convolutional neural networks, 2016.
+
+Chris Ying, Aaron Klein, Eric Christiansen, Esteban Real, Kevin Murphy, and Frank Hutter. Nasbench-101: Towards reproducible neural architecture search. In International Conference on Machine Learning, pp. 7105–7114, 2019.
+
+Haoran You, Xiaohan Chen, Yongan Zhang, Chaojian Li, Sicheng Li, Zihao Liu, Zhangyang Wang, and Yingyan Lin. Shiftaddnet: A hardware-inspired deep network. In H. Larochelle, M. Ranzato, R. Hadsell, M. F. Balcan, and H. Lin (eds.), Advances in Neural Information Processing Systems, volume 33, pp. 2771–2783. Curran Associates, Inc., 2020a. URL https://proceedings.neurips.cc/paper/2020/file/ 1cf44d7975e6c86cffa70cae95b5fbb2-Paper.pdf.
+
+Shan You, Tao Huang, Mingmin Yang, Fei Wang, Chen Qian, and Changshui Zhang. Greedynas: Towards fast one-shot nas with greedy supernet. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 1999–2008, 2020b.
+
+Chen Zhang, Peng Li, Guangyu Sun, Yijin Guan, Bingjun Xiao, and Jason Cong. Optimizing fpga-based accelerator design for deep convolutional neural networks. In Proceedings of the 2015 ACM/SIGDA International Symposium on Field-Programmable Gate Arrays, FPGA ’15, pp. 161–170, New York, NY, USA, 2015. Association for Computing Machinery. ISBN 9781450333153. doi: 10.1145/2684746.2689060. URL https://doi.org/10.1145/ 2684746.2689060.
+
+Jianhao Zhang, Yingwei Pan, Ting Yao, He Zhao, and Tao Mei. dabnn: A super fast inference framework for binary neural networks on arm devices. In Proceedings of the 27th ACM International Conference on Multimedia, pp. 2272–2275, 2019.
+
+Xiaofan Zhang, Junsong Wang, Chao Zhu, Yonghua Lin, Jinjun Xiong, Wen-mei Hwu, and Deming Chen. Dnnbuilder: An automated tool for building high-performance dnn hardware accelerators for fpgas. In Proceedings of the International Conference on Computer-Aided Design, ICCAD ’18, New York, NY, USA, 2018. Association for Computing Machinery. ISBN 9781450359504. doi: 10.1145/3240765.3240801. URL https://doi.org/10.1145/ 3240765.3240801.
+
+Yongan Zhang, Yonggan Fu, Weiwen Jiang, Chaojian Li, Haoran You, Meng Li, Vikas Chandra, and Yingyan Lin. Dna: Differentiable network-accelerator co-search, 2020.
+
+Cheah Wai Zhao, Jayanand Jegatheesan, and Son Chee Loon. Exploring iot application using raspberry pi. International Journal of Computer Networks and Applications, 2(1):27–34, 2015.
+
+Y. Zhao, X. Chen, Y. Wang, C. Li, H. You, Y. Fu, Y. Xie, Z. Wang, and Y. Lin. Smartexchange: Trading higher-cost memory storage/access for lower-cost computation. In 2020 ACM/IEEE 47th Annual International Symposium on Computer Architecture (ISCA), pp. 954–967, 2020a. doi: 10.1109/ISCA45697.2020.00082.
+
+Y. Zhao, C. Li, Y. Wang, P. Xu, Y. Zhang, and Y. Lin. Dnn-chip predictor: An analytical performance predictor for dnn accelerators with various dataflows and hardware architectures. In ICASSP 2020 - 2020 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 1593–1597, 2020b.
+
+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 MORE VISUALIZATION ON THE MEASURED HARDWARE-COST FOR THE FBNET SEARCH SPACE
+
+![](images/4b695456533a81e50c852133d9774fcb4a24bb440bfadf5dfd7a190adeac408f.jpg)  
+Figure 6: Comparison between the approximated and measured hardware-cost on CIFAR-100 (Top) and ImageNet (Bottom), where the red line indicates the fitting line for all the measured data, and $R ^ { 2 }$ represents the square of the Pearson Correlation Coefficient (Benesty et al., 2009).
+
+Fig. 6 shows a comparison between the approximated and measured hardware-cost of randomly sampled 100 architectures when being executed on commercial edge devices using the ImageNet and CIFAR-100 datasets, which verifies that our approximation of summing up the performance of the unique blocks is a simple yet quite accurate for providing the hardware-cost for networks in the FBNet space and is consistent with our observation in Table 2.
+
+# B COMPARING THE ESTIMATED COST EXECUTED ON EYERISS USING ACCELERGY $^ +$ TIMELOOP AND DNN-CHIP REDICTOR
+
+Both Accelergy (Wu et al., 2019) $+$ Timeloop (Parashar et al., 2019) and DNN-Chip Predictor (Zhao et al., 2020b) are able to simulate the latency and energy cost of Eyeriss (Chen et al., 2016), a SOTA ASIC DNN accelerator, when giving the network architectures. From Table 6, they nearly give the same estimation for the latency and energy cost: specifically, the mean of their differences is $6 . 0 9 6 \%$ , the standard deviation of the differences is $0 . 7 7 9 \%$ , the Pearson correlation coefficient is 0.9998, and the Kendall Rank correlation coefficient is 0.9633, in term of the average performance, when being benchmarked with NAS-Bench-201 on 3 datasets. Therefore, we use the average value of their predictions as the estimated latency and energy on Eyeriss in our proposed HW-NAS-Bench.
+
+Table 6: The differences of the hardware-cost estimation given by Accelergy (Wu et al., 2019) $+$ Timeloop (Parashar et al., 2019) and DNN-Chip Predictor (Zhao et al., 2020b), considering NAS-Bench-201 on 3 datasets.   
+
+<table><tr><td>Datasets</td><td>Hardware-cost</td><td>Mean of Differences</td><td>Standard Deviation ofI Differences</td><td>Pearson Correlation Coefficient</td><td>Kendall Rank Correlation Coefficient</td></tr><tr><td rowspan="2">CIFAR-10</td><td>Latency</td><td>1.648%</td><td>0.642%</td><td>0.9999</td><td>0.9888</td></tr><tr><td>Energy</td><td>10.96%</td><td>1.035%</td><td>0.9997</td><td>0.9374</td></tr><tr><td rowspan="2">CIFAR-100</td><td>Latency</td><td>1.572%</td><td>0.611%</td><td>1.0000</td><td>0.9888</td></tr><tr><td>Energy</td><td>10.93%</td><td>1.029%</td><td>0.9997</td><td>0.9374</td></tr><tr><td rowspan="2">ImageNet16-120</td><td>Latency</td><td>1.338%</td><td>0.520%</td><td>0.9999</td><td>0.9888</td></tr><tr><td>Energy</td><td>10.13%</td><td>0.840%</td><td>0.9998</td><td>0.9388</td></tr><tr><td colspan="2">Average Performance</td><td>6.096%</td><td>0.779%</td><td>0.9998</td><td>0.9633</td></tr></table>
+
+Table 7: Left: the marco-architectures of the search space proposed in the FBNet (Wu et al., 2019) for the ImageNet classification; Right: our modified search space to fit the input image size of the CIFAR-100 dataset. In the tables, “TBS” means the layer type needs to be searched and “Stride” denotes the stride of the first block in the stage. Here the modified parameters are emphasized as bold characters.   
+
+<table><tr><td rowspan=1 colspan=1>Input Shape</td><td rowspan=1 colspan=1>Block</td><td rowspan=1 colspan=1>Filter#</td><td rowspan=1 colspan=1>Block#</td><td rowspan=1 colspan=1>Stride</td></tr><tr><td rowspan=1 colspan=1>224²×3</td><td rowspan=1 colspan=1>3 × 3conv</td><td rowspan=1 colspan=1>16</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>2</td></tr><tr><td rowspan=1 colspan=1>112²× 16</td><td rowspan=1 colspan=1>TBS</td><td rowspan=1 colspan=1>16</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td></tr><tr><td rowspan=1 colspan=1>112²×16</td><td rowspan=1 colspan=1>TBS</td><td rowspan=1 colspan=1>24</td><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1>2</td></tr><tr><td rowspan=1 colspan=1>56²×24</td><td rowspan=1 colspan=1>TBS</td><td rowspan=1 colspan=1>32</td><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1>2</td></tr><tr><td rowspan=1 colspan=1>28²×32</td><td rowspan=1 colspan=1>TBS</td><td rowspan=1 colspan=1>64</td><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1>2</td></tr><tr><td rowspan=1 colspan=1>14²×64</td><td rowspan=1 colspan=1>TBS</td><td rowspan=1 colspan=1>112</td><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1>1</td></tr><tr><td rowspan=1 colspan=1>14² × 112</td><td rowspan=1 colspan=1>TBS</td><td rowspan=1 colspan=1>184</td><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1>2</td></tr><tr><td rowspan=1 colspan=1>7²×184</td><td rowspan=1 colspan=1>TBS</td><td rowspan=1 colspan=1>352</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td></tr><tr><td rowspan=3 colspan=1>7²×3527²×19841504</td><td rowspan=1 colspan=1>1 ×1conv</td><td rowspan=1 colspan=1>1984</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td></tr><tr><td rowspan=1 colspan=1>7×7avgpool</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>1</td><td rowspan=2 colspan=1>1=</td></tr><tr><td rowspan=1 colspan=1>fc</td><td rowspan=1 colspan=1>1000</td><td rowspan=1 colspan=1>1</td></tr></table>
+
+<table><tr><td rowspan=1 colspan=1>Input Shape</td><td rowspan=1 colspan=1>Block</td><td rowspan=1 colspan=1>Filter#</td><td rowspan=1 colspan=1>Block#</td><td rowspan=1 colspan=1>Stride</td></tr><tr><td rowspan=1 colspan=1>32²×3</td><td rowspan=1 colspan=1>3×3conv</td><td rowspan=1 colspan=1>16</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td></tr><tr><td rowspan=1 colspan=1>32²×16</td><td rowspan=1 colspan=1>TBS</td><td rowspan=1 colspan=1>16</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td></tr><tr><td rowspan=1 colspan=1>32²×16</td><td rowspan=1 colspan=1>TBS</td><td rowspan=1 colspan=1>24</td><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1>1</td></tr><tr><td rowspan=1 colspan=1>32²×24</td><td rowspan=1 colspan=1>TBS</td><td rowspan=1 colspan=1>32</td><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1>2</td></tr><tr><td rowspan=1 colspan=1>16²×32</td><td rowspan=1 colspan=1>TBS</td><td rowspan=1 colspan=1>64</td><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1>2</td></tr><tr><td rowspan=1 colspan=1>8²×64</td><td rowspan=1 colspan=1>TBS</td><td rowspan=1 colspan=1>112</td><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1>1</td></tr><tr><td rowspan=1 colspan=1>8²×112</td><td rowspan=1 colspan=1>TBS</td><td rowspan=1 colspan=1>184</td><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1>2</td></tr><tr><td rowspan=1 colspan=1>4²×184</td><td rowspan=1 colspan=1>TBS</td><td rowspan=1 colspan=1>352</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td></tr><tr><td rowspan=3 colspan=1>4²×3524²×15041504</td><td rowspan=1 colspan=1>1 ×1 conv</td><td rowspan=1 colspan=1>1504</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td></tr><tr><td rowspan=2 colspan=1>4×4avgpoolfc</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td></tr><tr><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>=</td></tr></table>
+
+# C MINOR MODIFICATIONS ON THE FBNET SEARCH SPACE WHEN BENCHMARKING ON CIFAR-100
+
+Here we describe our modification on the FBNet search space when benchmarking on CIFAR-100 (i.e., the setting in Section 5) by comparing the marco-architectures before and after such modification in Table 7.
+
+# D DETAILS OF THE PIPELINE USED TO COLLECT HARDWARE-COST DATA
+
+# D.1 COLLECT PERFORMANCE ON THE EDGE GPU
+
+NVIDIA Edge GPU Jetson TX2 (Edge GPU) (NVIDIA Inc., a) is a commonly used commercial edge device, consisting of a quad-core Arm Cortex-A57, a dual-core NVIDIA Denver2, a 256-core Pascal GPU, and a 8GB 128-bit LPDDR4, for various deep learning applications including classification (Li et al., 2020), segmentation (Siam et al., 2018), and depth estimation (Wofk et al., 2019), targeting IoT, and self-driving environments. Although widely-used TensorFlow (Abadi et al., 2016) and PyTorch (Paszke et al., 2019) can be directly used in Edge GPUs, to achieve faster inference, TensorRT (NVIDIA Inc., b), a $\mathrm { C } { + } { + }$ library for high-performance inference on NVIDIA GPUs, is more commonly used as the runtime environment in Edge GPUs when only benchmarking inference performance (Wang et al., 2019a; NVIDIA Inc., c).
+
+We pre-set the Edge GPU to the max-N mode to make full use of the resource on it following (Wofk et al., 2019). When plugging Edge GPUs into the hardware-cost collection pipeline, we first compile the PyTorch implementations of the network architectures in both NAS-Bench-201 and FBNet search spaces to TensorRT format models. In this way, the resulting hardware-cost can benefit from the optimized inference implementation within the TensorRF runtime environment. And then we benchmark the architectures in Edge GPUs to further measure the energy and latency using the sysfs (Patrick Mochel and Mike Murphy.) of the embedded INA3221 (Texas Instruments Inc.) power rails monitor.
+
+# D.2 COLLECT PERFORMANCE ON RASPI 4
+
+Raspberry Pi 4 (Raspi 4) (Raspberry Pi Limited.) is the latest Raspberry Pi device, which is a popular hardware platform for general purpose IoT applications (Zhao et al., 2015; Basu et al., 2020) and is able to support deep learning applications with specifical framework designs (Google LLC., f; Zhang et al., 2019; Geiger & Team, 2020). We choose the type of Raspi 4 with a Broadcom BCM2711 SoC and a 4GB LPDDR4 (Raspberry Pi Limited.). Similar to Edge GPUs, Raspi 4 can run architectures in the TensorFlow (Abadi et al., 2016), PyTorch (Paszke et al., 2019), or TensorFlow Lite (Google LLC., f) runtime environments. We utilize TensorFlow Lite (Google LLC., f) as it can further boost the inference efficiency.
+
+To collect hardware-cost operating on Respi 4, an official TensorFlow Lite interpreter is preconfigured in the Raspi 4, following the settings in (Google LLC., 2020). We benchmark the possible architectures in HW-NAS-Bench on Raspi 4 after compiling them to the TensorFlow Lite (Abadi et al., 2016) format to measure the resulting latency.
+
+# D.3 COLLECT PERFORMANCE ON THE EDGE TPU
+
+Edge TPU (Google LLC., a) is a series of dedicated ASIC accelerators developed by Google, targeting AI inference at the edge, which can be used for classification, pose estimation, and segmentation (Xiong et al., 2020; Google LLC., b) with extremely high efficiency (e.g., $2 . 3 2 \times$ more efficient than a single SOTA desktop GPU, GTX 2080 Ti, in terms of the number of fixed-point operations per watt (Google LLC., d)). In our proposed collection pipeline, we choose the Dev Board (Google LLC., a) which provides the most functions among all products.
+
+To collect hardware-cost in Edge TPUs, all the architectures to be benchmarked will first be converted to the TensorFlow Lite (Google LLC., f) format from their Keras (Chollet et al., 2015) implementation. After that, an in-house compiler (Google LLC., c) will be used to convert the TensorFlow Lite models into a more compressed format. This pipeline uses the least converting tools to make sure that the most operations are supported, as compared to other options (e.g., converting from the PyTorch-ONNX (Bai et al., 2020) implementation). Only the latency is collected on the Edge TPU since it lacks accurate embedded power rails monitor. We do not consider the FBNet’s search space for the Edge TPU, and more details are in the Appendix A.
+
+# D.4 COLLECT PERFORMANCE ON PIXEL 3
+
+Pixel 3 (Google LLC., e) is one of the latest Pixel mobile phones that are widely used as the target platform by recent NAS works (Xiong et al., 2020; Howard et al., 2019; Tan et al., 2019) and machine learning framework benchmark (Google LLC., f). In our implementation, the Pixel 3 is pre-configured to use its big cores following the setting in (Xiong et al., 2020; Tan et al., 2019). Similar to the case of Raspi 4, we first convert the possible architectures in the search spaces of our proposed HW-NAS-Bench into the TensorFlow Lite format and then use the official benchmark binary files to measure the latency for each architecture.
+
+# D.5 COLLECT PERFORMANCE ON ASIC-EYERISS
+
+For hardware-cost data collection in ASIC, we consider Eyeriss (ASIC-Eyeriss) which is a SOTA ASIC accelerator (Chen et al., 2016). The Eyeriss chip features 168 processing elements (PEs) which are connected through a configurable dedicated on-chip network into a 2D array. A 128KB SRAM is shared by all PEs and further divided into multiple banks, each of which can be assigned to fit the input feature maps or partial sums. Thanks to these configurable hardware settings, we can adopt the optimal algorithm-to-hardware mappings for different network architectures when being executed on Eyeriss to minimize the energy or latency by maximizing data reuse opportunities for different layers.
+
+In order to find the optimal mappings and evaluate the performance metrics on Eyeriss, we adopt SOTA performance simulators for DNN accelerators (1) Accelergy (Wu et al., 2019) $+$ Timeloop (Parashar et al., 2019) and (2) DNN-Chip Predictor (Zhao et al., 2020b). Both of the simulators can characterize the Eyeriss’s micro-architecture, perform mapping exploration, and predict the energy cost and latency metrics. Given the Eyeriss accelerator and layer information (e.g, layer type, feature map size, and kernel size) in both NAS-Bench-201 and FBNet, Accelergy+Timeloop reports the energy cost and latency characterization through an integrated mapper that finds the optimal mapping for such layer when being executed in Eyeriss. The inputs to DNNChip Predictor are the same as those to Accelergy $^ +$ Timeloop, except that we can set the optimization metric as energy/latency/energy-delay product. DNN-Chip Predictor identifies the optimal mapping for the optimization metric and generates the estimated hardware-cost. We report the average prediction from the two simulators as the estimated hardware-cost of Eyeriss, and more details can be found in Appendix B.
+
+Table 8: Our implemented FPGA accelerators for HW-NAS-Bench vs. SOTA FPGA accelerators, considering VGG16 on the ImageNet dataset and using Zynq XC70Z45 as the FPGA device.   
+
+<table><tr><td></td><td>I (Zhang et al., 2018)</td><td>(Xiao et al.,2017)</td><td>Our Implementation</td></tr><tr><td>Resource Utilization</td><td>680/900 DSP</td><td>824/900 DSP</td><td>723/900 DSP</td></tr><tr><td>Performance (GOP/s)</td><td>262</td><td>230</td><td>291</td></tr></table>
+
+# D.6 COLLECT PERFORMANCE ON FPGA
+
+FPGA is a widely adopted AI acceleration platform which can offer a higher flexibility in terms of the hardware resources for accelerating AI algorithms. For collecting hardware-cost data in FPGA, we construct a SOTA chunk based pipeline structure (Zhang et al., 2018; Shen et al., 2017) as our FPGA implementation. By configuring multiple sub-accelerators (chunks) and assigning different layers to different sub-accelerators(chunks), we can balance the throughput and hardware resource consumption. To further free up our implantation’s potential to reach the performance frontier across different architectures, we additionally configure hardware settings such as the number of PEs, interconnection method of PEs, and tiling/scheduling of the operations, which are commonly adopted by FPGA accelerators (Chen et al., 2017; Zhang et al., 2015; Yang et al., 2016). We then compile all the architectures using the standard Vivado HLS toolflow (Xilinx Inc., a) and obtain the bottleneck latency, the maximum latency across all sub-accelerators (chunks) of the architectures on a Xilinx ZC706 development board with Zynq XC7045 SoC (Xilinx Inc., b).
+
+To verify our implementation, we compare our implementation’s performance with SOTA FPGA accelerators (Zhang et al., 2018; Xiao et al., 2017) given the same architecture and dataset as shown in Table 8. We can see that our implementation achieves SOTA performance and thus provides insightful and trusted hardware-cost estimation for the HW-NAS-Bench.