Add files using upload-large-folder tool

parse/train/B1e-kxSKDH/B1e-kxSKDH.md

@@ -0,0 +1,352 @@
+# STRUCTURED OBJECT-AWARE PHYSICS PREDICTION FOR VIDEO MODELING AND PLANNING
+
+Jannik Kossen∗1, Karl Stelzner∗2, Marcel Hussing3, Claas Voelcker3 & Kristian Kersting2
+
+1Department of Physics and Astronomy, Heidelberg University   
+1kossen@stud.uni-heidelberg.de   
+2,3Department of Computer Science, TU Darmstadt   
+2{stelzner,kersting}@cs.tu-darmstadt.de   
+3{marcel.hussing,c.voelcker}@stud.tu-darmstadt.de
+
+# ABSTRACT
+
+When humans observe a physical system, they can easily locate objects, understand their interactions, and anticipate future behavior. For computers, however, learning such models from videos in an unsupervised fashion is an unsolved research problem. In this paper, we present STOVE, a novel state-space model for videos, which explicitly reasons about objects and their positions, velocities, and interactions. It is constructed by combining an image model and a dynamics model in compositional manner and improves on previous work by reusing the dynamics model for inference, accelerating and regularizing training. STOVE predicts videos with convincing physical behavior over thousands of timesteps, outperforms previous unsupervised models, and even approaches the performance of supervised baselines. We further demonstrate the strength of our model as a simulator for sample efficient model-based control in a task with heavily interacting objects.
+
+# 1 INTRODUCTION
+
+Obtaining structured knowledge about the world from unstructured, noisy sensory input is a key challenge in artificial intelligence. Of particular interest is the problem of identifying objects from visual input and understanding their interactions. One longstanding approach to this is the idea of vision as inverse graphics (Grenander, 1976), which postulates a data generating graphics process and phrases vision as posterior inference in the induced distribution. Despite its intuitive appeal, vision as inference has remained largely intractable in practice due to the high-dimensional and multimodal nature of the inference problem. Recently, however, probabilistic models based on deep neural networks have made promising advances in this area. By composing conditional distributions parameterized by neural networks, highly expressive yet structured models have been built. At the same time, advances in general approximate inference, particularly variational techniques, have put the inference problem for these models within reach (Zhang et al., 2019).
+
+Based on these advances, a number of probabilistic models for unsupervised scene understanding in single images have recently been proposed. The structured nature of approaches such as AIR (Eslami et al., 2016), MONet (Burgess et al., 2019), or IODINE (Greff et al., 2019) provides two key advantages over unstructured image models such as variational autoencoders (Kingma & Welling, 2014) or generative adversarial networks (Goodfellow et al., 2014). First, it allows for the specification of inductive biases, such as spatial consistency of objects, which constrain the model and act as regularization. Second, it enables the use of semantically meaningful latent variables, such as object positions, which may be used for downstream reasoning tasks.
+
+Building such a structured model for videos instead of individual images is the natural next challenge. Not only could such a model be used in more complex domains, such as reinforcement learning, but the additional redundancy in the data can even simplify and regularize the object detection problem (Kosiorek et al., 2018). To this end, the notion of temporal consistency may be leveraged as an additional inductive bias, guiding the model to desirable behavior. In situations where interactions between objects are prevalent, understanding and explicitly modeling these interactions in an object-centric state-space is valuable for obtaining good predictive models (Watters et al., 2017). Existing works in this area, such as SQAIR (Kosiorek et al., 2018), DDPAE (Hsieh et al., 2018), RNEM (Van Steenkiste et al., 2018), and COBRA (Watters et al., 2019) have explored these concepts, but have not demonstrated realistic long term video predictions on par with supervised approaches to modeling physics.
+
+![](images/2ef8e304dfc542a2ba7cd93d8941d7ed8d310ac2b8e63f2fd5c4cc71e55a5b83.jpg)  
+Figure 1: Overview of STOVE’s architecture. (Center left) At time $t$ , the input image $x _ { t }$ is processed by an LSTM in order to obtain a proposal distribution over object states $q ( \boldsymbol { z } _ { t } \mid \boldsymbol { x } _ { t } )$ . (Top) A separate proposal $q \big ( z _ { t } \mid z _ { t - 1 } \big )$ is obtained by propagating the previous state $z _ { t - 1 }$ using the dynamics model. (Center) The multiplication of both proposal distributions yields the final variational distribution $q ( z _ { t } \mid z _ { t - 1 } , x _ { t } )$ . (Right) We sample $z _ { t }$ from this distribution to evaluate the generative distribution $p ( z _ { t } \mid z _ { t - 1 } ) p ( x _ { t } \mid z _ { t } )$ , where $p \big ( z _ { t } \mid z _ { t - 1 } \big )$ shares means – but not variances – with $q \big ( z _ { t } \mid z _ { t - 1 } \big )$ , and $p ( x _ { t } \mid z _ { t } )$ can be obtained by direct evaluation of $x _ { t }$ in the sum-product networks. Not shown is the dependence on $x _ { t - 1 }$ in the inference routine which allows for the inference of velocities. (Best viewed in color.)
+
+To push the limits of unsupervised learning of physical interactions, we propose STOVE, a structured, object-aware video model. With STOVE, we combine image and physics modeling into a single state-space modelwhich explicitly reasons about object positions and velocities. It is trained end-to-end on pure video data in a self-supervised fashion and learns to detect objects, to model their interactions, and to predict future states and observations. To facilitate learning via variational inference in this model, we provide a novel inference architecture, which reuses the learned generative physics model in the variational distribution. As we will demonstrate, our model generates convincing rollouts over hundreds of time steps, outperforms other video modeling approaches, and approaches the performance of the supervised baseline which has access to the ground truth object states.
+
+Moving beyond unsupervised learning, we also demonstrate how STOVE can be employed for model-based reinforcement learning (RL). Model-based approaches to RL have long been viewed as a potential remedy to the often prohibitive sample complexity of model-free RL, but obtaining learned models of sufficient quality has proven difficult in practice (Sutton & Barto, 2011). By conditioning state predictions on actions and adding reward predictions to our dynamics predictor, we extend our model to the RL setting, allowing it to be used for search or planning. Our empirical evidence shows that an actor based on Monte-Carlo tree search (MCTS) (Coulom, 2007) on top of our model is competitive to model-free approaches such as Proximal Policy Optimization (PPO) (Schulman et al., 2017), while only requiring a fraction of the samples.
+
+![](images/6b317b9f721623f24eca24e93a98e12367a65fe2bbfd5f283319deb9d74f9ba5.jpg)  
+Figure 2: (Left) Depiction of the graphical model underlying STOVE. Black arrows denote the generative mechanism and red arrows the inference procedure. The variational distribution $q ( z _ { t } \mid z _ { t - 1 } , x _ { t } , x _ { t - 1 } )$ is formed by combining predictions from the dynamics model $p \big ( z _ { t } \mid z _ { t - 1 } \big )$ and the object detection network $q \dot { ( \boldsymbol { z } _ { t } \mid \boldsymbol { x } _ { t } ) }$ . For the RL domain, our approach is extended by action conditioning and reward prediction. (Right) Components of $z _ { t } ^ { o }$ and corresponding variational distributions. Note that the velocities are estimated based on the change in positions between timesteps, inducing a dependency on $x _ { t - 1 }$ .
+
+We proceed by introducing the two main components of STOVE: a structured image model and a dynamics model. We show how to perform joint inference and training, as well as how to extend the model to the RL setting. We then present our experimental evaluation, before touching on further related work and concluding.
+
+# 2 STRUCTURED OBJECT-AWARE VIDEO MODELING
+
+We approach the task of modeling a video with frames $x _ { 1 } , \ldots , x _ { T }$ from a probabilistic perspective, assuming a sequence of Markovian latent states $z _ { 1 } , \dots , z _ { T }$ , which decompose into the properties of a fixed number $O$ of objects, i.e. $\boldsymbol { z } _ { t } = ( z _ { t } ^ { 1 } , \ldots , z _ { t } ^ { O } )$ . In the spirit of compositionality, we propose to specify and train such a model by explicitly combining a dynamics prediction model $p ( z _ { t + 1 } \mid z _ { t } )$ and a scene model $p ( x _ { t } \mid z _ { t } )$ . This yields a state-space model, which can be trained on pure video data, using variational inference and an approximate posterior distribution $q ( z \mid x )$ . Our model differs from previous work that also follows this methodology, most notably SQAIR and DDPAE, in three major ways:
+
+• We propose a more compact architecture for the variational distribution $q ( z \mid x )$ , which reuses the dynamics model $p ( z _ { t + 1 } \mid z _ { t } )$ , and avoids the costly double recurrence across time and objects which was present in previous work. We parameterize the dynamics model using a graph neural network, taking advantage of the decomposed nature of the latent state $z$ .   
+• Instead of treating each $z _ { t } ^ { o }$ as an arbitrary latent code, we explicitly reserve the first six slots of this vector for the object’s position, size, and velocity, each in $x , y$ direction, and use this information for the dynamics prediction task. We write $z _ { t } ^ { o } = ( z _ { t , \mathrm { p o s } } ^ { o } , z _ { t , \mathrm { s i z e } } ^ { o } , z _ { t , \mathrm { v e l o } } ^ { o } , z _ { t , \mathrm { l a t e n t } } ^ { o } )$ .
+
+We begin by briefly introducing the individual components before discussing how they are combined to form our state-space model. Fig. 1 visualises the computational flow of STOVE’s inference and generative routines, Fig. 2 (left) specifies the underlying graphical model.
+
+2.1 OBJECT-BASED MODELING OF IMAGES USING SUM-PRODUCT ATTEND-INFER-REPEAT
+
+A variety of object-centric image models have recently been proposed, many of which are derivatives of attend-infer-repeat (AIR) (Eslami et al., 2016). AIR postulates that each image consists of a set of $z _ { \mathrm { w h e r e } } ^ { o } = ( z _ { \mathrm { p o s } } ^ { o } , z _ { \mathrm { s i z e } } ^ { o } )$ h occupies a rectangular region in the image, specified by positional . The visual content of each object is described by a latent code ${ z _ { \mathrm { w h a t } } ^ { o } }$ eters. By decoding zowhat with a neural network and rendering the resulting image patches in the prescribed location, a generative model $p ( x \mid z )$ is obtained. Inference is accomplished using a recurrent neural network, which outputs distributions over the latent objects $q ( z ^ { o } \mid { \bar { x } } )$ , attending to one object at a time. AIR is also capable of handling varying numbers of objects, using an additional set of latent variables.
+
+Sum-Product Attend-Infer-Repeat (SuPAIR) (Stelzner et al., 2019) utilizes sum-product networks (SPNs) instead of a decoder network to directly model the distribution over object appearances. The tractable inference capabilities of the SPNs used in SuPAIR allow for the exact and efficient computation of $p ( x \mid z _ { \mathrm { w h e r e } } )$ , effectively integrating out the appearance parameters ${ \mathcal { Z } } _ { \mathrm { W h a t } }$ analytically. This has been shown to drastically accelerate learning, as the reduced inference workload significantly lowers the variance of the variational objective. Since the focus of SuPAIR on interpretable object parameters fits our goal of building a structured video model, we apply it as our image model $p ( x _ { t } \mid z _ { t } )$ . Similarly, we use a recurrent inference network as in SuPAIR to model $q ( z _ { t , \mathrm { w h e r e } } \mid x _ { t } )$ . For details on SuPAIR, we refer to Stelzner et al. (2019).
+
+# .2 MODELING PHYSICAL INTERACTIONS USING GRAPH NEURAL NETWORK
+
+In order to successfully capture complex dynamics, the state transition distribution $p ( z _ { t + 1 } \mid z _ { t } ) =$ $p ( z _ { t + 1 } ^ { 1 } , \ldots , z _ { t + 1 } ^ { O } \mid z _ { t } ^ { 1 } , \ldots , \overline { { z _ { t } ^ { O } } } )$ . . . , z Ot ) needs to be parameterized using a flexible, non-linear estimator. A critical property that should be maintained in the process is permutation invariance, i.e., the output should not depend on the order in which objects appear in the vector $z _ { t }$ . This type of function is well captured by graph neural networks, cf. (Santoro et al., 2017), which posit that the output should depend on the sum of pairwise interactions between objects. Graph neural networks have been extensively used for modeling physical processes in supervised scenarios (Battaglia et al., 2016; 2018; Sanchez-Gonzalez et al., 2018; Zhou et al., 2018).
+
+Following this line of work, we build a dynamics model of the basic form
+
+$$
+\hat { z } _ { t + 1 , \mathrm { p o s } } ^ { o } , \hat { z } _ { t + 1 , \mathrm { v e l o } } ^ { o } , \hat { z } _ { t + 1 , \mathrm { l a t e n t } } ^ { o } = f \left( g ( z _ { t } ^ { o } ) + \sum _ { o ^ { \prime } \neq o } \alpha ( z _ { t } ^ { o } , z _ { t } ^ { o ^ { \prime } } ) h ( z _ { t } ^ { o } , z _ { t } ^ { o ^ { \prime } } ) \right)
+$$
+
+where $f , g , h , \alpha$ represent functions parameterized by dense neural networks. $\alpha$ is an attention mechconstant prior over the objthen given by the Gaussian $\hat { z } _ { t + 1 , \mathrm { s i z e } } ^ { o } = z _ { t , \mathrm { s i z e } } ^ { o }$ . The fullng a fixed tate transition distribution is. $p ( z _ { t + 1 } ^ { o } \mid z _ { t } ^ { o } ) = \mathcal { N } ( \hat { z } _ { t + 1 } ^ { o } , \sigma )$ $\sigma$
+
+# 2.3 JOINT STATE-SPACE MODEL
+
+Next, we assemble a state-space model from the two separate models for image modeling and physics prediction. The interface between the two components are the latent positions and velocities. The scene model infers them from images and the physics model propagates them forward in time. Combining the two yields the state-space model $\begin{array} { r } { \bar { p ( x , z ) } = p ( z _ { 0 } ) \bar { p } ( \bar { x _ { 0 } } \mid z _ { 0 } ) \prod _ { t } p ( z _ { t } \mid z _ { t - 1 } ) p ( x _ { t } \mid } \end{array}$ $z _ { t } )$ . To initialize the state, we model $p ( z _ { 0 } , z _ { 1 } )$ using simple uniform and Gaussian distributions. Details are given in Appendix C.3.
+
+Our model is trained on given video sequences $x$ by maximizing the evidence lower bound (ELBO) $\mathbb { E } _ { q ( z | x ) } \left[ \log p ( x , z ) - \log \bar { q } ( z \mid x ) \right]$ . This requires formulating a variational distribution $q ( z \mid x )$ to approximate the true posterior $p ( z \mid x )$ . A natural approach is to factorize this distribution over time, i.e. $q ( z \mid x ) = q ( z _ { 0 } \mid x _ { 0 } ) \prod _ { t } q ( z _ { t } \mid z _ { t - 1 } , x _ { t } )$ , resembling a Bayesian filter. The distribution $q ( z _ { 0 } \mid x _ { 0 } )$ is then readily available using the inference network provided by SuPAIR.
+
+The formulation of $q ( z _ { t } \mid z _ { t - 1 } , x _ { t } )$ , however, is an important design decision. Previous work, including SQAIR and DDPAE, have chosen to unroll this distribution over objects, introducing a costly double recurrence over time and objects, requiring $T \cdot O$ sequential recurrence steps in total. This increases the variance of the gradient estimate, slows down training, and hampers scalability. Inspired by Becker-Ehmck et al. (2019), we avoid this cost by reusing the dynamics model for the variational distribution. First, we construct the variational distribution $\bar { q } ( z _ { t , \mathrm { p o s } } ^ { o } \mid z _ { t - 1 } ^ { o } )$ by slightly adjusting the dynamics prediction $p \big ( z _ { t , \mathrm { p o s } } ^ { o } \mid z _ { t - 1 } ^ { o } \big )$ , using the same mean values but separately predicted standard deviations. Together with an estimate for the same object by the object detection network $q \big ( z _ { t , \mathrm { p o s } } ^ { o } \ | \ x _ { t } \big )$ , we construct a joint estimate by multiplying the two Gaussians and renormalizing, yielding another Gaussian:
+
+![](images/5c77c7a2ec0b5021b739736fa4d198a679dbea0afec150d7fb269487cacd7509.jpg)  
+Figure 3: Visualisation of object positions from the real environment and predictions made by our model, SQAIR, and the supervised baseline, for the billiards and gravity environment after the first 8 frames were given. Our model achieves realistic behaviour, outperforms the unsupervised baselines, and approaches the quality of the supervised baseline, despite being fully unsupervised. For full effect, the reader is encouraged to watch animated versions of the sequences in repository github.com/jlko/STOVE. (Best viewed in color.)
+
+$$
+q ( z _ { t , \mathrm { p o s } } ^ { o } \mid z _ { t - 1 } , x _ { t } ) \propto q ( z _ { t , \mathrm { p o s } } ^ { o } \mid z _ { t - 1 } ) \cdot q ( z _ { t , \mathrm { p o s } } ^ { o } \mid x _ { t } ) .
+$$
+
+Intuitively, this results in a distribution which reconciles the two proposals. A double recurrence is avoided since $q ( \boldsymbol { z } _ { t } \ | \ \boldsymbol { x } _ { t } )$ does not depend on previous timesteps and may thus be computed in parallel for all frames. Similarly, $q \big ( z _ { t } \mid z _ { t - 1 } \big )$ may be computed in parallel for all objects, leading to only $T + O$ sequential recurrence steps total. An additional benefit of this approach is that the information learned by the dynamics network is reused for inference — if $q ( z _ { t } \mid x _ { t } , z _ { t - 1 } )$ were just another neural network, it would have to essentially relearn the environment’s dynamics from scratch, resulting in a waste of parameters and training time. A further consequence is that the image likelihood $p ( x _ { t } \mid z _ { t } )$ is backpropagated through the dynamics model, which has been shown to be beneficial for efficient training (Karl et al., 2017; Becker-Ehmck et al., 2019). The same procedure is applied to reconcile velocity estimates from the two networks, where for the image model, velocities $z _ { t , \mathrm { v e l o } } ^ { o }$ are estimated from position differences between two consecutive timesteps.o The object scales $z _ { t , \mathrm { s c a l e } } ^ { o }$ are inferred solely from the image model. The latent states increase the modelling capacity of the dynamics network, are initialised to zero-mean Gaussians, and do not interact with the image model. This then gives the inference procedure for the full latent state $z _ { t } ^ { o } = ( z _ { t , \mathrm { p o s } } ^ { o } , z _ { t , \mathrm { s i z e } } ^ { o } , z _ { t , \mathrm { v e l o } } ^ { o } , z _ { t , \mathrm { l a t e n t } } ^ { o } )$ , as illustrated in Fig. 2 (right).
+
+Despite its benefits, this technique has thus far only been used in environments with a single object or with known state information. A challenge when applying it in a multi-object video setting is to match up the proposals of the two networks. Since the object detection RNN outputs proposals for object locations in an indeterminate order, it is not immediately clear how to find the corresponding proposals from the dynamics network. We have, however, found that a simple matching procedure results in good performance: For each $z _ { t }$ , we assign the object order that results in the minimal difference of $| | z _ { t , \mathrm { p o s } } - z _ { t - 1 , \mathrm { p o s } } | |$ , where $| | \cdot | |$ is the Euclidean norm. The resulting Euclidean bipartite matching problem can be solved in cubic time using the classic Hungarian algorithm (Kuhn, 1955).
+
+# 2.4 CONDITIONING ON ACTIONS
+
+In reinforcement learning, an agent interacts with the environment sequentially through actions $a _ { t }$ to optimize a cumulative reward $r$ . To extend STOVE to operate in this setting, we make two changes, yielding a distribution $p ( z _ { t } , r _ { t } \mid z _ { t - 1 } , a _ { t - 1 } )$ .
+
+First, we condition the dynamics model on actions $a _ { t }$ , enabling a conditional prediction based on both state and action. To keep the model invariant to the order of the input objects, the action information is concatenated to each object state $z _ { t - 1 } ^ { o }$ before they are fed into the dynamics model. The model has to learn on its own which of the objects in the scene are influenced by the actions. To facilitate this, we have found it helpful to also concatenate appearance information from the extracted object patches to the object state. While this patch-wise code could, in general, be obtained using some neural feature extractor, we achieved satisfactory performance by simply using the mean values per color channel when given colored input.
+
+![](images/439309f336cbcdaab013818b9b1400e492efd3d0be28f643955921d3ab545183.jpg)  
+Figure 4: Mean test set performance of our model compared to baselines. Our approach (STOVE) clearly outperforms all unsupervised baselines and is almost indistinguishable from the supervised dynamics model on the billiards task. (Top) Mean squared errors over all pixels in the video prediction setting (the lower, the better). (Bottom) Mean Euclidean distances between predicted and true positions (the lower, the better). All position and pixel values are in $[ 0 , 1 ]$ . In all experiments, the first eight frames are given, all remaining frames are then conditionally generated. The shading indicates the max and min values over multiple training runs with identical hyperparameters. (Best viewed in color.)
+
+The second change to the model is the addition of reward prediction. In many RL environments, rewards depend on the interactions between objects. Therefore, the dynamics prediction architecture, presented in Eq. 1, is well suited to also predict rewards. We choose to share the same encoding of object interactions between reward and dynamics prediction and simply apply two different output networks $f$ in Eq. 1) to obtain the dynamics and reward predictions. The total model is again optimized using the ELBO, this time including the reward likelihood $p ( r _ { t } \mid z _ { t - 1 } , a _ { t - 1 } )$ .
+
+# 3 EXPERIMENTAL EVIDENCE
+
+In order to evaluate our model, we compare it to baselines in three different settings: First, pure video prediction, where the goal is to predict future frames of a video given previous ones. Second, the prediction of future object positions, which may be relevant for downstream tasks. Third, we extend one of the video datasets to a reinforcement learning task and investigate how our physics model may be utilized for sample-efficient, model-based reinforcement learning. With this paper, we also release a PyTorch implementation of STOVE.1
+
+# 3.1 VIDEO AND STATE MODELING
+
+Inspired by Watters et al. (2017), we consider grayscale videos of objects moving according to physical laws. In particular, we opt for the commonly used bouncing billiards balls dataset, as well as a dataset of gravitationally interacting balls. For further details on the datasets, see Appendix D. When trained using a single GTX 1080 Ti, STOVE converges after about 20 hours. As baselines, we compare to VRNNs (Chung et al., 2015), SQAIR (Kosiorek et al., 2018), and DDPAE (Hsieh et al., 2018). To allow for a fair comparison, we fix the number of objects predicted by SQAIR and DDPAE to the correct amount. Furthermore, we compare to a supervised baseline: Here, we consider the ground truth positions and velocities to be fully observed, and train our dynamics model on them, resembling the setting of Battaglia et al. (2016). Since our model needs to infer object states from pixels, this baseline provides an upper bound on the predictive performance we can hope to achieve with our model. In turn, the size of the performance gap between the two is a good indicator of the quality of our state-space model. We also report the results obtained by combining our image model with a simple linear physics model, which linearly extrapolates the objects’ trajectories. Since VRNN does not reason about object positions, we only evaluate it on the video prediction task. Similarly, the supervised baseline does not reason about images and is considered for the position prediction task only. For more information on the baselines, see Appendix E.
+
+![](images/438a7800208e40ee1010886942f1824c64d045e7e30fd458f4b1deeacb323ad5.jpg)  
+Figure 5: Comparison of the kinetic energies of the rollouts predicted by the models, computed based on position differences between successive states. Only STOVE’s predictions reflect the conservation of total kinetic energy in the billiards data set. This is a quantitive measure of the convincing physical behavior in the rollout videos. (Left, center) Averages are over 300 trajectories from the test set. Shaded regions indicate one standard deviation. STOVE correctly predicts trajectories with constant energy, whereas SQAIR and DDPAE quickly diverge. (Right) Rolling average over a single, extremely long-term run. We conjecture that STOVE predicts physical behavior indefinitely. (Best viewed in color.)
+
+Fig. 4 depicts the reconstruction and prediction errors of the various models: Each model is given eight frames of video from the test set as input, which it then reconstructs. Conditioned on this input, the models predict the object positions or resulting video frames for the following 92 timesteps. The predictions are evaluated on ground truth data by computing the mean squared error between pixels and the Euclidean distance between positions based on the best available object matching. We outperform all baselines on both the state and the image prediction task by a large margin. Additionally, we perform strikingly close to the supervised model.
+
+For the gravitational data, the prediction task appears easier, as all models achieve lower errors than on the billiards task. However, in this regime of easy prediction, precise access to the object states becomes more important, which is likely the reason why the gap between our approach and the supervised baseline is slightly more pronounced. Despite this, STOVE produces high-quality rollouts and outperforms the unsupervised baselines.
+
+Table 1 underlines these results with concrete numbers. We also report results for three ablations of STOVE, which are obtained by (a) training a separate dynamics networks for inference with the same graph neural network architecture, instead of sharing weights with the generative model as argued for in section 2.3, (b) no longer explicitly modelling velocities ${ \mathit { z } } _ { \mathrm { v e l o } }$ in the state, and (c) removing the latent state variables $z _ { \mathrm { l a t e n t } }$ . The ablation study shows that each of these components contributes positively to the performance of STOVE. See Appendix F for a comparison of training curves for the ablations.
+
+Fig. 3 illustrates predictions on future object positions made by the models, after each of them was given eight consecutive frames from the datasets. Visually, we find that STOVE predicts physically plausible sequences over long timeframes. This desirable property is not captured by the rollout error: Due to the chaotic nature of our environments, infinitesimally close initial states diverge quickly and a model which perfectly follows the ground truth states cannot exist. After this divergence has occurred, the rollout error no longer provides any information on the quality of the learned physical behavior. We therefore turn to investigating the total kinetic energy of the predicted billiards trajectories. Since the collisions in the training set are fully elastic and frictional forces are not present, the initial energy should be conserved. Fig. 5 shows the kinetic energies of trajectories predicted by STOVE and its baselines, computed based on the position differences between consecutive timesteps. While the energies of SQAIR and DDPAE diverge quickly in less than 100 frames, the mean energies of STOVE’s rollouts stay constant and are good estimates of the true energy. We have confirmed that STOVE predicts constant energies – and therefore displays realistic looking behavior – for at least 100 000 steps. This is in stark contrast to the baselines, which predict teleporting, stopping, or overlapping objects after less than 100 frames. In the billiards dataset used by us and the literature, the total energy is the same for all sequences in the training set. See Appendix B for a discussion of how STOVE handles diverse energies.
+
+Table 1: Predictive performance of our approach, the baselines, and ablations (lower is better, best unsupervised values are bold). STOVE outperforms all unsupervised baselines and is almost indistinguishable from the supervised model on the billiards task. The values are computed by summing the prediction errors presented in Fig. 4 in the time interval $t \in$ [9, 18], i.e., the first ten predicted timesteps. In parentheses, standard deviations across multiple training runs are given.   
+
+<table><tr><td></td><td>Billiards (pixels)</td><td>Billiards (positions)</td><td>Gravity (pixels)</td><td>Gravity (positions)</td></tr><tr><td>STOVE (ours)</td><td>0.240(14)</td><td>0.418(20)</td><td>0.040(3)</td><td>0.142(7)</td></tr><tr><td>VRNN</td><td>0.526(14)</td><td></td><td>0.055(12)</td><td></td></tr><tr><td>SQAIR</td><td>0.591</td><td>0.804</td><td>0.070</td><td>0.194</td></tr><tr><td>DDPAE</td><td>0.405</td><td>0.482</td><td>0.120</td><td>0.298</td></tr><tr><td>Linear</td><td>0.844(5)</td><td>1.348(15)</td><td>0.196(2)</td><td>0.493(4)</td></tr><tr><td>Supervised</td><td></td><td>0.232(37)</td><td>一</td><td>0.013(2)</td></tr><tr><td>Abl: Double Dynamics</td><td>0.262</td><td>0.458</td><td>0.042</td><td>0.154</td></tr><tr><td>Abl: No Velocity</td><td>0.272</td><td>0.460</td><td>0.053</td><td>0.174</td></tr><tr><td>Abl: No Latent</td><td>0.338</td><td>0.050</td><td>0.089</td><td>0.235</td></tr></table>
+
+# 3.2 MODEL-BASED CONTROL
+
+To explore the usefulness of STOVE for reinforcement learning, we extend the billiards dataset into a reinforcement learning task. Now, the agent controls one of the balls using nine actions, which correspond to moving in one of the eight (inter)cardinal directions and staying at rest. The goal is to avoid collisions with the other balls, which elastically bounce off of each other, the walls, and the controlled ball. A negative reward of $- 1$ is given whenever the controlled ball collides with one of the others. To allow the models to recognize the object controlled by the agents we now provide it with RGB input in which the balls are colored differently. Starting with a random policy, we iteratively gather observations from the environment, i. e. sequences of images, actions, and rewards. Using these, we train our model as described in Sec. 2.4. To obtain a policy based on our world model, we use Monte-Carlo tree search (MCTS), leveraging our model as a simulator for planning. Using this policy, we gather more observations and apply them to refine the world model. As an upper bound on the performance achievable in this manner, we report the results obtained by MCTS when the real environment is used for planning. As a model-free baseline, we consider PPO (Schulman et al., 2017), which is a state-of-the-art algorithm on comparable domains such as Atari games. To explore the effect of the availability of state information, we also run PPO on a version of the environment in which, instead of images, the ground-truth object positions and velocities are observed directly.
+
+Learning curves for each of the agents are given in Fig. 6 (left), reported at intervals of 10 000 samples taken from the environment, up to a total of 130 000. For our model, we collect the first 50 000 samples using a random policy to provide an initial training set. After that, the described training loop is used, iterating between collecting 10 000 observations using an MCTS-based policy and refining the model using examples sampled from the pool of previously seen observations. After 130 000 samples, PPO has not yet seen enough samples to converge, whereas our model quickly learns to meaningfully model the environment and thus produces a better policy at this stage. Even when PPO is trained on ground truth states, MCTS based on STOVE remains comparable.
+
+![](images/3f83a9f411cd632a4d06105f63d51989e999a9af882fa2d8f3256ed7484cd94d.jpg)  
+Figure 6: Comparison of all models on sample efficiency and final performance. (Left) Mean cumulative reward over 100 steps on the environment, averaged over 100 environments, using the specified policy. The shaded regions correspond to one-tenth of a standard deviation. In addition to the training curves, two constant baselines are shown, one representing a random policy and one corresponding to the MCTS based policy when using the real environment as a simulator. (Right) Final performance of all approaches, after training each model to convergence. The shaded region corresponds to one standard deviation. (Best viewed in color.)
+
+After training each model to convergence, the final performance of all approaches is reported in Fig. 6 (right). In this case, PPO achieves slightly better results, however it only converges after training for approximately $4 0 0 0 0 0 0$ steps, while our approach only uses 130 000 samples. After around $1 5 0 0 0 0 0$ steps, PPO does eventually surpass the performance of STOVE-based MCTS. Additionally, we find that MCTS on STOVE yields almost the same performance as on the real environment, indicating that it can be used to anticipate and avoid collisions accurately.
+
+# 4 RELATED WORK
+
+Multiple lines of work with the goal of video modeling or prediction have emerged recently. Prominently, the supervised modeling of physical interactions from videos has been investigated by Fragkiadaki et al. (2015), who train a model to play billiards with a single ball. Similarly, graph neural networks have been trained in a supervised fashion to predict the dynamics of objects from images (Watters et al., 2017; Sanchez-Gonzalez et al., 2018; Sun et al., 2018; 2019) or ground truth states (Kipf et al., 2018; Wang et al., 2018; Chang et al., 2017). A number of works learn object interactions in games in terms of rules instead of continuous dynamics (Guzdial et al., 2017; Ersen & Sariel, 2014). Janner et al. (2019) show successful planning based on learned interactions, but assume access to image segmentations. Several unsupervised approaches address the problem by fitting the parameters of a physics engine to data (Jaques et al., 2019; Wu et al., 2016; 2015). This necessitates specifying in advance which physical laws govern the observed interactions. In the fully unsupervised setting, mainly unstructured variational approaches have been explored (Babaeizadeh et al., 2017; Chung et al., 2015; Krishnan et al., 2015). However, without the explicit notion of objects, their performance in scenarios with interacting objects remains limited. Nevertheless, unstructured video models have recently been applied to model-based RL and have been shown to improve sample efficiency when used as a simulator for the real environment (Oh et al., 2015; Kaiser et al., 2020).
+
+Only a small number of works incorporate objects into unsupervised video models. Xu et al. (2019) and Ehrhardt et al. (2018) take non-probabilistic autoencoding approaches to discovering objects in real-world videos. COBRA (Watters et al., 2019) represents a model-based RL approach based on MONet, but is restricted to environments with non-interacting objects and only uses one-step search to build its policy. Closest to STOVE are a small number of probabilistic models, namely SQAIR (Kosiorek et al., 2018), R-NEM (Van Steenkiste et al., 2018; Greff et al., 2017), and DDPAE (Hsieh et al., 2018). R-NEM learns a mixture model via expectation-maximization unrolled through time and handles interactions between objects in a factorized fashion. However, it lacks an explicitly structured latent space, and requires noise in the input data to avoid local minima. Both DDPAE and SQAIR extend the AIR approach to work on videos using standard recurrent architectures. As discussed, this introduces a double recurrence over objects and time, which is detrimental for performance. However, SQAIR is capable of handling a varying number of objects, which is not something we consider in this paper.
+
+# 5 CONCLUSION
+
+We introduced STOVE, a structured, object-aware model for unsupervised video modeling and planning. It combines recent advances in unsupervised image modeling and physics prediction into a single compositional state-space model. The resulting joint model explicitly reasons about object positions and velocities, and is capable of generating highly accurate video predictions in domains featuring complicated non-linear interactions between objects. As our experimental evaluation shows, it outperforms previous unsupervised approaches and even approaches the performance and visual quality of a supervised model.
+
+Additionally, we presented an extension of the video learning framework to the RL setting. Our experiments demonstrate that our model may be utilized for sample-efficient model-based control in a visual domain, making headway towards a long standing goal of the model-based RL community. In particular, STOVE yields good performance with more than one order of magnitude fewer samples compared to the model-free baseline, even when paired with a relatively simple planning algorithm like MCTS.
+
+At the same time, STOVE also makes several assumptions for the sake of simplicity. Relaxing them provides interesting avenues for future research. First, we assume a fixed number of objects, which may be avoided by performing dynamic object propagation and discovery like in SQAIR. Second, we have inherited the assumption of rectangular object masks from AIR. Applying a more flexible model such as MONet (Burgess et al., 2019) or GENESIS (Engelcke et al., 2020) may alleviate this, but also poses additional challenges, especially regarding the explicit modeling of movement. Finally, the availability of high-quality learned state-space models enables the use of more sophisticated planning algorithms in visual domains (Chua et al., 2018). In particular, by combining planning with policy and value networks, model-free and model-based RL may be integrated into a comprehensive system (Buckman et al., 2018).
+
+Acknowledgments. The authors thank Adam Kosiorek for his assistance with the SQAIR experiments and Emilien Dupont for helpful discussions about conservation laws in dynamics models. KK acknowledges the support of the Rhine-Main universities’ network for “Deep Continuous-Discrete Machine Learning” (DeCoDeML).
+
+# REFERENCES
+
+Mohammad Babaeizadeh, Chelsea Finn, Dumitru Erhan, Roy H Campbell, and Sergey Levine. Stochastic variational video prediction. In Proceedings of ICLR, 2017.
+
+Peter Battaglia, Razvan Pascanu, Matthew Lai, Danilo Jimenez Rezende, et al. Interaction networks for learning about objects, relations and physics. In Proceedings of NeurIPS, pp. 4502–4510, 2016.
+
+Peter W Battaglia, Jessica B Hamrick, Victor Bapst, Alvaro Sanchez-Gonzalez, Vinicius Zambaldi, Mateusz Malinowski, Andrea Tacchetti, David Raposo, Adam Santoro, Ryan Faulkner, et al. Relational inductive biases, deep learning, and graph networks. arXiv preprint arXiv:1806.01261, 2018.
+
+Philip Becker-Ehmck, Jan Peters, and Patrick Van Der Smagt. Switching linear dynamics for variational bayes filtering. In Proceedings of ICML, 2019.
+
+Jacob Buckman, Danijar Hafner, George Tucker, Eugene Brevdo, and Honglak Lee. Sampleefficient reinforcement learning with stochastic ensemble value expansion. In Proceedings of NeurIPS, pp. 8224–8234, 2018.
+
+Christopher P Burgess, Loic Matthey, Nicholas Watters, Rishabh Kabra, Irina Higgins, Matt Botvinick, and Alexander Lerchner. Monet: Unsupervised scene decomposition and representation. arXiv preprint arXiv:1901.11390, 2019.
+
+Michael Chang, Tomer Ullman, Antonio Torralba, and Joshua B Tenenbaum. A compositional object-based approach to learning physical dynamics. In Proceedings of ICLR, 2017.
+
+Kurtland Chua, Roberto Calandra, Rowan McAllister, and Sergey Levine. Deep reinforcement learning in a handful of trials using probabilistic dynamics models. In Proceedings of NeurIPS, pp. 4754–4765, 2018.
+
+Junyoung Chung, Kyle Kastner, Laurent Dinh, Kratarth Goel, Aaron C Courville, and Yoshua Bengio. A recurrent latent variable model for sequential data. In Proceedings of NeurIPS, pp. 2980– 2988, 2015.
+
+Remi Coulom. Efficient selectivity and backup operators in monte-carlo tree search. In ´ Computers and Games, pp. 72–83. Springer Berlin Heidelberg, 2007.
+
+Sebastien Ehrhardt, Aron Monszpart, Niloy Mitra, and Andrea Vedaldi. Unsupervised intuitive physics from visual observations. In Proceedings of ACCV, pp. 700–716, 2018.
+
+Martin Engelcke, Adam R. Kosiorek, Oiwi Parker Jones, and Ingmar Posner. Genesis: Generative scene inference and sampling with object-centric latent representations. In Proceedings of ICLR, 2020.
+
+Mustafa Ersen and Sanem Sariel. Learning behaviors of and interactions among objects through spatio–temporal reasoning. IEEE TCIAIG, 7(1):75–87, 2014.
+
+SM Ali Eslami, Nicolas Heess, Theophane Weber, Yuval Tassa, David Szepesvari, Geoffrey E Hinton, et al. Attend, infer, repeat: Fast scene understanding with generative models. In Proceedings of NeurIPS, pp. 3225–3233, 2016.
+
+Katerina Fragkiadaki, Pulkit Agrawal, Sergey Levine, and Jitendra Malik. Learning visual predictive models of physics for playing billiards. arXiv preprint arXiv:1511.07404, 2015.
+
+Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In Proceedings of NeurIPS, pp. 2672–2680, 2014.
+
+Klaus Greff, Sjoerd van Steenkiste, and Jurgen Schmidhuber. Neural expectation maximization. In ¨ Advances in Neural Information Processing Systems, pp. 6691–6701, 2017.
+
+Klaus Greff, Raphael Lopez Kaufmann, Rishab Kabra, Nick Watters, Chris Burgess, Daniel Zoran, ¨ Loic Matthey, Matthew Botvinick, and Alexander Lerchner. Multi-object representation learning with iterative variational inference. In Proceedings of ICML, 2019.
+
+U. Grenander. Lectures in Pattern Theory: Vol. 2 Pattern Analysis. Springer-Verlag, 1976.
+
+Matthew Guzdial, Boyang Li, and Mark O Riedl. Game engine learning from video. In Proceedings of IJCAI, 2017.
+
+Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural computation, 9(8): 1735–1780, 1997.
+
+Jun-Ting Hsieh, Bingbin Liu, De-An Huang, Li F Fei-Fei, and Juan Carlos Niebles. Learning to decompose and disentangle representations for video prediction. In Proceedings of NeurIPS, pp. 517–526, 2018.
+
+Michael Janner, Sergey Levine, William T. Freeman, Joshua B. Tenenbaum, Chelsea Finn, and Jiajun Wu. Reasoning about physical interactions with object-centric models. In Proceedings of ICLR, 2019.
+
+Miguel Jaques, Michael Burke, and Timothy Hospedales. Physics-as-inverse-graphics: Joint unsupervised learning of objects and physics from video. arXiv preprint arXiv:1905.11169, 2019.
+
+Łukasz Kaiser, Mohammad Babaeizadeh, Piotr Miłos, Błazej Osi ˙ nski, Roy H Campbell, Konrad ´ Czechowski, Dumitru Erhan, Chelsea Finn, Piotr Kozakowski, Sergey Levine, Afroz Mohiuddin, Ryan Sepassi, George Tucker, and Henryk Michalewski. Model based reinforcement learning for atari. In Proceedings of ICLR, 2020.
+
+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 Proceedings of ICLR, 2017.
+
+Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In Proceedings of ICLR, 2015.
+
+Diederik P Kingma and Max Welling. Auto-encoding variational bayes. In Proceedings of ICLR, 2014.
+
+Thomas Kipf, Ethan Fetaya, Kuan-Chieh Wang, Max Welling, and Richard Zemel. Neural relational inference for interacting systems. In Proceedings of ICML, 2018.
+
+Adam Kosiorek, Hyunjik Kim, Yee Whye Teh, and Ingmar Posner. Sequential attend, infer, repeat: Generative modelling of moving objects. In Proceedings of NeurIPS, pp. 8606–8616, 2018.
+
+Rahul G. Krishnan, Uri Shalit, and David Sontag. Deep kalman filters. arXiv preprint arXiv:1812.08434, 2015.
+
+Harold W Kuhn. The hungarian method for the assignment problem. Naval research logistics quarterly, 2(1-2):83–97, 1955.
+
+Junhyuk Oh, Xiaoxiao Guo, Honglak Lee, Richard L Lewis, and Satinder Singh. Action-conditional video prediction using deep networks in atari games. In Proceedings of NeurIPS, pp. 2845–2853, 2015.
+
+Alvaro Sanchez-Gonzalez, Nicolas Heess, Jost Tobias Springenberg, Josh Merel, Martin Riedmiller, Raia Hadsell, and Peter Battaglia. Graph networks as learnable physics engines for inference and control. In Proceedings of ICML, 2018.
+
+Adam Santoro, David Raposo, David G Barrett, Mateusz Malinowski, Razvan Pascanu, Peter Battaglia, and Timothy Lillicrap. A simple neural network module for relational reasoning. In Proceedings of NeurIPS, pp. 4967–4976, 2017.
+
+John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy optimization algorithms. arXiv preprint arXiv:1707.06347, 2017.
+
+Karl Stelzner, Robert Peharz, and Kristian Kersting. Faster attend-infer-repeat with tractable probabilistic models. In Proceedings of ICML, pp. 5966–5975, 2019.
+
+Chen Sun, Abhinav Shrivastava, Carl Vondrick, Kevin Murphy, Rahul Sukthankar, and Cordelia Schmid. Actor-centric relation network. In Proceedings of ECCV, 2018.
+
+Chen Sun, Abhinav Shrivastava, Carl Vondrick, Rahul Sukthankar, Kevin Murphy, and Cordelia Schmid. Relational action forecasting. In Proceedings of CVPR, 2019.
+
+Richard S Sutton and Andrew G Barto. Reinforcement learning: An introduction. MIT Press, Cambridge, 2011.
+
+Sjoerd Van Steenkiste, Michael Chang, Klaus Greff, and Jurgen Schmidhuber. Relational neural ex- ¨ pectation maximization: Unsupervised discovery of objects and their interactions. In Proceedings of ICLR, 2018.
+
+Antonio Vergari, Robert Peharz, Nicola Di Mauro, Alejandro Molina, Kristian Kersting, and Floriana Esposito. Sum-product autoencoding: Encoding and decoding representations using sumproduct networks. In Proceedings of AAAI, 2018.
+
+Tingwu Wang, Renjie Liao, Jimmy Ba, and Sanja Fidler. Nervenet: Learning structured policy with graph neural networks. In Proceedings of ICLR, 2018.
+
+Nicholas Watters, Daniel Zoran, Theophane Weber, Peter Battaglia, Razvan Pascanu, and Andrea Tacchetti. Visual interaction networks: Learning a physics simulator from video. In Proceedings of NeurIPS, pp. 4539–4547, 2017.   
+Nicholas Watters, Loic Matthey, Matko Bosnjak, Christopher P Burgess, and Alexander Lerchner. Cobra: Data-efficient model-based rl through unsupervised object discovery and curiosity-driven exploration. arXiv preprint arXiv:1905.09275, 2019.   
+Jiajun Wu, Ilker Yildirim, Joseph J Lim, Bill Freeman, and Josh Tenenbaum. Galileo: Perceiving physical object properties by integrating a physics engine with deep learning. In Proceedings of NeurIPS, pp. 127–135, 2015.   
+Jiajun Wu, Joseph J Lim, Hongyi Zhang, Joshua B Tenenbaum, and William T Freeman. Physics 101: Learning physical object properties from unlabeled videos. In Proceedings of BMVC, 2016.   
+Zhenjia Xu, Zhijian Liu, Chen Sun, Kevin Murphy, William T. Freeman, Joshua B. Tenenbaum, and Jiajun Wu. Modeling parts, structure, and system dynamics via predictive learning. In Proceedings of ICLR, 2019.   
+Cheng Zhang, Judith Butepage, Hedvig Kjellstr ¨ om, and Stephan Mandt. Advances in variational ¨ inference. IEEE TPAMI, 2019.   
+Jie Zhou, Ganqu Cui, Zhengyan Zhang, Cheng Yang, Zhiyuan Liu, and Maosong Sun. Graph neural networks: A review of methods and applications. arXiv preprint arXiv:1812.08434, 2018.
+
+# A RECONSTRUCTIONS: SPRITES DATA
+
+SuPAIR does not need a latent description of the objects’ appearances. Nevertheless, object reconstructions can be obtained by using a variant of approximate MPE (most probable explanation) in the sum-product networks as proposed by Vergari et al. (2018). We follow the AIR approach and reconstruct each object separately and paste it into the canvas using spatial transformers. Unlike AIR, SuPAIR explicitly models the background using a separate background SPN. A reconstruction of the background is also obtained using MPE.
+
+To demonstrate the capabilities of our image model, we also trained our model on a variant of the gravity data in which the round balls were replaced by a random selection of four different sprites of the same size. Fig. 7 shows the reconstructions obtained from SuPAIR when trained on these more complex object shapes.
+
+# B STUDY OF ENERGIES
+
+As discussed in Sec. 3.1, the energies of the ground truth data were constant for all sequences during the training of STOVE. However, initial velocities are drawn from a random normal distribution. This is the standard procedure of generating the bouncing balls data set as used by previous publications. Under these circumstances, STOVE does indeed learn to discover and replicate the total energies of the system, while SQAIR and DDPAE do not. Even if trained on constant energy data, STOVE does to some extent generalise to unseen energies. Observed velocities and therefore total energies are highly correlated with the true total kinetic energies of the sequences. However as prediction starts, STOVE quickly regresses to the energy of the training set, see Fig. 8 (left). If trained on a dataset of diverse total energies, the performance of modelling sequences of different energies increases, see Fig. 8 (right). Rollouts now initially represent the true energy of the observed sequence, although this estimate of the true energy diverges over a time span of around 500 frames to a constant but wrong energy value. This is an improvement over the model trained on constant energy data, where the regression to the training data energy happens much quicker within around 10 frames. Note that this does not drastically decrease the visual quality of the rollouts as the change of total energy over 500 frames is gradual enough. We leave the reliable prediction of rollouts with physically valid constant energy for sequences of varying energies for future work.
+
+# C MODEL DETAILS
+
+Here, we present additional details on the architecture and hyperparameters of STOVE.
+
+# C.1 INFERENCE ARCHITECTURE
+
+The object detection network for $q ( z _ { t , \mathrm { w h e r e } } \mid x _ { t } )$ is realised by an LSTM (Hochreiter & Schmidhuber, 1997) with 256 hidden units, which outputs the mean and standard deviation of the objects’ twodimensional position and size distributions, i.e. $q ( z _ { t , \mathrm { p o s } , \mathrm { s i z e } } ^ { o } \mid x _ { t } )$ with $2 \cdot 2 \cdot 2 = 8$ parameters per object. Given such position distributions for two consecutive timesteps $q ( \boldsymbol { z } _ { t - 1 , \mathrm { p o s } } \mid \boldsymbol { x } _ { t - 1 } ) , q ( \boldsymbol { z } _ { t , \mathrm { p o s } } \mid$ $x _ { t }$ ), with parameters $\mu _ { z _ { t - 1 , \mathrm { p o s } } ^ { o } } , \sigma _ { z _ { t - 1 , \mathrm { p o s } } ^ { o } } , \mu _ { z _ { t , \mathrm { p o s } } ^ { o } } , \sigma _ { z _ { t , \mathrm { p o s } } ^ { o } }$ , the following velocity estimate based on the difference in position is constructed:
+
+$$
+q ( z _ { t , \mathrm { v e l o } } ^ { o } \mid x _ { t } , x _ { t - 1 } ) = \mathcal { N } ( \mu _ { z _ { t , \mathrm { p o s } } ^ { o } } - \mu _ { z _ { t - 1 , \mathrm { p o s } } ^ { o } } , \sigma _ { z _ { t , \mathrm { p o s } } ^ { o } } ^ { 2 } + \sigma _ { z _ { t - 1 , \mathrm { p o s } } ^ { o } } ^ { 2 } ) .
+$$
+
+As described in Sec. 2.3, positions and velocities are also inferred from the dynamics model as $q \big ( z _ { t , \mathrm { p o s } } ^ { o } \mid z _ { t - 1 } \big )$ and $q \big ( z _ { t , \mathrm { v e l o } } ^ { o } \ \big | \ z _ { t - 1 } \big )$ . A joint estimate, including information from both image model and dynamics prediction, is obtained by multiplying the respective distributions and renormalizing. Since both $q$ -distributions are Gaussian, the normalized product is again Gaussian, with mean and
+
+![](images/250d42d0bf58bbf0abe9cdf56e8e0a79bd2957ccd91ebeb2abf1af06c577d4d4.jpg)  
+Figure 7: Reconstructions obtained from our image model when using more varied shapes.
+
+standard deviation are given by
+
+$$
+\begin{array} { r l } & { q ( \boldsymbol { z } _ { t } \mid \boldsymbol { x } _ { t } , \boldsymbol { z } _ { t - 1 } ) \propto q ( \boldsymbol { z } _ { t } \mid \boldsymbol { x } _ { t } ) \cdot q ( \boldsymbol { z } _ { t } \mid \boldsymbol { z } _ { t - 1 } ) } \\ & { \qquad = \mathcal { N } ( \boldsymbol { z } _ { t } ; \boldsymbol { \mu } _ { t , i } , \sigma _ { t , i } ^ { 2 } ) \cdot \mathcal { N } ( \boldsymbol { z } _ { t } ; \boldsymbol { \mu } _ { t , d } , \sigma _ { t , d } ^ { 2 } ) } \\ & { \qquad = \mathcal { N } ( \boldsymbol { z } _ { t } ; \boldsymbol { \mu } _ { t } , \sigma _ { t } ^ { 2 } ) } \\ & { \qquad \mu _ { t } = \frac { \sigma _ { t , d } ^ { 2 } \mu _ { t , i } + \sigma _ { t , i } ^ { 2 } \mu _ { t , d } } { \sigma _ { t , d } ^ { 2 } + \sigma _ { t , i } ^ { 2 } } } \\ & { \qquad \frac { 1 } { \sigma _ { t } ^ { 2 } } = \frac { 1 } { \sigma _ { t , d } ^ { 2 } } + \frac { 1 } { \sigma _ { t , i } ^ { 2 } } , } \end{array}
+$$
+
+where we relax our notation for readability $z _ { t } \in [ z _ { t , \mathrm { p o s } } ^ { o } , z _ { t , \mathrm { v e l o } } ^ { o } ]$ and the indices $i$ and $d$ refer to the parameters obtained from the image and dynamics model. This procedure is applied independently for the positions and velocities of each object.
+
+For zot,latent, we choose dimension 12, such that a full state $z _ { t } ^ { o } = ( z _ { t , \mathrm { p o s } } ^ { o } , z _ { t , \mathrm { s i z e } } ^ { o } , z _ { t , \mathrm { v e l o } } ^ { o } , z _ { t , \mathrm { l a t e n t } } ^ { o } )$ is 18-dimensional.
+
+# C.2 GRAPH NEURAL NETWORK
+
+The dynamics prediction is given by the following series of transformations applied to each input state of shape (batch size, number of objects, l), where $l ~ = ~ 1 6$ , since currently, size information is not propagated through the dynamics prediction.
+
+• $S _ { 1 }$ : Encode input state with linear layer $[ l , 2 l ]$ .   
+• $S _ { 2 }$ : Apply linear layer [2l, 2l] to $S _ { 1 }$ followed by ReLU non-linearity.   
+• $S _ { 3 }$ : Apply linear layer [2l, 2l] to $S _ { 2 }$ and add result to $S _ { 2 }$ . This gives the dynamics prediction without relational effects, corresponding to $g ( z _ { t } ^ { o } )$ in Eq. 1. $C _ { 1 }$ : The following steps obtain the relational aspects of dynamics prediction, corresponding to $h ( z _ { t } ^ { o } , z _ { t } ^ { o ^ { \prime } } )$ in Eq. 1. Concatenate the encoded state $S _ { 1 } ^ { o }$ pairwise with all state encoding, yielding a tensor of shape (batch size, number of objects, number of objects, 4l).   
+• $C _ { 2 }$ : Apply linear layer [4l, 4l] to $C _ { 1 }$ followed by ReLU.   
+• $C _ { 3 }$ : Apply linear layer [4l, 2l] to $C _ { 2 }$ followed by ReLU.   
+• $C _ { 4 }$ : Apply linear layer [2l, 2l] to $C _ { 3 }$ and add to $C _ { 3 }$ .   
+• $A _ { 1 }$ : To obtain attention coefficients $\alpha \big ( z _ { t } ^ { o } , z _ { t } ^ { o ^ { \prime } } \big )$ , apply linear layer $[ 4 l , 4 l ]$ to $C _ { 1 }$ followed by ReLU.   
+• $A _ { 2 }$ : Apply linear layer $[ 4 l , 2 l ]$ to $A _ { 1 }$ followed by ReLU.   
+• $A _ { 3 }$ : Apply linear layer [2l, 1] to $A _ { 2 }$ and apply exponential function.   
+• $R _ { 1 }$ : Multiply $C _ { 4 }$ with $A _ { 3 }$ , where diagonal elements of $A _ { 3 }$ are masked out to ensure that $R _ { 1 }$ only covers cases where $o \neq o ^ { \prime }$ .   
+• $R _ { 2 }$ : Sum over $R _ { 1 }$ for all $o ^ { \prime }$ , to obtain tensor of shape (batch size, number of objects, 2l). This is the relational dynamics prediction. • $D _ { 1 }$ : Sum relational dynamics $R _ { 2 }$ and self-dynamics $S _ { 3 }$ , obtaining the input to $f$ in Eq. 1.   
+• $D _ { 2 }$ : Apply linear layer [2l, 2l] to $D _ { 1 }$ followed by tanh non-linearity.   
+• $D _ { 3 }$ : Apply linear layer [2l, 2l] to $D _ { 2 }$ followed by tanh non-linearity and add result to $D _ { 2 }$ .   
+• $D _ { 4 }$ : Concatenate $D _ { 3 }$ and $S _ { 1 }$ , and apply linear layer [4l, 2l] followed by tanh.   
+• $D _ { 5 }$ : Apply linear layer [2l, 2l] to $D _ { 4 }$ and add result to $D _ { 4 }$ to obtain final dynamics prediction.
+
+![](images/61dce573d362ff7fd6fdb777baa2450419a27bd1fb412a75698d60c3372f690e.jpg)  
+Figure 8: Mean kinetic energy observed/predicted by STOVE over true energy of the sequences. (left) STOVE is trained on sequences of constant kinetic energy. As can be seen from the blue scatter points, STOVE manages to predict sequences of arbitrary lengths which, on average, preserve the constant energy of the test set. When STOVE is applied to sequences of different energies, it manages to infer these energies from observed frames fairly well, with inaccuracies compounding at larger energies (red). In the following prediction, however, the mean predicted energies diverge quickly to the energy value of the training set (orange and green). (right) STOVE is now trained on sequences of varying energies. Compared to the constant energy training, energies from observed as well as predicted energies improve drastically. The predictions no longer immediately regress towards a specific value (orange). However after 100 frames, the quality of the predicted energies still regresses to a wrong value (green). (all) The observed values refers to energies obtained as the mean energy value over the six initially observed frames. The short (long) time frame refers to an energy obtained as the mean energy over the first 10 (100) frames of prediction. (Best viewed in color.)
+
+The output $D _ { 5 }$ has shape (batch size, number of objects, 2l), twice the size of means and standard deviations over the next predicted state.
+
+For the model-based control scenario, the one-hot encoded actions (batch size, action space) are transformed with a linear layer [action space, number of objects · encoding size] and reshaped to (action space, number of objects, encoding size). The action embedding and the object appearances (batch size, number of objects, 3) are then concatenated to the input state. The rest of the dynamics prediction follows as above. The reward prediction consists of the following steps:
+
+• $H _ { 1 }$ : Apply linear layer [2l, 2l] to $D _ { 1 }$ followed by ReLU.   
+• $H _ { 2 }$ : Apply linear layer [2l, 2l] to $H _ { 1 }$ .   
+• $H _ { 3 }$ : Sum over object dimension to obtain tensor of shape (batch size, l).   
+• $H _ { 4 }$ : Apply linear layer $[ l , l / 2 ]$ to $H _ { 3 }$ followed by ReLU.   
+• $H _ { 5 }$ : Apply linear layer $[ l / 2 , l / 4 ]$ to $H _ { 4 }$ followed by ReLU.   
+• $H _ { 5 }$ : Apply linear layer $[ l / 4 , l ]$ to $H _ { 4 }$ followed by a sigmoid non-linearity.
+
+$H _ { 5 }$ then gives the final reward prediction.
+
+# C.3 STATE INITIALIZATION
+
+In the first two timesteps, we cannot yet apply STOVE’s main inference step $q ( z _ { t } \mid z _ { t - 1 } , x _ { t } , x _ { t - 1 } )$ as described above. In order to initialize the latent state over the first two frames, we apply a simplified architecture and only use a partial state at $t = 0$ .
+
+At $t = 0$ , $z _ { 0 } \sim q ( z _ { 0 , \mathrm { ( p o s , s i z e ) } } \mid x _ { 0 } )$ is given purely by the object detection network, since no previous states, which could be propagated, exist. $z _ { \mathrm { 0 } }$ is incomplete insofar as it does not contain velocity information or latents. At $t = 1$ , $q ( z _ { 1 , \mathrm { p o s , s i z e } } \mid x _ { 1 } , x _ { 0 } )$ is still given purely based on the object detection network. Note that for a dynamics prediction of $z _ { 1 }$ , velocity information at $t = 0$ would need to be available. However, at $t = 1$ , velocities can be constructed based on the differences between the previously inferred object positions. We sample $z _ { 1 , \mathrm { l a t e n t } }$ from the prior Gaussian distribution to assemble the first full initial state $z _ { 1 }$ . At $t \geq 2$ , the full inference network can be run: States are inferred both from the object detection network $q ( \boldsymbol { z } _ { t } \ | \ x _ { t } , \boldsymbol { x } _ { t - 1 } )$ as well as propagated using the dynamics model $q \big ( z _ { t } \mid z _ { t - 1 } \big )$ .
+
+In the generative model, similar adjustments are made: $p ( z _ { 0 , \mathrm { p o s , s i z e } } )$ is given by a uniform prior, velocities and latents are omitted. At $t = 1$ , velocities are sampled from a uniform distribution in planar coordinates $p ( z _ { 1 , \mathrm { v e l o } } )$ and positions are given by a simple linear dynamics model $p ( z _ { 1 , \mathrm { p o s } } \ |$ $z _ { 0 , \mathrm { p o s } } , z _ { 1 , \mathrm { v e l o } } ) = \mathcal N ( z _ { 0 , \mathrm { p o s } } + z _ { 1 , \mathrm { v e l o } } , \sigma )$ . Latents $z _ { 1 , \mathrm { l a t e n t } }$ are sampled from a Gaussian prior. Starting at $t = 2$ , the full dynamics model is used.
+
+# C.4 TRAINING PROCEDURE
+
+Our model was trained using the Adam optimizer (Kingma & Ba, 2015), with a learning rate of $2 \times 1 0 ^ { - 3 } \exp ( - 4 0 \times 1 0 ^ { - 3 } \cdot \mathrm { s t e p } )$ for a total of $8 3 0 0 0$ steps with a batch size of 256.
+
+# D DATA DETAILS
+
+For the billiards and gravitational data, 1000 sequences of length 100 were generated for training. From these, subsequences of lengths 8 were sampled and used to optimize the ELBO. A test dataset of 300 sequences of length 100 was also generated and used for all evaluations. The pixel resolution of the dataset was $3 2 \times 3 2$ for the billiards data and $5 0 \times 5 0$ for the gravity data. All models for video prediction were learned on grayscale data, with objects of identical appearance. The $O = 3$ balls were initialised with uniformly random positions and velocities, rejecting configurations with overlap. They are rendered using anti-aliasing. The billiards data models the balls as circular objects, which perform elastic collision with each other or the walls of the environment. For the gravity data, the balls are modeled as point masses, where, following Watters et al. (2017), we clip the gravitational force to avoid slingshot effects. Also, we add an additional basin of attraction towards the center of the canvas and model the balls in their center off mass system to avoid drift. Velocities here are initialised orthogonal to the center of the canvas for a stabilising effect. For full details we refer to the file envs.py in the provided code.
+
+# E BASELINES FOR VIDEO MODELING
+
+Following Kosiorek et al. (2018), we experimented with different hyperparameter configurations for VRNNs. We varied the sizes of the hidden and latent states $[ h , z ]$ , experimenting with the values [256, 16], [512, 32], [1024, 64], and [2048, 32]. We found that increasing the model capacity beyond [512, 32] did not yield large increases in performance, which is why we chose the configuration [512, 32] for our experiments. Our VRNN implementation is written in PyTorch and based on https://github.com/emited/VariationalRecurrentNeuralNetwork.
+
+SQAIR can handle a variable number of objects in each sequence. However, to allow for a fairer comparison to STOVE, we fixed the number of objects to the correct number. This means that in the first timestep, exactly three objects are discovered, which are then propagated in all following timesteps, without further discoveries. Our implementation is based on the original implementation provided by the authors at https://github.com/akosiorek/sqair.
+
+![](images/4dd4a1dc282ad5bd3363117064355e87e6881785fdcd75837ddea026fc1ced3d.jpg)  
+Figure 9: Displayed is the mean predicted position error over a rollout length of 8 frames as training progresses for the billiards (left) and gravity (right) scenario for STOVE and its ablations. (Best viewed in color.)
+
+The DDPAE experiments were performed using the implementation available at https:// github.com/jthsieh/DDPAE-video-prediction. Default parameters for training DDPAE with billiards datasets are provided with the code. However, the resolution of our billiards (32 pixels) and gravity (64 pixels) datasets is different to the resolution DDPAE expects (64 pixels). While we experimented with adjusting DDPAE parameters such as the latent space dimension to fit our different resolution, best results were obtained when bilinearly scaling our data to the resolution DDPAE expects. DDPAE was trained for 400 000 steps, which sufficed for convergence of the models’ test set error.
+
+The linear baseline was obtained as follows: For the first 8 frames, we infer the full model state using STOVE. We then take the last inferred positions and velocities of each object and predict future positions by assuming constant, uniform motions for each object. We do not allow objects to leave the frame, i. e. when objects reach the canvas boundary after some timesteps, they stick to it.
+
+Since our dynamics model requires only object positions and velocities as input, it is trivial to construct a supervised baseline for our physics prediction by replacing the SuPAIR-inferred states with real, ground-truth states. On these, the model can then be trained in supervised fashion.
+
+# F TRAINING CURVES OF ABLATIONS
+
+In Fig. 9 we display learning curves for STOVE and presented ablations. As mentioned in the main text, the ablations demonstrate the value of the reuse of the dynamics model, the explicit inclusion of a velocity value, and the presence of unstructured latent space in the dynamics model. (Best viewed in color.)
+
+# G DETAILS ON THE REINFORCEMENT LEARNING MODELS
+
+Our MCTS implementation uses the standard UCT formulation for exploration/exploitation. The $c$ parameter is set to 1. in all our experiments. Since the environment does not provide a natural endpoint, we cut off all rollouts at a depth of 20 timesteps. We found this to be a good trade-off between runtime and accuracy.
+
+When expanding a node on the true environment, we compute the result of the most promising action, and then start a rollout using a random policy from the resulting state. For the final evaluation, a total of 200 nodes are expanded. To better utilize the GPU, a slightly different approach is used for STOVE. When we expand a node in this setting, we predict the results of all actions simultaneously, and compute a rollout from each resulting position. In turn, only 50 nodes are expanded. To estimate the node value function, the average reward over all rollouts is propagated back to the root and each node’s visit counter is increased by 1. Furthermore, we discount the reward predicted STOVE with a factor of 0.95 per timestep to account for the higher uncertainty of longer rollouts. This is not done in the baseline running on the real environment, since it behaves deterministically.
+
+For PPO, we employ a standard convolutional neural network as an actor-critic for the evaluation on images and a MLP for the evaluation on states. The image network consists of two convolutional layers, each using 32 output filters with a kernel size of 4 and 3 respectively and a stride of 2. The MLP consists of two fully connected layers with 128 and 64 hidden units. In both cases, an additional fully connected layer links the outputs of the respective base to an actor and a critic head. For the convolutional base, this linking layer employs 512 hidden units, for the MLP 64. All previously mentioned layers use rectified linear activations. The actor head predicts a probability distribution over next actions using a softmax activation function while the critic head outputs a value estimation for the current state using a linear prediction. We tested several hyperparameter configurations but found the following to be the most efficient one. To update the actor-critic architecture, we sample 32 trajectories of length 16 from separate environments in every batch. The training uses an Adam optimizer with a learning rate of $2 \times 1 0 ^ { - 4 }$ and and $\epsilon$ value of $\mathrm { i } ^ { \cdot } \times \mathrm { 1 0 ^ { - 5 } }$ . The clipping parameter of PPO is set to $1 \times 1 0 ^ { - 1 }$ . We update the network for 4 epochs in each batch using 32 mini-batches of the sampled data. The value loss is weighted at $5 \times 1 0 ^ { - 1 }$ and the entropy coefficient is set to $1 \times 1 0 ^ { - 2 }$ .

parse/train/BJx040EFvH/BJx040EFvH.md

@@ -0,0 +1,338 @@
+# FAST IS BETTER THAN FREE: REVISITING ADVERSARIAL TRAINING
+
+Eric Wong∗ Machine Learning Department Carnegie Mellon University Pittsburgh, PA 15213, USA ericwong@cs.cmu.edu
+
+Leslie Rice∗ Computer Science Department Carnegie Mellon University Pittsburgh, PA 15213, USA larice@cs.cmu.edu
+
+# J. Zico Kolter
+
+Computer Science Department Carnegie Mellon University and Bosch Center for Artifical Intelligence Pittsburgh, PA 15213, USA zkolter@cs.cmu.edu
+
+# ABSTRACT
+
+Adversarial training, a method for learning robust deep networks, is typically assumed to be more expensive than traditional training due to the necessity of constructing adversarial examples via a first-order method like projected gradient decent (PGD). In this paper, we make the surprising discovery that it is possible to train empirically robust models using a much weaker and cheaper adversary, an approach that was previously believed to be ineffective, rendering the method no more costly than standard training in practice. Specifically, we show that adversarial training with the fast gradient sign method (FGSM), when combined with random initialization, is as effective as PGD-based training but has significantly lower cost. Furthermore we show that FGSM adversarial training can be further accelerated by using standard techniques for efficient training of deep networks, allowing us to learn a robust CIFAR10 classifier with $45 \%$ robust accuracy to PGD attacks with $\epsilon = 8 / 2 5 5$ in 6 minutes, and a robust ImageNet classifier with $43 \%$ robust accuracy at $\epsilon = 2 / 2 5 5$ in 12 hours, in comparison to past work based on “free” adversarial training which took 10 and 50 hours to reach the same respective thresholds. Finally, we identify a failure mode referred to as “catastrophic overfitting” which may have caused previous attempts to use FGSM adversarial training to fail. All code for reproducing the experiments in this paper as well as pretrained model weights are at https://github.com/locuslab/fast_adversarial.
+
+# 1 INTRODUCTION
+
+Although deep network architectures continue to be successful in a wide range of applications, the problem of learning robust deep networks remains an active area of research. In particular, safety and security focused applications are concerned about robustness to adversarial examples, data points which have been adversarially perturbed to fool a model (Szegedy et al., 2013). The goal here is to learn a model which is not only accurate on the data, but also accurate on adversarially perturbed versions of the data. To this end, a number of defenses have been proposed to mitigate the problem and improve the robustness of deep networks, with some of the most reliable being certified defenses and adversarial training. However, both of these approaches come at a non-trivial, additional computational cost, often increasing training time by an order of magnitude over standard training. This has slowed progress in researching robustness in deep networks, due to the computational difficulty in scaling to much larger networks and the inability to rapidly train models when experimenting with new ideas. In response to this difficulty, there has been a recent surge in work that tries to to reduce the complexity of generating an adversarial example, which forms the bulk of the additional computation in adversarial training (Zhang et al., 2019; Shafahi et al., 2019). While these works present reasonable improvements to the runtime of adversarial training, they are still significantly slower than standard training, which has been greatly accelerated due to competitions for optimizing both the speed and cost of training (Coleman et al., 2017).
+
+In this work, we argue that adversarial training, in fact, is not as hard as has been suggested by this past line of work. In particular, we revisit one of the the first proposed methods for adversarial training, using the Fast Gradient Sign Method (FGSM) to add adversarial examples to the training process (Goodfellow et al., 2014). Although this approach has long been dismissed as ineffective, we show that by simply introducing random initialization points, FGSM-based training is as effective as projected gradient descent based training while being an order of magnitude more efficient. Moreover, FGSM adversarial training (and to a lesser extent, other adversarial training methods) can be drastically accelerated using standard techniques for efficient training of deep networks, including e.g. cyclic learning rates (Smith & Topin, 2018), mixed-precision training (Micikevicius et al., 2017), and other similar techniques. The method has extremely few free parameters to tune, and can be easily adapted to most training procedures. We further identify a failure mode that we call “catastrophic overfitting”, which may have caused previous attempts at FGSM adversarial training to fail against PGD-based attacks.
+
+The end result is that, with these approaches, we are able to train (empirically) robust classifiers far faster than in previous work. Specifically, we train an $\ell _ { \infty }$ robust CIFAR10 model to $4 5 \%$ accuracy at $\epsilon = 8 / 2 5 \bar { 5 }$ (the same level attained in previous work) in $6$ minutes; previous papers reported times of 80 hours for PGD-based training (Madry et al., 2017) and 10 hours for the more recent “free” adversarial training method (Shafahi et al., 2019). Similarly, we train an $\ell _ { \infty }$ robust ImageNet classifier to $4 3 \%$ top-1 accuracy at $\epsilon = 2 / 2 5 5$ (again matching previous results) in 12 hours of training (compared to 50 hours in the best reported previous work that we are aware of (Shafahi et al., 2019)). Both of these times roughly match the comparable time for quickly training a standard non-robust model to reasonable accuracy. We extensively evaluate these results against strong $P G D { \mathrm { . } }$ - based attacks, and show that they obtain the same empirical performance as the slower, PGD-based training. Thus, we argue that despite the conventional wisdom, adversarially robust training is not actually more challenging than standard training of deep networks, and can be accomplished with the notoriously weak FGSM attack.
+
+# 2 RELATED WORK
+
+After the discovery of adversarial examples by Szegedy et al. (2013), Goodfellow et al. (2014) proposed the Fast Gradient Sign Method (FGSM) to generate adversarial examples with a single gradient step. This method was used to perturb the inputs to the model before performing backpropagation as an early form of adversarial training. This attack was enhanced by adding a randomization step, which was referred to as $\mathrm { R + F G S M }$ (Tramer et al., 2017). Later, the Basic Iterative \` Method improved upon FGSM by taking multiple, smaller FGSM steps, ultimately rendering both FGSM-based adversarial training ineffective (Kurakin et al., 2016). This iterative adversarial attack was further strengthened by adding multiple random restarts, and was also incorporated into the adversarial training procedure. These improvements form the basis of what is widely understood today as adversarial training against a projected gradient descent (PGD) adversary, and the resulting method is recognized as an effective approach to learning robust networks (Madry et al., 2017). Since then, the PGD attack and its corresponding adversarial training defense have been augmented with various techniques, such as optimization tricks like momentum to improve the adversary (Dong et al., 2018), combination with other heuristic defenses like matrix estimation (Yang et al., 2019) or logit pairing (Mosbach et al., 2018), and generalization to multiple types of adversarial attacks (Tramer & Boneh, 2019; Maini et al., 2019).\`
+
+In addition to adversarial training, a number of other defenses against adversarial attacks have also been proposed. Adversarial defenses span a wide range of methods, such as preprocessing techniques (Guo et al., 2017; Buckman et al., 2018; Song et al., 2017), detection algorithms (Metzen et al., 2017; Feinman et al., 2017; Carlini & Wagner, 2017a), verification and provable defenses (Katz et al., 2017; Sinha et al., 2017; Wong & Kolter, 2017; Raghunathan et al., 2018), and various theoretically motivated heuristics (Xiao et al., 2018; Croce et al., 2018). While certified defenses have been scaled to reasonably sized networks (Wong et al., 2018; Mirman et al., 2018; Gowal et al., 2018; Cohen et al., 2019; Salman et al., 2019), the guarantees don’t match the empirical robustness obtained through adversarial training.
+
+With the proposal of many new defense mechanisms, of great concern in the community is the use of strong attacks for evaluating robustness: weak attacks can give a misleading sense of security, and the history of adversarial examples is littered with adversarial defenses (Papernot et al., 2016; Lu et al., 2017; Kannan et al., 2018; Tao et al., 2018) which were ultimately defeated by stronger attacks (Carlini & Wagner, 2016; 2017b; Athalye et al., 2017; Engstrom et al., 2018; Carlini, 2019). This highlights the difficulty of evaluating adversarial robustness, as pointed out by other work which began to defeat proposed defenses en masse (Uesato et al., 2018; Athalye et al., 2018). Since then, several best practices have been proposed to mitigate this problem (Carlini et al., 2019).
+
+Despite the eventual defeat of other adversarial defenses, adversarial training with a PGD adversary remains empirically robust to this day. However, running a strong PGD adversary within an inner loop of training is expensive, and some earlier work in this topic found that taking larger but fewer steps did not always significantly change the resulting robustness of a network (Wang, 2018). To combat the increased computational overhead of the PGD defense, some recent work has looked at regressing the $k$ -step PGD adversary to a variation of its single-step FGSM predecessor called “free” adversarial training, which can be computed with little overhead over standard training by using a single backwards pass to simultaneously update both the model weights and also the input perturbation (Shafahi et al., 2019). Finally, when performing a multi-step PGD adversary, it is possible to cut out redundant calculations during backpropagation when computing adversarial examples for additional speedup (Zhang et al., 2019).
+
+Although these improvements are certainly faster than the standard adversarial training procedure, they are not much faster than traditional training methods, and can still take hours to days to compute. On the other hand, top performing training methods from the DAWNBench competition (Coleman et al., 2017) are able to train CIFAR10 and ImageNet architectures to standard benchmark metrics in mere minutes and hours respectively, using only a modest amount of computational resources. Although some of the techniques can be quite problem specific for achieving bleedingedge performance, more general techniques such as cyclic learning rates (Smith & Topin, 2018) and half-precision computations (Micikevicius et al., 2017) have been quite successful in the top ranking submissions, and can also be useful for adversarial training.
+
+# 3 ADVERSARIAL TRAINING OVERVIEW
+
+Adversarial training is a method for learning networks which are robust to adversarial attacks. Given a network $f _ { \theta }$ parameterized by $\theta$ , a dataset $( x _ { i } , y _ { i } )$ , a loss function $\ell$ and a threat model $\Delta$ , the learning problem is typically cast as the following robust optimization problem,
+
+$$
+\operatorname* { m i n } _ { \theta } \sum _ { i } \operatorname* { m a x } _ { \delta \in \Delta } \ell ( f _ { \theta } ( x _ { i } + \delta ) , y _ { i } ) .
+$$
+
+A typical choice for a threat model is to take $\Delta = \{ \delta : \| \delta \| _ { \infty } \leq \epsilon \}$ for some $\epsilon > 0$ . This is the $\ell _ { \infty }$ threat model used by Madry et al. (2017) and is the setting we study in this paper. The procedure for adversarial training is to use some adversarial attack to approximate the inner maximization over $\Delta$ , followed by some variation of gradient descent on the model parameters $\theta$ . For example, one of the earliest versions of adversarial training used the Fast Gradient Sign Method to approximate the inner maximization. This could be seen as a relatively inaccurate approximation of the inner maximization for $\ell _ { \infty }$ perturbations, and has the following closed form (Goodfellow et al., 2014):
+
+$$
+\delta ^ { \star } = \epsilon \cdot \mathrm { s i g n } \big ( \nabla _ { x } \ell ( f ( x ) , y ) \big ) .
+$$
+
+A better approximation of the inner maximization is to take multiple, smaller FGSM steps of size $\alpha$ instead. When the iterate leaves the threat model, it is projected back to the set $\Delta$ (for $\ell _ { \infty }$ perturbations. This is equivalent to clipping $\delta$ to the interval $[ - \epsilon , \epsilon ] )$ . Since this is only a local approximation of a non-convex function, multiple random restarts within the threat model $\Delta$ typically improve the approximation of the inner maximization even further. A combination of all these techniques is
+
+<table><tr><td>Algorithm 1 PGD adversarial training for T epochs, given some radius ∈,adversarial step size α and N PGD steps and a dataset of size M for a network fe</td></tr><tr><td>fort=1...Tdo fori=1...Mdo</td></tr><tr><td>// Perform PGD adversarial attack</td></tr><tr><td>δ = O // or randomly initialized for j=1...N do</td></tr><tr><td>δ=δ+α·sign(Vsl(fe(xi +δ),yi))</td></tr><tr><td>δ = max(min(δ,ε),-∈) end for</td></tr><tr><td>0 = 0 - Vθl(fe(xi + δ),yi) // Update model weights with some optimizer, e.g. SGD</td></tr><tr><td>end for end for</td></tr></table>
+
+Algorithm 2 “Free” adversarial training for $T$ epochs, given some radius , $N$ minibatch replays, and a dataset of size $M$ for a network $f _ { \theta }$
+
+$\delta = 0$   
+// Iterate T/N times to account for minibatch replays and run for T total epochs   
+for $t = 1 \ldots T / N$ do for $i = 1 \dots M$ do // Perform simultaneous FGSM adversarial attack and model weight updates $T$ times for $j = 1 \ldots N$ do // Compute gradients for perturbation and model weights simultaneously $\nabla _ { \boldsymbol { \delta } } , \nabla _ { \boldsymbol { \theta } } = \nabla \ell ( f _ { \boldsymbol { \theta } } ( x _ { i } + \boldsymbol { \delta } ) , y _ { i } )$ $\delta = \delta + \epsilon \cdot \mathrm { s i g n } ( \nabla _ { \delta } )$ $\delta = \operatorname* { m a x } ( \operatorname* { m i n } ( \delta , \epsilon ) , - \epsilon )$ $\theta = \theta - \nabla _ { \theta }$ // Update model weights with some optimizer, e.g. SGD end for end for   
+end for
+
+known as the PGD adversary (Madry et al., 2017), and its usage in adversarial training is summarized in Algorithm 1.
+
+Note that the number of gradient computations here is proportional to $O ( M N )$ in a single epoch, where $M$ is the size of the dataset and $N$ is the number of steps taken by the PGD adversary. This is $N$ times greater than standard training (which has $O ( M )$ gradient computations per epoch), and so adversarial training is typically $N$ times slower than standard training.
+
+# 3.1 “FREE” ADVERSARIAL TRAINING
+
+To get around this slowdown of a factor of $N$ , Shafahi et al. (2019) instead propose “free” adversarial training. This method takes FGSM steps with full step sizes $\alpha = \epsilon$ followed by updating the model weights for $N$ iterations on the same minibatch (also referred to as “minibatch replays”). The algorithm is summarized in Algorithm 2. Note that perturbations are not reset between minibatches. To account for the additional computational cost of minibatch replay, the total number of epochs is reduced by a factor of $N$ to make the total cost equivalent to $T$ epochs of standard training. Although “free” adversarial training is faster than the standard PGD adversarial training, it is not as fast as we’d like: Shafahi et al. (2019) need to run over 200 epochs in over 10 hours to learn a robust CIFAR10 classifier and two days to learn a robust ImageNet classifier, whereas standard training can be accomplished in minutes and hours for the same respective tasks.
+
+# 4 FAST ADVERSARIAL TRAINING
+
+To speed up adversarial training and move towards the state of the art in fast standard training methods, we first highlight the main empirical contribution of the paper: that FGSM adversarial training combined with random initialization is just as effective a defense as PGD-based training. Following this, we discuss several techniques from the DAWNBench competition (Coleman et al., 2017) that are applicable to all adversarial training methods, which reduce the total number of epochs needed for convergence with cyclic learning rates and further speed up computations with mixedprecision arithmetic.
+
+Algorithm 3 FGSM adversarial training for $T$ epochs, given some radius , $N$ PGD steps, step size $\alpha$ , and a dataset of size $M$ for a network $f _ { \theta }$   
+
+<table><tr><td>fort=1...Tdo fori=1...Mdo</td><td></td></tr><tr><td>//Perform FGSMadversarial attack</td><td></td></tr><tr><td>δ=Uniform(-∈,∈)</td><td></td></tr><tr><td>δ=δ+α·sign(Vsl(fe(xi+δ),yi))</td><td></td></tr><tr><td>δ = max(min(δ,ε),-∈)</td><td></td></tr><tr><td>end for</td><td>0 = 0- Vθl(fe(xi + δ),yi) // Update model weights with some optimizer, e.g. SGD</td></tr><tr><td>end for</td><td></td></tr></table>
+
+Table 1: Standard and robust performance of various adversarial training methods on CIFAR10 for $\epsilon = 8 / 2 5 5$ and their corresponding training times   
+
+<table><tr><td>Method</td><td>Standard accuracy</td><td>PGD (∈= 8/255)</td><td>Time (min)</td></tr><tr><td>FGSM+ DAWNBench</td><td></td><td></td><td></td></tr><tr><td>+ zero init</td><td>85.18%</td><td>0.00%</td><td>12.37</td></tr><tr><td>+ early stopping</td><td>71.14%</td><td>38.86%</td><td>7.89</td></tr><tr><td>+ previous init</td><td>86.02%</td><td>42.37%</td><td>12.21</td></tr><tr><td>+ random init</td><td>85.32%</td><td>44.01%</td><td>12.33</td></tr><tr><td>+ α = 10/255 step size</td><td>83.81%</td><td>46.06%</td><td>12.17</td></tr><tr><td>+ α = 16/255 step size</td><td>86.05%</td><td>0.00%</td><td>12.06</td></tr><tr><td>+ early stopping</td><td>70.93%</td><td>40.38%</td><td>8.81</td></tr><tr><td>“Free” (m= 8) (Shafahi et al.,2019)1</td><td>85.96%</td><td>46.33%</td><td>785</td></tr><tr><td>+ DAWNBench</td><td>78.38%</td><td>46.18%</td><td>20.91</td></tr><tr><td>PGD-7 (Madry et al., 2017)2</td><td>87.30%</td><td>45.80%</td><td>4965.71</td></tr><tr><td>+ DAWNBench</td><td>82.46%</td><td>50.69%</td><td>68.8</td></tr></table>
+
+# 4.1 REVISITING FGSM ADVERSARIAL TRAINING
+
+Despite being quite similar to FGSM adversarial training, free adversarial training is empirically robust against PGD attacks whereas FGSM adversarial training is not believed to be robust. To analyze why, we identify a key difference between the methods: a property of free adversarial training is that the perturbation from the previous iteration is used as the initial starting point for the next iteration. However, there is little reason to believe that an adversarial perturbation for a previous minibatch is a reasonable starting point for the next minibatch. As a result, we hypothesize that the main benefit comes from simply starting from a non-zero initial perturbation.
+
+In light of this difference, our approach is to use FGSM adversarial training with random initialization for the perturbation, as shown in Algorithm 3. We find that, in contrast to what was previously believed, this simple adjustment to FGSM adversarial training can be used as an effective defense on par with PGD adversarial training. Crucially, we find that starting from a non-zero initial perturbation is the primary driver for success, regardless of the actual initialization. In fact, both starting with the previous minibatch’s perturbation or initializing from a uniformly random perturbation allow FGSM adversarial training to succeed at being robust to full-strength PGD adversarial attacks. Note that randomized initialization for FGSM is not a new idea and was previously studied by Tramer et al. (2017). Crucially, Tram \` er et al. (2017) use a different, more restricted random initial- \` ization and step size, which does not result in models robust to full-strength PGD adversaries. A more detailed comparison of their approach with ours is in Appendix A.
+
+To test the effect of initialization in FGSM adversarial training, we train several models to be robust at a radius $\epsilon = 8 / 2 5 5$ on CIFAR10, starting with the most “pure” form of FGSM, which takes steps of size $\alpha = \epsilon$ from a zero-initialized perturbation. The results, given in Table 1, are consistent with the literature, and show that the model trained with zero-initialization is not robust against a PGD adversary. However, surprisingly, simply using a random or previous-minibatch initialization instead of a zero initialization actually results in reasonable robustness levels (with random initialization performing slightly better) that are comparable to both free and PGD adversarial training methods. The adversarial accuracies in Table 1 are calculated using a PGD adversary with 50 iterations, step size $\alpha = 2 / 2 5 5$ , and 10 random restarts. Specific optimization parameters used for training these models can be found in Appendix B.
+
+FGSM step size Note that an FGSM step with size $\alpha = \epsilon$ from a non-zero initialization is not guaranteed to lie on the boundary of the $\ell _ { \infty }$ ball, and so this defense could potentially be seen as too weak. We find that increasing the step size by a factor of 1.25 to $\alpha = 1 0 / 2 5 5$ further improved the robustness of the model so that it is on par with the best reported result from free adversarial training. However, we also found that forcing the resulting perturbation to lie on the boundary with a step size of $\alpha = 2 \epsilon$ resulted in catastrophic overfitting: it does not produce a model robust to adversarial attacks. These two failure modes (starting from a zero-initialized perturbation and generating perturbations at the boundary) may explain why previous attempts at FGSM adversarial training failed, as the model overfits to a restricted threat model, and is described in more detail in Section 5.4. A full curve showing the effect of a range of FGSM step sizes on the robust performance can be found in Appendix C.
+
+Computational complexity A second key difference between FGSM and free adversarial training is that the latter uses a single backwards pass to compute gradients for both the perturbation and the model weights while repeating the same minibatch $m$ times in a row, called “minibatch replay”. In comparison, the FGSM adversarial training does not need to repeat minibatches, but needs two backwards passes to compute gradients separately for the perturbation and the model weights. As a result, the computational complexity for an epoch of FGSM adversarial training is not truly free and is equivalent to two epochs of standard training.
+
+# 4.2 DAWNBENCH IMPROVEMENTS
+
+Although free adversarial training is of comparable cost per iteration to traditional standard training methods, it is not quite comparable in total cost to more recent advancements in fast methods for standard training. Notably, top submissions to the DAWNBench competition have shown that CIFAR10 and ImageNet classifiers can be trained at significantly quicker times and at much lower cost than traditional training methods. Although some of the submissions can be quite unique in their approaches, we identify two generally applicable techniques which have a significant impact on the convergence rate and computational speed of standard training.
+
+Cyclic learning rate Introduced by Smith (2017) for improving convergence and reducing the amount of tuning required when training networks, a cyclic schedule for a learning rate can drastically reduce the number of epochs required for training deep networks (Smith & Topin, 2018). A simple cyclic learning rate schedules the learning rate linearly from zero, to a maximum learning rate, and back down to zero (examples can be found in Figure 1). Using a cyclic learning rate allows CIFAR10 architectures to converge to benchmark accuracies in tens of epochs instead of hundreds, and is a crucial component of some of the top DAWNBench submissions.
+
+Mixed-precision arithmetic With newer GPU architectures coming with tensor cores specifically built for rapid half-precision calculations, using mixed-precision arithmetic when training deep networks can also provide significant speedups for standard training (Micikevicius et al., 2017). This can drastically reduce the memory utilization, and when tensor cores are available, also reduce runtime. In some DAWNBench submissions, switching to mixed-precision computations was key to achieving fast training while keeping costs low.
+
+![](images/2d5e9c39d0474672bdef40131c28969bd68a9e2c32dfc5142d5be8b030760579.jpg)  
+Figure 1: Cyclic learning rates used for FGSM adversarial training on CIFAR10 and ImageNet over epochs. The ImageNet cyclic schedule is decayed further by a factor of 10 in the second and third phases.
+
+Table 2: Robustness of FGSM and PGD adversarial training on MNIST   
+
+<table><tr><td>Method</td><td>Standard accuracy</td><td>PGD (ε = 0.1)</td><td>PGD (ε = 0.3)</td><td>Verified (ε = 0.1)</td></tr><tr><td>PGD</td><td>99.20%</td><td>97.66%</td><td>89.90%</td><td>96.7%</td></tr><tr><td>FGSM</td><td>99.20%</td><td>97.53%</td><td>88.77%</td><td>96.8%</td></tr></table>
+
+We adopt these two techniques for use in adversarial training, which allows us to drastically reduce the number of training epochs as well as the runtime on GPU infrastructure with tensor cores, while using modest amounts of computational resources. Notably, both of these improvements can be easily applied to existing implementations of adversarial training by adding a few lines of code with very little additional engineering effort, and so are easily accessible by the general research community.
+
+# 5 EXPERIMENTS
+
+To demonstrate the effectiveness of FGSM adversarial training with fast training methods, we run a number of experiments on MNIST, CIFAR10, and ImageNet benchmarks. All CIFAR10 experiments in this paper are run on a single GeForce RTX 2080ti using the PreAct ResNet18 architecture, and all ImageNet experiments are run on a single machine with four GeForce RTX 2080tis using the ResNet50 architecture (He et al., 2016). Repositories for reproducing all experiments and the corresponding trained model weights are available at https://github.com/locuslab/fast_ adversarial.
+
+All experiments using FGSM adversarial training in this section are carried out with random initial starting points and step size $\alpha = 1 . 2 5 \epsilon$ as described in Section 4.1. All PGD adversaries used at evaluation are run with 10 random restarts for 50 iterations (with the same hyperparameters as those used by Shafahi et al. (2019) but further strengthened with random restarts). Speedup with mixedprecision was incorporated with the Apex amp package at the O1 optimization level for ImageNet experiments and O2 without loss scaling for CIFAR10 experiments.3
+
+# 5.1 VERIFIED PERFORMANCE ON MNIST
+
+Since the FGSM attack is known to be significantly weaker than the PGD attack, it is understandable if the reader is still skeptical of the true robustness of the models trained using this method. To demonstrate that FGSM adversarial training confers real robustness to the model, in addition to evaluating against a PGD adversary, we leverage mixed-integer linear programming (MILP) methods from formal verification to calculate the exact robustness of small, but verifiable models (Tjeng et al., 2017). We train two convolutional networks with 16 and 32 convolutional filters followed by a fully connected layer of 100 units, the same architecture used by Tjeng et al. (2017). We use both PGD and FGSM adversarial training at $\epsilon = 0 . 3$ , where the PGD adversary for training has 40 iterations with step size 0.01 as done by Madry et al. (2017). The exact verification results can be seen in Table 2, where we find that FGSM adversarial training confers empirical and verified robustness which is nearly indistinguishable to that of PGD adversarial training on MNIST.4
+
+![](images/b00d6eb5af7a8fe3ce93e02453db494ae8ae55edcabe39e69549c6716302c36b.jpg)  
+Figure 2: Performance of models trained on CIFAR10 at $\epsilon = 8 / 2 5 5$ with cyclic learning rates and half precision, given varying numbers of epochs across different adversarial training methods. Each point denotes the average model performance over 3 independent runs, where the $x$ axis denotes the number of epochs $N$ the model was trained for, and the $y$ axis denotes the resulting accuracy. The orange dots measure accuracy on natural images and the blue dots plot the empirical robust accuracy on adversarial images. The vertical dotted line indicates the minimum number of epochs needed to train a model to $45 \%$ robust accuracy.
+
+Table 3: Time to train a robust CIFAR10 classifier to $45 \%$ robust accuracy using various adversarial training methods with the DAWNBench techniques of cyclic learning rates and mixed-precision arithmetic, showing significant speedups for all forms of adversarial training.   
+
+<table><tr><td>Method</td><td>Epochs</td><td>Seconds/epoch</td><td>Total time (minutes)</td></tr><tr><td>DAWNBench +PGD-7</td><td>10</td><td>104.94</td><td>17.49</td></tr><tr><td>DAWNBench + Free (m = 8)</td><td>80</td><td>13.08</td><td>17.44</td></tr><tr><td>DAWNBench + FGSM</td><td>15</td><td>25.36</td><td>6.34</td></tr><tr><td>PGD-7 (Madry et al., 2017)5</td><td>205</td><td>1456.22</td><td>4965.71</td></tr><tr><td>Free (m = 8) (Shafahi et al.,2019)6</td><td>205</td><td>197.77</td><td>674.39</td></tr></table>
+
+# 5.2 FAST CIFAR10
+
+We begin our CIFAR10 experiments by combining the DAWNBench improvements from Section 4.2 with various forms of adversarial training. For $N$ epochs, we use a cyclic learning rate that increases linearly from 0 to $\lambda$ over the first $N / 2$ epochs, then decreases linearly from $\lambda$ to 0 for the remaining epochs, where $\lambda$ is the maximum learning rate. For each method, we individually tune $\lambda$ to be as large as possible without causing the training loss to diverge, which is the recommended learning rate test from Smith & Topin (2018).
+
+To identify the minimum number of epochs needed for each adversarial training method, we repeatedly run each method over a range of maximum epochs $N$ , and then plot the final robustness of each trained model in Figure 2. While all the adversarial training methods benefit greatly from the cyclic learning rate schedule, we find that both FGSM and PGD adversarial training require much fewer epochs than free adversarial training, and consequently reap the greatest speedups.
+
+Table 4: Imagenet classifiers trained with adversarial training methods at $\epsilon = 2 / 2 5 5$ and $\epsilon = 4 / 2 5 5$ .   
+
+<table><tr><td>Method</td><td>E</td><td>Standard acc.</td><td>PGD+1 restart</td><td>PGD+10 restarts</td><td>Total time (hrs)</td></tr><tr><td rowspan="2">FGSM Free (m = 4)</td><td>2/255</td><td>60.90%</td><td>43.46%</td><td>43.43%</td><td>12.14</td></tr><tr><td>2/255</td><td>64.37%</td><td>43.31%</td><td>43.28%</td><td>52.20</td></tr><tr><td>FGSM</td><td>4/255</td><td>55.45%</td><td>30.28%</td><td>30.18%</td><td>12.14</td></tr><tr><td>Free (m = 4)</td><td>4/255</td><td>60.42%</td><td>31.22%</td><td>31.08%</td><td>52.20</td></tr></table>
+
+Table 5: Time to train a robust ImageNet classifier using various fast adversarial training methods   
+
+<table><tr><td>Method</td><td>Precision</td><td>Epochs</td><td>Min/epoch</td><td>Total time (hrs)</td></tr><tr><td>FGSM (phase 1)</td><td>single</td><td>6</td><td>22.65</td><td>2.27</td></tr><tr><td>FGSM (phase 2)</td><td>single</td><td>6</td><td>65.97</td><td>6.60</td></tr><tr><td>FGSM (phase 3)</td><td>single</td><td>3</td><td>114.45</td><td>5.72</td></tr><tr><td>FGSM</td><td>single</td><td>15</td><td>-</td><td>14.59</td></tr><tr><td>Free (m = 4)</td><td>single</td><td>92</td><td>34.04</td><td>52.20</td></tr><tr><td>FGSM (phase 1)</td><td>mixed</td><td>6</td><td>20.07</td><td>2.01</td></tr><tr><td>FGSM (phase 2)</td><td>mixed</td><td>6</td><td>53.39</td><td>5.34</td></tr><tr><td>FGSM (phase 3)</td><td>mixed</td><td>3</td><td>95.93</td><td>4.80</td></tr><tr><td>FGSM</td><td>mixed</td><td>15</td><td>1</td><td>12.14</td></tr><tr><td>Free (m = 4)</td><td>mixed</td><td>92</td><td>25.28</td><td>38.76</td></tr></table>
+
+Using the minimum number of epochs needed for each training method to reach a baseline of $45 \%$ robust accuracy, we report the total training time in Table 3. We find that while all adversarial training methods benefit from the DAWNBench improvements, FGSM adversarial training is the fastest, capable of learning a robust CIFAR10 classifier in 6 minutes using only 15 epochs. Interestingly, we also find that PGD and free adversarial training take comparable amounts of time, largely because free adversarial training does not benefit from the cyclic learning rate as much as PGD or FGSM adversarial training.
+
+# 5.3 FAST IMAGENET
+
+Finally, we apply all of the same techniques (FGSM adversarial training, mixed-precision, and cyclic learning rate) on the ImageNet benchmark. In addition, the top submissions from the DAWNBench competition for ImageNet utilize two more improvements on top of this, the first of which is the removal of weight decay regularization from batch normalization layers. The second addition is to progressively resize images during training, starting with larger batches of smaller images in the beginning and moving on to smaller batches of larger images later. Specifically, training is divided into three phases, where phases 1 and 2 use images resized to 160 and 352 pixels respectively, and phase 3 uses the entire image. We train models to be robust at $\epsilon = 2 / 2 5 5$ and $\epsilon = 4 / 2 5 5$ and compare to free adversarial training in Table 4, showing similar levels of robustness. In addition to using ten restarts, we also report the PGD accuracy with one restart to reproduce the evaluation done by Shafahi et al. (2019).
+
+With these techniques, we can train an ImageNet classifier using 15 epochs in 12 hours using FGSM adversarial training, taking a fraction of the cost of free adversarial training as shown in Table 5.7 We compare to the best performing variation of free adversarial training which which uses $m = 4$ minibatch replays over 92 epochs of training (scaled down accordingly to 23 passes over the data). Note that free adversarial training can also be enhanced with mixed-precision arithmetic, which reduces the runtime by $2 5 \%$ , but is still slower than FGSM-based training. Directly combining free adversarial training with the other fast techniques used in FGSM adversarial training for ImageNet results in reduced performance which we describe in Appendix F.
+
+# 5.4 CATASTROPHIC OVERFITTING
+
+While FGSM adversarial training works in the context of this paper, many other researchers have tried and failed to have FGSM adversarial training work. In addition to using a zero initialization or too large of a step size as seen in Table 1, other design decisions (like specific learning rate schedules or numbers of epochs) for the training procedure can also make it more likely for FGSM adversarial training to fail. However, all of these failure modes result in what we call “catastrophic overfitting”, where the robust accuracy with respect to a PGD adversarial suddenly and drastically drops to $0 \%$ (on the training data). Due to the rapid deterioration of robust performance, these alternative versions of FGSM adversarial training can be salvaged to some degree with a simple early-stopping scheme by measuring PGD accuracy on a small minibatch of training data, and the recovered results for some of these failure modes are shown in Table 1. Catastrophic overfitting and the early-stopping scheme are discussed in more detail in Appendix D.
+
+# 5.5 TAKEAWAYS FROM FGSM ADVERSARIAL TRAINING
+
+While it may be surprising that FGSM adversarial training can result in robustness to full PGD adversarial attacks, this work highlights some empirical hypotheses and takeaways which we describe below.
+
+1. Adversarial examples need to span the entire threat model. One of the reasons why FGSM and $\mathrm { R + F G S M }$ as done by Tramer et al. (2017) may have failed is due to the restricted nature \` of the generated examples: the restricted (or lack of) initialization results in perturbations which perturb each dimension by either 0 or $\pm \epsilon .$ , and so adversarial examples with feature perturbations in between are never seen. This is discussed further in Appendix D. 2. Defenders don’t need strong adversaries during training. This work suggests that rough approximations to the inner optimization problem are sufficient for adversarial training. This is in contrast to the usage of strong adversaries at evaluation time, where it is standard practice to use multiple restarts and a large number of PGD steps.
+
+# 6 CONCLUSION
+
+Our findings show that FGSM adversarial training, when used with random initialization, can in fact be just as effective as the more costly PGD adversarial training. While a single iteration of FGSM adversarial training is double the cost of free adversarial training, it converges significantly faster, especially with a cyclic learning rate schedule. As a result, we are able to learn adversarially robust classifiers for CIFAR10 in minutes and for ImageNet in hours, even faster than free adversarial training but with comparable levels of robustness. We believe that leveraging these significant reductions in time to train robust models will allow future work to iterate even faster, and accelerate research in learning models which are resistant to adversarial attacks. By demonstrating that extremely weak adversarial training is capable of learning robust models, this work also exposes a new potential direction in more rigorously explaining when approximate solutions to the inner optimization problem are sufficient for robust optimization, and when they fail.
+
+# REFERENCES
+
+Anish Athalye, Logan Engstrom, Andrew Ilyas, and Kevin Kwok. Synthesizing robust adversarial examples. arXiv preprint arXiv:1707.07397, 2017.
+
+Anish Athalye, Nicholas Carlini, and David Wagner. Obfuscated gradients give a false sense of security: Circumventing defenses to adversarial examples. arXiv preprint arXiv:1802.00420, 2018.
+
+Jacob Buckman, Aurko Roy, Colin Raffel, and Ian Goodfellow. Thermometer encoding: One hot way to resist adversarial examples. 2018.
+
+Nicholas Carlini. Is ami (attacks meet interpretability) robust to adversarial examples? arXiv preprint arXiv:1902.02322, 2019.
+
+Nicholas Carlini and David Wagner. Defensive distillation is not robust to adversarial examples. arXiv preprint arXiv:1607.04311, 2016.
+
+Nicholas Carlini and David Wagner. Adversarial examples are not easily detected: Bypassing ten detection methods. In Proceedings of the 10th ACM Workshop on Artificial Intelligence and Security, pp. 3–14. ACM, 2017a.
+
+Nicholas Carlini and David Wagner. Towards evaluating the robustness of neural networks. In 2017 IEEE Symposium on Security and Privacy (SP), pp. 39–57. IEEE, 2017b.
+
+Nicholas Carlini, Anish Athalye, Nicolas Papernot, Wieland Brendel, Jonas Rauber, Dimitris Tsipras, Ian Goodfellow, and Aleksander Madry. On evaluating adversarial robustness. arXiv preprint arXiv:1902.06705, 2019.
+
+Jeremy M Cohen, Elan Rosenfeld, and J Zico Kolter. Certified adversarial robustness via randomized smoothing. arXiv preprint arXiv:1902.02918, 2019.
+
+Cody Coleman, Deepak Narayanan, Daniel Kang, Tian Zhao, Jian Zhang, Luigi Nardi, Peter Bailis, Kunle Olukotun, Chris Re, and Matei Zaharia. Dawnbench: An end-to-end deep learning bench-´ mark and competition. Training, 100(101):102, 2017.
+
+Francesco Croce, Maksym Andriushchenko, and Matthias Hein. Provable robustness of relu networks via maximization of linear regions. arXiv preprint arXiv:1810.07481, 2018.
+
+Yinpeng Dong, Fangzhou Liao, Tianyu Pang, Hang Su, Jun Zhu, Xiaolin Hu, and Jianguo Li. Boosting adversarial attacks with momentum. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 9185–9193, 2018.
+
+Logan Engstrom, Andrew Ilyas, and Anish Athalye. Evaluating and understanding the robustness of adversarial logit pairing. arXiv preprint arXiv:1807.10272, 2018.
+
+Reuben Feinman, Ryan R Curtin, Saurabh Shintre, and Andrew B Gardner. Detecting adversarial samples from artifacts. arXiv preprint arXiv:1703.00410, 2017.
+
+Ian J Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. arXiv preprint arXiv:1412.6572, 2014.
+
+Sven Gowal, Krishnamurthy Dvijotham, Robert Stanforth, Rudy Bunel, Chongli Qin, Jonathan Uesato, Timothy Mann, and Pushmeet Kohli. On the effectiveness of interval bound propagation for training verifiably robust models. arXiv preprint arXiv:1810.12715, 2018.
+
+Chuan Guo, Mayank Rana, Moustapha Cisse, and Laurens Van Der Maaten. Countering adversarial images using input transformations. arXiv preprint arXiv:1711.00117, 2017.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 770–778, 2016.
+
+Harini Kannan, Alexey Kurakin, and Ian Goodfellow. Adversarial logit pairing. arXiv preprint arXiv:1803.06373, 2018.
+
+Guy Katz, Clark Barrett, David L Dill, Kyle Julian, and Mykel J Kochenderfer. Reluplex: An efficient smt solver for verifying deep neural networks. In International Conference on Computer Aided Verification, pp. 97–117. Springer, 2017.
+
+Alexey Kurakin, Ian Goodfellow, and Samy Bengio. Adversarial examples in the physical world. arXiv preprint arXiv:1607.02533, 2016.
+
+Jiajun Lu, Hussein Sibai, Evan Fabry, and David Forsyth. No need to worry about adversarial examples in object detection in autonomous vehicles. arXiv preprint arXiv:1707.03501, 2017.
+
+Aleksander Madry, Aleksandar Makelov, Ludwig Schmidt, Dimitris Tsipras, and Adrian Vladu. Towards deep learning models resistant to adversarial attacks. arXiv preprint arXiv:1706.06083, 2017.
+
+Pratyush Maini, Eric Wong, and J Zico Kolter. Adversarial robustness against the union of multiple perturbation models. arXiv preprint arXiv:1909.04068, 2019.
+
+Jan Hendrik Metzen, Tim Genewein, Volker Fischer, and Bastian Bischoff. On detecting adversarial perturbations. arXiv preprint arXiv:1702.04267, 2017.
+
+Paulius Micikevicius, Sharan Narang, Jonah Alben, Gregory Diamos, Erich Elsen, David Garcia, Boris Ginsburg, Michael Houston, Oleksii Kuchaiev, Ganesh Venkatesh, et al. Mixed precision training. arXiv preprint arXiv:1710.03740, 2017.
+
+Matthew Mirman, Timon Gehr, and Martin Vechev. Differentiable abstract interpretation for provably robust neural networks. In International Conference on Machine Learning, pp. 3575–3583, 2018.
+
+Marius Mosbach, Maksym Andriushchenko, Thomas Trost, Matthias Hein, and Dietrich Klakow. Logit pairing methods can fool gradient-based attacks. arXiv preprint arXiv:1810.12042, 2018.
+
+Nicolas Papernot, Patrick McDaniel, Xi Wu, Somesh Jha, and Ananthram Swami. Distillation as a defense to adversarial perturbations against deep neural networks. In 2016 IEEE Symposium on Security and Privacy $( S P )$ , pp. 582–597. IEEE, 2016.
+
+Aditi Raghunathan, Jacob Steinhardt, and Percy S Liang. Semidefinite relaxations for certifying robustness to adversarial examples. In Advances in Neural Information Processing Systems, pp. 10877–10887, 2018.
+
+Hadi Salman, Greg Yang, Jerry Li, Pengchuan Zhang, Huan Zhang, Ilya Razenshteyn, and Sebastien Bubeck. Provably robust deep learning via adversarially trained smoothed classifiers. arXiv preprint arXiv:1906.04584, 2019.
+
+Ali Shafahi, Mahyar Najibi, Amin Ghiasi, Zheng Xu, John Dickerson, Christoph Studer, Larry S Davis, Gavin Taylor, and Tom Goldstein. Adversarial training for free! arXiv preprint arXiv:1904.12843, 2019.
+
+Aman Sinha, Hongseok Namkoong, and John Duchi. Certifying some distributional robustness with principled adversarial training. arXiv preprint arXiv:1710.10571, 2017.
+
+Leslie N Smith. Cyclical learning rates for training neural networks. In 2017 IEEE Winter Conference on Applications of Computer Vision (WACV), pp. 464–472. IEEE, 2017.
+
+Leslie N Smith and Nicholay Topin. Super-convergence: Very fast training of residual networks using large learning rates. 2018.
+
+Yang Song, Taesup Kim, Sebastian Nowozin, Stefano Ermon, and Nate Kushman. Pixeldefend: Leveraging generative models to understand and defend against adversarial examples. arXiv preprint arXiv:1710.10766, 2017.
+
+Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. arXiv preprint arXiv:1312.6199, 2013.
+
+Guanhong Tao, Shiqing Ma, Yingqi Liu, and Xiangyu Zhang. Attacks meet interpretability: Attribute-steered detection of adversarial samples. In Advances in Neural Information Processing Systems, pp. 7717–7728, 2018.
+
+Vincent Tjeng, Kai Xiao, and Russ Tedrake. Evaluating robustness of neural networks with mixed integer programming. arXiv preprint arXiv:1711.07356, 2017.
+
+Florian Tramer and Dan Boneh. Adversarial training and robustness for multiple perturbations. \` arXiv preprint arXiv:1904.13000, 2019.
+
+Florian Tramer, Alexey Kurakin, Nicolas Papernot, Ian Goodfellow, Dan Boneh, and Patrick Mc- \` Daniel. Ensemble adversarial training: Attacks and defenses. arXiv preprint arXiv:1705.07204, 2017.
+
+Jonathan Uesato, Brendan O’Donoghue, Aaron van den Oord, and Pushmeet Kohli. Adversarial risk and the dangers of evaluating against weak attacks. arXiv preprint arXiv:1802.05666, 2018.
+
+Jianyu Wang. Bilateral adversarial training: Towards fast training of more robust models against adversarial attacks. arXiv preprint arXiv:1811.10716, 2018.
+
+Eric Wong and J Zico Kolter. Provable defenses against adversarial examples via the convex outer adversarial polytope. arXiv preprint arXiv:1711.00851, 2017.
+
+Eric Wong, Frank Schmidt, Jan Hendrik Metzen, and J Zico Kolter. Scaling provable adversarial defenses. In Advances in Neural Information Processing Systems, pp. 8400–8409, 2018.
+
+Kai Y Xiao, Vincent Tjeng, Nur Muhammad Shafiullah, and Aleksander Madry. Training for faster adversarial robustness verification via inducing relu stability. arXiv preprint arXiv:1809.03008, 2018.
+
+Yuzhe Yang, Guo Zhang, Dina Katabi, and Zhi Xu. Me-net: Towards effective adversarial robustness with matrix estimation. arXiv preprint arXiv:1905.11971, 2019.
+
+Dinghuai Zhang, Tianyuan Zhang, Yiping Lu, Zhanxing Zhu, and Bin Dong. You only propagate once: Painless adversarial training using maximal principle. arXiv preprint arXiv:1905.00877, 2019.
+
+Table 6: Ablation study showing the performance of $\mathrm { R + F G S M }$ from Tramer et al. (2017) and the \` various changes for the version of FGSM adversarial training done in this paper, over 10 random seeds.   
+
+<table><tr><td>Method</td><td>Step size</td><td>Initialization</td><td>Robust accuracy</td></tr><tr><td>R+FGSM (Tramer et al., 2017)</td><td>0.15</td><td>Hypercube(0.15)</td><td>34.58 ± 36.06%</td></tr><tr><td>R+FGSM (+full step size)</td><td>0.30</td><td>Hypercube(0.15)</td><td>26.53 ± 32.48%</td></tr><tr><td>R+FGSM(+uniform init.)</td><td>0.15</td><td>Uniform(0.3)</td><td>72.92 ±10.40%</td></tr><tr><td>Uniform + full (ours)</td><td>0.30</td><td>Uniform(0.3)</td><td>86.21 ± 00.75%</td></tr></table>
+
+Table 7: Training parameters used for the DAWNBench experiments of Table 1   
+
+<table><tr><td>Parameter</td><td>FGSM</td><td>PGD</td><td>Free</td></tr><tr><td>Epochs</td><td>30</td><td>40</td><td>96</td></tr><tr><td>Max learning rate</td><td>0.2</td><td>0.2</td><td>0.04</td></tr></table>
+
+# A A DIRECT COMPARISON TO $\mathrm { R + F G S M }$ FROM TRAMER ET AL \` . (2017)
+
+While a randomized version of FGSM adversarial training was proposed by Tramer et al. (2017), it \` was not shown to be as effective as adversarial training against a PGD adversary. Here, we note the two main differences between our approach and that of Tramer et al. (2017). \`
+
+1. The random initialization used is different. For a data point $x$ , we initialize with the uniform distribution in the entire perturbation region with
+
+$$
+x ^ { \prime } = x + \mathrm { U n i f o r m } ( - \epsilon , \epsilon ) .
+$$
+
+In comparison, Tramer et al. (2017) instead initialize on the surface of a hypercube with \` radius $\epsilon / 2$ with
+
+$$
+x ^ { \prime } = x + \frac { \epsilon } { 2 } \mathrm { N o r m a l } ( 0 , 1 ) .
+$$
+
+2. The step sizes used for the FGSM step are different. We use a full step size of $\alpha = \epsilon$ whereas Tramer et al. (2017) use a step size of \` $\alpha = \epsilon / 2$ .
+
+To study the effect of these two differences, we run all combinations of either initialization with either step size on MNIST. The results are summarized in Table 6.
+
+We find that using a uniform initialization adds the greatest marginal improvement to the original $\mathrm { R + F G S M }$ attack, while using a full step size doesn’t seem to help on its own. Implementing both of these improvements results in the form of FGSM adversarial training presented in this paper. Additionally, note that $\mathrm { R + F G S M }$ as done by Tramer et al. (2017) has high variance in robust perfor- \` mance when done over multiple random seeds, whereas our version of FGSM adversarial training is significantly more consistent and has a very low standard deviation over random seeds.
+
+# B TRAINING PARAMETERS FOR TABLE 1
+
+For all methods, we use a batch size of 128, and SGD optimizer with momentum 0.9 and weight decay $5 * 1 0 ^ { - 4 }$ . We report the average results over 3 random seeds. The remaining parameters for learning rate schedules and number of epochs for the DAWNBench experiments are in Table 7. For runs using early-stopping, we use a 5-step PGD adversary with 1 restart on 1 training minibatch to detect overfitting to the FGSM adversaries, as described in more detail in Section D.
+
+![](images/d1bba9c25633d8962669c3935a2f3466ef9e4efb4a4924d48415fa31a1a505e2.jpg)  
+Figure 3: Robust test performance of FGSM adversarial training over different step sizes for $\epsilon =$ 8/255.
+
+![](images/438b9fa287165347faded06d7f88a2848edd6e8d301f039a22b62f0e9f54a0e1.jpg)  
+Figure 4: Learning curves for FGSM adversarial training plotting the training loss and error rates incurred by an FGSM and PGD adversary when trained with zero-initialization FGSM at $\epsilon = 8 / 2 5 5$ , depicting the catastrophic overfitting where PGD performance suddenly degrades while the model overfits to the FGSM performance.
+
+# C OPTIMAL STEP SIZE FOR FGSM ADVERSARIAL TRAINING
+
+Here, we test the effect of step size on the performance of FGSM adversarial training. We plot the mean and standard error of the robust accuracy for models trained for 30 epochs over 3 random seeds in Figure 3, and vary the step size from $\alpha = 1 / 2 5 5$ to $\alpha = 1 6 / 2 5 5$ .
+
+We find that we get increasing robust performance as we increase the step size up to $\alpha = 1 0 / 2 5 5$ . Beyond this, we see no further benefit, or find that the model is prone to overfitting to the adversarial examples, since the large step size forces the model to overfit to the boundary of the perturbation region.
+
+# D CATASTROPHIC OVERFITTING AND THE EFFECT OF EARLY STOPPING
+
+While the main experiments in this paper work as is (with the cyclic learning rate and FGSM adversarial training with uniform random initialization), many of the variations of FGSM adversarial training which have been found to not succeed all fail similarly: the model will very rapidly (over the span of a couple epochs) appear to overfit to the FGSM adversarial examples. What was previously a reasonably robust model will quickly transform into a non-robust model which suffers $0 \%$ robust accuracy (with respect to a PGD adversary). This phenomenon, which we call catastrophic overfitting, can be seen in Figure 4 which plots the learning curves for standard, vanilla FGSM adversarial training from zero-initialization.
+
+Indeed, one of the reasons for this failure may lie in the lack of diversity in adversarial examples generated by these FGSM adversaries. For example, using a zero initialization or using the random initialization scheme from Tramer et al. (2017) will result in adversarial examples whose features \` have been perturbed by $\{ - \epsilon , 0 , \epsilon \}$ , and so the network learns a decision boundary which is robust only at these perturbation values. This can be verified by running a PGD adversarial attack on models which have catastrophically overfitted, where the perturbations tend to be more in between the origin and the boundary of the threat model (relative to a non-overfitted model, which tends to have perturbations near the boundary), as seen in Figure 5.
+
+![](images/aa3c7e3e733e662e25a53af4ba6b880dc993f15eb191c30368308466f3cb59bc.jpg)  
+Figure 5: Histogram of the resulting perturbations from a PGD adversary for each feature for a successfully trained robust CIFAR10 model and a catastrophically overfitted CIFAR10 model.
+
+![](images/35c4e3ab49eb82d71b381ff6080bbec6986a6fc80d5b8dbfb23fdf77aee5f45d.jpg)  
+Figure 6: Robust test performance of FGSM adversarial training over different step sizes for $\epsilon =$ $8 / 2 5 5$ with early stopping to avoid catastrophic overfitting.
+
+These failure modes, including the other failure modes discussed in Section 5.4, can be easily detected by evaluating the PGD performance on a small subset of the training data, as the catastrophic failure will result in $0 \%$ robust accuracy for a PGD adversary on the training set. In practice, we find that this can be a simple as a single minibatch with a 5-step PGD adversary, which can be quickly checked at the end of the epoch. If robust accuracy with respect to this adversary suddenly drops, then we have catastrophic overfitting. Using a PGD adversary on a training minibatch to detect catastrophic overfitting, we can early stop to avoid catastrophic overfitting and achieve a reasonable amount of robust performance.
+
+For a concrete example, recall from Section C that step sizes larger than $1 1 / 2 5 5$ result in $0 \%$ robust accuracy, due to this catastrophic overfitting phenomenon. By using early stopping to catch the model at its peak performance before overfitting, FGSM adversarial training with larger step sizes can actually achieve some degree of robust accuracy, as shown in Figure 6.
+
+Table 8: Training parameters used for Figure 2   
+
+<table><tr><td>Parameter</td><td>FGSM</td><td>PGD</td><td>Free</td></tr><tr><td>Max learning rate</td><td>0.2</td><td>0.2</td><td>0.04</td></tr></table>
+
+Table 9: ImageNet classifiers trained with free adversarial training methods at $m = 3$ minibatch replay when augmented with DAWNBench optimizations, against $\ell _ { \infty }$ perturbations of radius $\epsilon =$ 4/255, where 30 epochs of free training is equivalent to 15 epochs of FGSM training   
+
+<table><tr><td>Method</td><td>Step size</td><td>Epochs</td><td>Standard acc.</td><td>PGD+1</td><td>PGD+10</td></tr><tr><td>Free+DAWNBench</td><td>4/255</td><td>15</td><td>49.87%</td><td>22.78%</td><td>22.18%</td></tr><tr><td>Free+DAWNBench</td><td>5/255</td><td>15</td><td>50.48%</td><td>22.88%</td><td>22.25%</td></tr><tr><td>Free+DAWNBench</td><td>4/255</td><td>30</td><td>49.87%</td><td>28.17%</td><td>27.08%</td></tr><tr><td>Free+DAWNBench</td><td>5/255</td><td>30</td><td>50.48%</td><td>28.73%</td><td>27.81%</td></tr><tr><td>Free (m = 4)</td><td>4/255</td><td>92</td><td>60.42%</td><td>31.22%</td><td>31.08%</td></tr><tr><td>FGSM</td><td>5/255</td><td>15</td><td>55.45%</td><td>30.28%</td><td>30.18%</td></tr></table>
+
+# E TRAINING PARAMETERS FOR FIGURE 2
+
+For all methods, we use a batch size of 128, and SGD optimizer with momentum 0.9 and weight decay $5 * 1 0 ^ { - 4 }$ . We report the average results over 3 random seeds. Maximum learning rates used for the cyclic learning rate schedule are shown in Table 8.
+
+# F COMBINING FREE ADVERSARIAL TRAINING WITH DAWNBENCH IMPROVEMENTS ON IMAGENET
+
+While adding mixed-precision is a direct speedup to free adversarial training without hurting performance, using other optimization tricks such as the cyclic learning rate schedule, progressive resizing, and batch-norm regularization may affect the final performance of free adversarial training. Since ImageNet is too large to run a comprehensive search over the various parameters as was done for CIFAR10 in Table 3, we instead test the performance of free adversarial training when used as a drop-in replacement for FGSM adversarial training with all the same optimizations used for FGSM adversarial training. We use free adversarial training with $m = 3$ minibatch-replay, with 2 epochs for phase one, 2 epochs for phase two, and 1 epoch for phase three to be equivalent to 15 epochs of standard training. $\mathrm { P G D } { + } N$ denotes the accuracy under a PGD adversary with $N$ restarts.
+
+A word of caution: this is not to claim that free adversarial training is completely incompatible with the DAWNBench optimizations on ImageNet. By giving free adversarial training more epochs, it may be possible recover the same or better performance. However, tuning the DAWNBench techniques to be optimal for free adversarial training is not the objective of this paper, and so this is merely to show what happens if we naively apply the same DAWNBench tricks used for FGSM adversarial training to free adversarial training. Since free adversarial training requires more epochs even when tuned with DAWNBench improvements for CIFAR10, we suspect that the same behavior occurs here for ImageNet, and so 15 epochs is likely not enough to obtain top performance for free adversarial training. Since one epoch of FGSM adversarial training is equivalent to two epochs of free training, a fairer comparison is to give free adversarial training 30 epochs instead of 15. Even with double the epochs (and thus the same compute time as FGSM adversarial training), we find that it gets closer but doesn’t quite recover the original performance of free adversarial training.

parse/train/BJx040EFvH/BJx040EFvH_content_list.json

@@ -0,0 +1,1849 @@
+[
+    {
+        "type": "text",
+        "text": "FAST IS BETTER THAN FREE: REVISITING ADVERSARIAL TRAINING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            101,
+            627,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Eric Wong∗ Machine Learning Department Carnegie Mellon University Pittsburgh, PA 15213, USA ericwong@cs.cmu.edu ",
+        "bbox": [
+            183,
+            170,
+            387,
+            239
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Leslie Rice∗ Computer Science Department Carnegie Mellon University Pittsburgh, PA 15213, USA larice@cs.cmu.edu ",
+        "bbox": [
+            611,
+            170,
+            813,
+            239
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "J. Zico Kolter ",
+        "text_level": 1,
+        "bbox": [
+            184,
+            261,
+            281,
+            275
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Computer Science Department Carnegie Mellon University and Bosch Center for Artifical Intelligence Pittsburgh, PA 15213, USA zkolter@cs.cmu.edu ",
+        "bbox": [
+            184,
+            275,
+            436,
+            343
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            381,
+            544,
+            396
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Adversarial training, a method for learning robust deep networks, is typically assumed to be more expensive than traditional training due to the necessity of constructing adversarial examples via a first-order method like projected gradient decent (PGD). In this paper, we make the surprising discovery that it is possible to train empirically robust models using a much weaker and cheaper adversary, an approach that was previously believed to be ineffective, rendering the method no more costly than standard training in practice. Specifically, we show that adversarial training with the fast gradient sign method (FGSM), when combined with random initialization, is as effective as PGD-based training but has significantly lower cost. Furthermore we show that FGSM adversarial training can be further accelerated by using standard techniques for efficient training of deep networks, allowing us to learn a robust CIFAR10 classifier with $45 \\%$ robust accuracy to PGD attacks with $\\epsilon = 8 / 2 5 5$ in 6 minutes, and a robust ImageNet classifier with $43 \\%$ robust accuracy at $\\epsilon = 2 / 2 5 5$ in 12 hours, in comparison to past work based on “free” adversarial training which took 10 and 50 hours to reach the same respective thresholds. Finally, we identify a failure mode referred to as “catastrophic overfitting” which may have caused previous attempts to use FGSM adversarial training to fail. All code for reproducing the experiments in this paper as well as pretrained model weights are at https://github.com/locuslab/fast_adversarial. ",
+        "bbox": [
+            233,
+            411,
+            764,
+            676
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            703,
+            336,
+            718
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Although deep network architectures continue to be successful in a wide range of applications, the problem of learning robust deep networks remains an active area of research. In particular, safety and security focused applications are concerned about robustness to adversarial examples, data points which have been adversarially perturbed to fool a model (Szegedy et al., 2013). The goal here is to learn a model which is not only accurate on the data, but also accurate on adversarially perturbed versions of the data. To this end, a number of defenses have been proposed to mitigate the problem and improve the robustness of deep networks, with some of the most reliable being certified defenses and adversarial training. However, both of these approaches come at a non-trivial, additional computational cost, often increasing training time by an order of magnitude over standard training. This has slowed progress in researching robustness in deep networks, due to the computational difficulty in scaling to much larger networks and the inability to rapidly train models when experimenting with new ideas. In response to this difficulty, there has been a recent surge in work that tries to to reduce the complexity of generating an adversarial example, which forms the bulk of the additional computation in adversarial training (Zhang et al., 2019; Shafahi et al., 2019). While these works present reasonable improvements to the runtime of adversarial training, they are still significantly slower than standard training, which has been greatly accelerated due to competitions for optimizing both the speed and cost of training (Coleman et al., 2017). ",
+        "bbox": [
+            174,
+            734,
+            825,
+            901
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this work, we argue that adversarial training, in fact, is not as hard as has been suggested by this past line of work. In particular, we revisit one of the the first proposed methods for adversarial training, using the Fast Gradient Sign Method (FGSM) to add adversarial examples to the training process (Goodfellow et al., 2014). Although this approach has long been dismissed as ineffective, we show that by simply introducing random initialization points, FGSM-based training is as effective as projected gradient descent based training while being an order of magnitude more efficient. Moreover, FGSM adversarial training (and to a lesser extent, other adversarial training methods) can be drastically accelerated using standard techniques for efficient training of deep networks, including e.g. cyclic learning rates (Smith & Topin, 2018), mixed-precision training (Micikevicius et al., 2017), and other similar techniques. The method has extremely few free parameters to tune, and can be easily adapted to most training procedures. We further identify a failure mode that we call “catastrophic overfitting”, which may have caused previous attempts at FGSM adversarial training to fail against PGD-based attacks. ",
+        "bbox": [
+            174,
+            180,
+            825,
+            359
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The end result is that, with these approaches, we are able to train (empirically) robust classifiers far faster than in previous work. Specifically, we train an $\\ell _ { \\infty }$ robust CIFAR10 model to $4 5 \\%$ accuracy at $\\epsilon = 8 / 2 5 \\bar { 5 }$ (the same level attained in previous work) in $6$ minutes; previous papers reported times of 80 hours for PGD-based training (Madry et al., 2017) and 10 hours for the more recent “free” adversarial training method (Shafahi et al., 2019). Similarly, we train an $\\ell _ { \\infty }$ robust ImageNet classifier to $4 3 \\%$ top-1 accuracy at $\\epsilon = 2 / 2 5 5$ (again matching previous results) in 12 hours of training (compared to 50 hours in the best reported previous work that we are aware of (Shafahi et al., 2019)). Both of these times roughly match the comparable time for quickly training a standard non-robust model to reasonable accuracy. We extensively evaluate these results against strong $P G D { \\mathrm { . } }$ - based attacks, and show that they obtain the same empirical performance as the slower, PGD-based training. Thus, we argue that despite the conventional wisdom, adversarially robust training is not actually more challenging than standard training of deep networks, and can be accomplished with the notoriously weak FGSM attack. ",
+        "bbox": [
+            174,
+            368,
+            825,
+            547
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            575,
+            339,
+            592
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "After the discovery of adversarial examples by Szegedy et al. (2013), Goodfellow et al. (2014) proposed the Fast Gradient Sign Method (FGSM) to generate adversarial examples with a single gradient step. This method was used to perturb the inputs to the model before performing backpropagation as an early form of adversarial training. This attack was enhanced by adding a randomization step, which was referred to as $\\mathrm { R + F G S M }$ (Tramer et al., 2017). Later, the Basic Iterative \\` Method improved upon FGSM by taking multiple, smaller FGSM steps, ultimately rendering both FGSM-based adversarial training ineffective (Kurakin et al., 2016). This iterative adversarial attack was further strengthened by adding multiple random restarts, and was also incorporated into the adversarial training procedure. These improvements form the basis of what is widely understood today as adversarial training against a projected gradient descent (PGD) adversary, and the resulting method is recognized as an effective approach to learning robust networks (Madry et al., 2017). Since then, the PGD attack and its corresponding adversarial training defense have been augmented with various techniques, such as optimization tricks like momentum to improve the adversary (Dong et al., 2018), combination with other heuristic defenses like matrix estimation (Yang et al., 2019) or logit pairing (Mosbach et al., 2018), and generalization to multiple types of adversarial attacks (Tramer & Boneh, 2019; Maini et al., 2019).\\` ",
+        "bbox": [
+            174,
+            611,
+            825,
+            833
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In addition to adversarial training, a number of other defenses against adversarial attacks have also been proposed. Adversarial defenses span a wide range of methods, such as preprocessing techniques (Guo et al., 2017; Buckman et al., 2018; Song et al., 2017), detection algorithms (Metzen et al., 2017; Feinman et al., 2017; Carlini & Wagner, 2017a), verification and provable defenses (Katz et al., 2017; Sinha et al., 2017; Wong & Kolter, 2017; Raghunathan et al., 2018), and various theoretically motivated heuristics (Xiao et al., 2018; Croce et al., 2018). While certified defenses have been scaled to reasonably sized networks (Wong et al., 2018; Mirman et al., 2018; Gowal et al., 2018; Cohen et al., 2019; Salman et al., 2019), the guarantees don’t match the empirical robustness obtained through adversarial training. ",
+        "bbox": [
+            174,
+            840,
+            823,
+            922
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "With the proposal of many new defense mechanisms, of great concern in the community is the use of strong attacks for evaluating robustness: weak attacks can give a misleading sense of security, and the history of adversarial examples is littered with adversarial defenses (Papernot et al., 2016; Lu et al., 2017; Kannan et al., 2018; Tao et al., 2018) which were ultimately defeated by stronger attacks (Carlini & Wagner, 2016; 2017b; Athalye et al., 2017; Engstrom et al., 2018; Carlini, 2019). This highlights the difficulty of evaluating adversarial robustness, as pointed out by other work which began to defeat proposed defenses en masse (Uesato et al., 2018; Athalye et al., 2018). Since then, several best practices have been proposed to mitigate this problem (Carlini et al., 2019). ",
+        "bbox": [
+            174,
+            152,
+            825,
+            263
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Despite the eventual defeat of other adversarial defenses, adversarial training with a PGD adversary remains empirically robust to this day. However, running a strong PGD adversary within an inner loop of training is expensive, and some earlier work in this topic found that taking larger but fewer steps did not always significantly change the resulting robustness of a network (Wang, 2018). To combat the increased computational overhead of the PGD defense, some recent work has looked at regressing the $k$ -step PGD adversary to a variation of its single-step FGSM predecessor called “free” adversarial training, which can be computed with little overhead over standard training by using a single backwards pass to simultaneously update both the model weights and also the input perturbation (Shafahi et al., 2019). Finally, when performing a multi-step PGD adversary, it is possible to cut out redundant calculations during backpropagation when computing adversarial examples for additional speedup (Zhang et al., 2019). ",
+        "bbox": [
+            174,
+            270,
+            825,
+            424
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Although these improvements are certainly faster than the standard adversarial training procedure, they are not much faster than traditional training methods, and can still take hours to days to compute. On the other hand, top performing training methods from the DAWNBench competition (Coleman et al., 2017) are able to train CIFAR10 and ImageNet architectures to standard benchmark metrics in mere minutes and hours respectively, using only a modest amount of computational resources. Although some of the techniques can be quite problem specific for achieving bleedingedge performance, more general techniques such as cyclic learning rates (Smith & Topin, 2018) and half-precision computations (Micikevicius et al., 2017) have been quite successful in the top ranking submissions, and can also be useful for adversarial training. ",
+        "bbox": [
+            174,
+            430,
+            825,
+            556
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 ADVERSARIAL TRAINING OVERVIEW ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            577,
+            511,
+            592
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Adversarial training is a method for learning networks which are robust to adversarial attacks. Given a network $f _ { \\theta }$ parameterized by $\\theta$ , a dataset $( x _ { i } , y _ { i } )$ , a loss function $\\ell$ and a threat model $\\Delta$ , the learning problem is typically cast as the following robust optimization problem, ",
+        "bbox": [
+            174,
+            607,
+            825,
+            650
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fa46ddd142ee8b788fd55b2be35f7547cfaa21e1dfcb6c02daa547fe63815539.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { \\theta } \\sum _ { i } \\operatorname* { m a x } _ { \\delta \\in \\Delta } \\ell ( f _ { \\theta } ( x _ { i } + \\delta ) , y _ { i } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            395,
+            665,
+            604,
+            699
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "A typical choice for a threat model is to take $\\Delta = \\{ \\delta : \\| \\delta \\| _ { \\infty } \\leq \\epsilon \\}$ for some $\\epsilon > 0$ . This is the $\\ell _ { \\infty }$ threat model used by Madry et al. (2017) and is the setting we study in this paper. The procedure for adversarial training is to use some adversarial attack to approximate the inner maximization over $\\Delta$ , followed by some variation of gradient descent on the model parameters $\\theta$ . For example, one of the earliest versions of adversarial training used the Fast Gradient Sign Method to approximate the inner maximization. This could be seen as a relatively inaccurate approximation of the inner maximization for $\\ell _ { \\infty }$ perturbations, and has the following closed form (Goodfellow et al., 2014): ",
+        "bbox": [
+            173,
+            708,
+            825,
+            808
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c92ee70a12e0bd7ff7e8b68dd3056d50ac3a969baf36235bc6c540a5ccf40681.jpg",
+        "text": "$$\n\\delta ^ { \\star } = \\epsilon \\cdot \\mathrm { s i g n } \\big ( \\nabla _ { x } \\ell ( f ( x ) , y ) \\big ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            401,
+            827,
+            596,
+            844
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "A better approximation of the inner maximization is to take multiple, smaller FGSM steps of size $\\alpha$ instead. When the iterate leaves the threat model, it is projected back to the set $\\Delta$ (for $\\ell _ { \\infty }$ perturbations. This is equivalent to clipping $\\delta$ to the interval $[ - \\epsilon , \\epsilon ] )$ . Since this is only a local approximation of a non-convex function, multiple random restarts within the threat model $\\Delta$ typically improve the approximation of the inner maximization even further. A combination of all these techniques is ",
+        "bbox": [
+            174,
+            853,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "table",
+        "img_path": "images/bf535434bbef8ae7e539a913355910fd0d26c7f775d8814ea88d36a895054d3f.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Algorithm 1 PGD adversarial training for T epochs, given some radius ∈,adversarial step size α and N PGD steps and a dataset of size M for a network fe</td></tr><tr><td>fort=1...Tdo fori=1...Mdo</td></tr><tr><td>// Perform PGD adversarial attack</td></tr><tr><td>δ = O // or randomly initialized for j=1...N do</td></tr><tr><td>δ=δ+α·sign(Vsl(fe(xi +δ),yi))</td></tr><tr><td>δ = max(min(δ,ε),-∈) end for</td></tr><tr><td>0 = 0 - Vθl(fe(xi + δ),yi) // Update model weights with some optimizer, e.g. SGD</td></tr><tr><td>end for end for</td></tr></table>",
+        "bbox": [
+            173,
+            101,
+            826,
+            292
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 2 “Free” adversarial training for $T$ epochs, given some radius \u000f, $N$ minibatch replays, and a dataset of size $M$ for a network $f _ { \\theta }$ ",
+        "bbox": [
+            174,
+            308,
+            825,
+            338
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "$\\delta = 0$   \n// Iterate T/N times to account for minibatch replays and run for T total epochs   \nfor $t = 1 \\ldots T / N$ do for $i = 1 \\dots M$ do // Perform simultaneous FGSM adversarial attack and model weight updates $T$ times for $j = 1 \\ldots N$ do // Compute gradients for perturbation and model weights simultaneously $\\nabla _ { \\boldsymbol { \\delta } } , \\nabla _ { \\boldsymbol { \\theta } } = \\nabla \\ell ( f _ { \\boldsymbol { \\theta } } ( x _ { i } + \\boldsymbol { \\delta } ) , y _ { i } )$ $\\delta = \\delta + \\epsilon \\cdot \\mathrm { s i g n } ( \\nabla _ { \\delta } )$ $\\delta = \\operatorname* { m a x } ( \\operatorname* { m i n } ( \\delta , \\epsilon ) , - \\epsilon )$ $\\theta = \\theta - \\nabla _ { \\theta }$ // Update model weights with some optimizer, e.g. SGD end for end for   \nend for ",
+        "bbox": [
+            179,
+            340,
+            785,
+            539
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "known as the PGD adversary (Madry et al., 2017), and its usage in adversarial training is summarized in Algorithm 1. ",
+        "bbox": [
+            176,
+            565,
+            821,
+            594
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Note that the number of gradient computations here is proportional to $O ( M N )$ in a single epoch, where $M$ is the size of the dataset and $N$ is the number of steps taken by the PGD adversary. This is $N$ times greater than standard training (which has $O ( M )$ gradient computations per epoch), and so adversarial training is typically $N$ times slower than standard training. ",
+        "bbox": [
+            174,
+            602,
+            825,
+            657
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 “FREE” ADVERSARIAL TRAINING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            676,
+            444,
+            690
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To get around this slowdown of a factor of $N$ , Shafahi et al. (2019) instead propose “free” adversarial training. This method takes FGSM steps with full step sizes $\\alpha = \\epsilon$ followed by updating the model weights for $N$ iterations on the same minibatch (also referred to as “minibatch replays”). The algorithm is summarized in Algorithm 2. Note that perturbations are not reset between minibatches. To account for the additional computational cost of minibatch replay, the total number of epochs is reduced by a factor of $N$ to make the total cost equivalent to $T$ epochs of standard training. Although “free” adversarial training is faster than the standard PGD adversarial training, it is not as fast as we’d like: Shafahi et al. (2019) need to run over 200 epochs in over 10 hours to learn a robust CIFAR10 classifier and two days to learn a robust ImageNet classifier, whereas standard training can be accomplished in minutes and hours for the same respective tasks. ",
+        "bbox": [
+            174,
+            703,
+            825,
+            842
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 FAST ADVERSARIAL TRAINING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            863,
+            462,
+            878
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To speed up adversarial training and move towards the state of the art in fast standard training methods, we first highlight the main empirical contribution of the paper: that FGSM adversarial training combined with random initialization is just as effective a defense as PGD-based training. Following this, we discuss several techniques from the DAWNBench competition (Coleman et al., 2017) that are applicable to all adversarial training methods, which reduce the total number of epochs needed for convergence with cyclic learning rates and further speed up computations with mixedprecision arithmetic. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/c156d72fb057c3bbd888dcb1b43ba37e37a4fe777f7db8750720b2be98981c52.jpg",
+        "table_caption": [
+            "Algorithm 3 FGSM adversarial training for $T$ epochs, given some radius \u000f, $N$ PGD steps, step size $\\alpha$ , and a dataset of size $M$ for a network $f _ { \\theta }$ "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>fort=1...Tdo fori=1...Mdo</td><td></td></tr><tr><td>//Perform FGSMadversarial attack</td><td></td></tr><tr><td>δ=Uniform(-∈,∈)</td><td></td></tr><tr><td>δ=δ+α·sign(Vsl(fe(xi+δ),yi))</td><td></td></tr><tr><td>δ = max(min(δ,ε),-∈)</td><td></td></tr><tr><td>end for</td><td>0 = 0- Vθl(fe(xi + δ),yi) // Update model weights with some optimizer, e.g. SGD</td></tr><tr><td>end for</td><td></td></tr></table>",
+        "bbox": [
+            179,
+            135,
+            792,
+            263
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/957af0f68e9eb25f5dd6724f243ba764ec0adf46c5cda26df75ddf459f1353cc.jpg",
+        "table_caption": [
+            "Table 1: Standard and robust performance of various adversarial training methods on CIFAR10 for $\\epsilon = 8 / 2 5 5$ and their corresponding training times "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>Standard accuracy</td><td>PGD (∈= 8/255)</td><td>Time (min)</td></tr><tr><td>FGSM+ DAWNBench</td><td></td><td></td><td></td></tr><tr><td>+ zero init</td><td>85.18%</td><td>0.00%</td><td>12.37</td></tr><tr><td>+ early stopping</td><td>71.14%</td><td>38.86%</td><td>7.89</td></tr><tr><td>+ previous init</td><td>86.02%</td><td>42.37%</td><td>12.21</td></tr><tr><td>+ random init</td><td>85.32%</td><td>44.01%</td><td>12.33</td></tr><tr><td>+ α = 10/255 step size</td><td>83.81%</td><td>46.06%</td><td>12.17</td></tr><tr><td>+ α = 16/255 step size</td><td>86.05%</td><td>0.00%</td><td>12.06</td></tr><tr><td>+ early stopping</td><td>70.93%</td><td>40.38%</td><td>8.81</td></tr><tr><td>“Free” (m= 8) (Shafahi et al.,2019)1</td><td>85.96%</td><td>46.33%</td><td>785</td></tr><tr><td>+ DAWNBench</td><td>78.38%</td><td>46.18%</td><td>20.91</td></tr><tr><td>PGD-7 (Madry et al., 2017)2</td><td>87.30%</td><td>45.80%</td><td>4965.71</td></tr><tr><td>+ DAWNBench</td><td>82.46%</td><td>50.69%</td><td>68.8</td></tr></table>",
+        "bbox": [
+            176,
+            321,
+            823,
+            529
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            559,
+            825,
+            630
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 REVISITING FGSM ADVERSARIAL TRAINING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            647,
+            529,
+            661
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Despite being quite similar to FGSM adversarial training, free adversarial training is empirically robust against PGD attacks whereas FGSM adversarial training is not believed to be robust. To analyze why, we identify a key difference between the methods: a property of free adversarial training is that the perturbation from the previous iteration is used as the initial starting point for the next iteration. However, there is little reason to believe that an adversarial perturbation for a previous minibatch is a reasonable starting point for the next minibatch. As a result, we hypothesize that the main benefit comes from simply starting from a non-zero initial perturbation. ",
+        "bbox": [
+            174,
+            672,
+            825,
+            770
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In light of this difference, our approach is to use FGSM adversarial training with random initialization for the perturbation, as shown in Algorithm 3. We find that, in contrast to what was previously believed, this simple adjustment to FGSM adversarial training can be used as an effective defense on par with PGD adversarial training. Crucially, we find that starting from a non-zero initial perturbation is the primary driver for success, regardless of the actual initialization. In fact, both starting with the previous minibatch’s perturbation or initializing from a uniformly random perturbation allow FGSM adversarial training to succeed at being robust to full-strength PGD adversarial attacks. Note that randomized initialization for FGSM is not a new idea and was previously studied by Tramer et al. (2017). Crucially, Tram \\` er et al. (2017) use a different, more restricted random initial- \\` ization and step size, which does not result in models robust to full-strength PGD adversaries. A more detailed comparison of their approach with ours is in Appendix A. ",
+        "bbox": [
+            174,
+            777,
+            825,
+            861
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            172
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To test the effect of initialization in FGSM adversarial training, we train several models to be robust at a radius $\\epsilon = 8 / 2 5 5$ on CIFAR10, starting with the most “pure” form of FGSM, which takes steps of size $\\alpha = \\epsilon$ from a zero-initialized perturbation. The results, given in Table 1, are consistent with the literature, and show that the model trained with zero-initialization is not robust against a PGD adversary. However, surprisingly, simply using a random or previous-minibatch initialization instead of a zero initialization actually results in reasonable robustness levels (with random initialization performing slightly better) that are comparable to both free and PGD adversarial training methods. The adversarial accuracies in Table 1 are calculated using a PGD adversary with 50 iterations, step size $\\alpha = 2 / 2 5 5$ , and 10 random restarts. Specific optimization parameters used for training these models can be found in Appendix B. ",
+        "bbox": [
+            174,
+            180,
+            825,
+            319
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "FGSM step size Note that an FGSM step with size $\\alpha = \\epsilon$ from a non-zero initialization is not guaranteed to lie on the boundary of the $\\ell _ { \\infty }$ ball, and so this defense could potentially be seen as too weak. We find that increasing the step size by a factor of 1.25 to $\\alpha = 1 0 / 2 5 5$ further improved the robustness of the model so that it is on par with the best reported result from free adversarial training. However, we also found that forcing the resulting perturbation to lie on the boundary with a step size of $\\alpha = 2 \\epsilon$ resulted in catastrophic overfitting: it does not produce a model robust to adversarial attacks. These two failure modes (starting from a zero-initialized perturbation and generating perturbations at the boundary) may explain why previous attempts at FGSM adversarial training failed, as the model overfits to a restricted threat model, and is described in more detail in Section 5.4. A full curve showing the effect of a range of FGSM step sizes on the robust performance can be found in Appendix C. ",
+        "bbox": [
+            174,
+            337,
+            825,
+            489
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Computational complexity A second key difference between FGSM and free adversarial training is that the latter uses a single backwards pass to compute gradients for both the perturbation and the model weights while repeating the same minibatch $m$ times in a row, called “minibatch replay”. In comparison, the FGSM adversarial training does not need to repeat minibatches, but needs two backwards passes to compute gradients separately for the perturbation and the model weights. As a result, the computational complexity for an epoch of FGSM adversarial training is not truly free and is equivalent to two epochs of standard training. ",
+        "bbox": [
+            174,
+            507,
+            825,
+            604
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 DAWNBENCH IMPROVEMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            625,
+            431,
+            638
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Although free adversarial training is of comparable cost per iteration to traditional standard training methods, it is not quite comparable in total cost to more recent advancements in fast methods for standard training. Notably, top submissions to the DAWNBench competition have shown that CIFAR10 and ImageNet classifiers can be trained at significantly quicker times and at much lower cost than traditional training methods. Although some of the submissions can be quite unique in their approaches, we identify two generally applicable techniques which have a significant impact on the convergence rate and computational speed of standard training. ",
+        "bbox": [
+            174,
+            651,
+            825,
+            748
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Cyclic learning rate Introduced by Smith (2017) for improving convergence and reducing the amount of tuning required when training networks, a cyclic schedule for a learning rate can drastically reduce the number of epochs required for training deep networks (Smith & Topin, 2018). A simple cyclic learning rate schedules the learning rate linearly from zero, to a maximum learning rate, and back down to zero (examples can be found in Figure 1). Using a cyclic learning rate allows CIFAR10 architectures to converge to benchmark accuracies in tens of epochs instead of hundreds, and is a crucial component of some of the top DAWNBench submissions. ",
+        "bbox": [
+            174,
+            766,
+            825,
+            864
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Mixed-precision arithmetic With newer GPU architectures coming with tensor cores specifically built for rapid half-precision calculations, using mixed-precision arithmetic when training deep networks can also provide significant speedups for standard training (Micikevicius et al., 2017). This can drastically reduce the memory utilization, and when tensor cores are available, also reduce runtime. In some DAWNBench submissions, switching to mixed-precision computations was key to achieving fast training while keeping costs low. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/2d5e9c39d0474672bdef40131c28969bd68a9e2c32dfc5142d5be8b030760579.jpg",
+        "image_caption": [
+            "Figure 1: Cyclic learning rates used for FGSM adversarial training on CIFAR10 and ImageNet over epochs. The ImageNet cyclic schedule is decayed further by a factor of 10 in the second and third phases. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            258,
+            97,
+            741,
+            208
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/c20b8128223ef34c8f80074dbb6241b08e681c8dd2ab46c0aa67815582f5920d.jpg",
+        "table_caption": [
+            "Table 2: Robustness of FGSM and PGD adversarial training on MNIST "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>Standard accuracy</td><td>PGD (ε = 0.1)</td><td>PGD (ε = 0.3)</td><td>Verified (ε = 0.1)</td></tr><tr><td>PGD</td><td>99.20%</td><td>97.66%</td><td>89.90%</td><td>96.7%</td></tr><tr><td>FGSM</td><td>99.20%</td><td>97.53%</td><td>88.77%</td><td>96.8%</td></tr></table>",
+        "bbox": [
+            197,
+            309,
+            802,
+            362
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            395,
+            823,
+            438
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We adopt these two techniques for use in adversarial training, which allows us to drastically reduce the number of training epochs as well as the runtime on GPU infrastructure with tensor cores, while using modest amounts of computational resources. Notably, both of these improvements can be easily applied to existing implementations of adversarial training by adding a few lines of code with very little additional engineering effort, and so are easily accessible by the general research community. ",
+        "bbox": [
+            174,
+            444,
+            825,
+            527
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            549,
+            326,
+            565
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To demonstrate the effectiveness of FGSM adversarial training with fast training methods, we run a number of experiments on MNIST, CIFAR10, and ImageNet benchmarks. All CIFAR10 experiments in this paper are run on a single GeForce RTX 2080ti using the PreAct ResNet18 architecture, and all ImageNet experiments are run on a single machine with four GeForce RTX 2080tis using the ResNet50 architecture (He et al., 2016). Repositories for reproducing all experiments and the corresponding trained model weights are available at https://github.com/locuslab/fast_ adversarial. ",
+        "bbox": [
+            174,
+            582,
+            825,
+            679
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "All experiments using FGSM adversarial training in this section are carried out with random initial starting points and step size $\\alpha = 1 . 2 5 \\epsilon$ as described in Section 4.1. All PGD adversaries used at evaluation are run with 10 random restarts for 50 iterations (with the same hyperparameters as those used by Shafahi et al. (2019) but further strengthened with random restarts). Speedup with mixedprecision was incorporated with the Apex amp package at the O1 optimization level for ImageNet experiments and O2 without loss scaling for CIFAR10 experiments.3 ",
+        "bbox": [
+            174,
+            685,
+            825,
+            770
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.1 VERIFIED PERFORMANCE ON MNIST ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            789,
+            473,
+            803
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Since the FGSM attack is known to be significantly weaker than the PGD attack, it is understandable if the reader is still skeptical of the true robustness of the models trained using this method. To demonstrate that FGSM adversarial training confers real robustness to the model, in addition to evaluating against a PGD adversary, we leverage mixed-integer linear programming (MILP) methods from formal verification to calculate the exact robustness of small, but verifiable models (Tjeng et al., 2017). We train two convolutional networks with 16 and 32 convolutional filters followed by a fully connected layer of 100 units, the same architecture used by Tjeng et al. (2017). We use both PGD and FGSM adversarial training at $\\epsilon = 0 . 3$ , where the PGD adversary for training has 40 iterations with step size 0.01 as done by Madry et al. (2017). The exact verification results can be seen in Table 2, where we find that FGSM adversarial training confers empirical and verified robustness which is nearly indistinguishable to that of PGD adversarial training on MNIST.4 ",
+        "bbox": [
+            174,
+            815,
+            823,
+            885
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/b00d6eb5af7a8fe3ce93e02453db494ae8ae55edcabe39e69549c6716302c36b.jpg",
+        "image_caption": [
+            "Figure 2: Performance of models trained on CIFAR10 at $\\epsilon = 8 / 2 5 5$ with cyclic learning rates and half precision, given varying numbers of epochs across different adversarial training methods. Each point denotes the average model performance over 3 independent runs, where the $x$ axis denotes the number of epochs $N$ the model was trained for, and the $y$ axis denotes the resulting accuracy. The orange dots measure accuracy on natural images and the blue dots plot the empirical robust accuracy on adversarial images. The vertical dotted line indicates the minimum number of epochs needed to train a model to $45 \\%$ robust accuracy. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            196,
+            97,
+            808,
+            209
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/cd09cef7de15caf031c0adbc0bd64524b341ce051c1c3993ed17f3b9c4c758b3.jpg",
+        "table_caption": [
+            "Table 3: Time to train a robust CIFAR10 classifier to $45 \\%$ robust accuracy using various adversarial training methods with the DAWNBench techniques of cyclic learning rates and mixed-precision arithmetic, showing significant speedups for all forms of adversarial training. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>Epochs</td><td>Seconds/epoch</td><td>Total time (minutes)</td></tr><tr><td>DAWNBench +PGD-7</td><td>10</td><td>104.94</td><td>17.49</td></tr><tr><td>DAWNBench + Free (m = 8)</td><td>80</td><td>13.08</td><td>17.44</td></tr><tr><td>DAWNBench + FGSM</td><td>15</td><td>25.36</td><td>6.34</td></tr><tr><td>PGD-7 (Madry et al., 2017)5</td><td>205</td><td>1456.22</td><td>4965.71</td></tr><tr><td>Free (m = 8) (Shafahi et al.,2019)6</td><td>205</td><td>197.77</td><td>674.39</td></tr></table>",
+        "bbox": [
+            192,
+            400,
+            805,
+            503
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            542,
+            825,
+            627
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.2 FAST CIFAR10 ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            654,
+            325,
+            667
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We begin our CIFAR10 experiments by combining the DAWNBench improvements from Section 4.2 with various forms of adversarial training. For $N$ epochs, we use a cyclic learning rate that increases linearly from 0 to $\\lambda$ over the first $N / 2$ epochs, then decreases linearly from $\\lambda$ to 0 for the remaining epochs, where $\\lambda$ is the maximum learning rate. For each method, we individually tune $\\lambda$ to be as large as possible without causing the training loss to diverge, which is the recommended learning rate test from Smith & Topin (2018). ",
+        "bbox": [
+            174,
+            684,
+            825,
+            767
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "To identify the minimum number of epochs needed for each adversarial training method, we repeatedly run each method over a range of maximum epochs $N$ , and then plot the final robustness of each trained model in Figure 2. While all the adversarial training methods benefit greatly from the cyclic learning rate schedule, we find that both FGSM and PGD adversarial training require much fewer epochs than free adversarial training, and consequently reap the greatest speedups. ",
+        "bbox": [
+            173,
+            775,
+            825,
+            844
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/4080e8a05d2e102729e9d4377d8b44f0b7615aefe5caec1fbafec178232bd238.jpg",
+        "table_caption": [
+            "Table 4: Imagenet classifiers trained with adversarial training methods at $\\epsilon = 2 / 2 5 5$ and $\\epsilon = 4 / 2 5 5$ . "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>E</td><td>Standard acc.</td><td>PGD+1 restart</td><td>PGD+10 restarts</td><td>Total time (hrs)</td></tr><tr><td rowspan=\"2\">FGSM Free (m = 4)</td><td>2/255</td><td>60.90%</td><td>43.46%</td><td>43.43%</td><td>12.14</td></tr><tr><td>2/255</td><td>64.37%</td><td>43.31%</td><td>43.28%</td><td>52.20</td></tr><tr><td>FGSM</td><td>4/255</td><td>55.45%</td><td>30.28%</td><td>30.18%</td><td>12.14</td></tr><tr><td>Free (m = 4)</td><td>4/255</td><td>60.42%</td><td>31.22%</td><td>31.08%</td><td>52.20</td></tr></table>",
+        "bbox": [
+            173,
+            133,
+            825,
+            220
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/bc1d658c24af169e36bab16aafaae03f0a0dc0ebd8ca8c6d2682d3033e4a2c7c.jpg",
+        "table_caption": [
+            "Table 5: Time to train a robust ImageNet classifier using various fast adversarial training methods "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>Precision</td><td>Epochs</td><td>Min/epoch</td><td>Total time (hrs)</td></tr><tr><td>FGSM (phase 1)</td><td>single</td><td>6</td><td>22.65</td><td>2.27</td></tr><tr><td>FGSM (phase 2)</td><td>single</td><td>6</td><td>65.97</td><td>6.60</td></tr><tr><td>FGSM (phase 3)</td><td>single</td><td>3</td><td>114.45</td><td>5.72</td></tr><tr><td>FGSM</td><td>single</td><td>15</td><td>-</td><td>14.59</td></tr><tr><td>Free (m = 4)</td><td>single</td><td>92</td><td>34.04</td><td>52.20</td></tr><tr><td>FGSM (phase 1)</td><td>mixed</td><td>6</td><td>20.07</td><td>2.01</td></tr><tr><td>FGSM (phase 2)</td><td>mixed</td><td>6</td><td>53.39</td><td>5.34</td></tr><tr><td>FGSM (phase 3)</td><td>mixed</td><td>3</td><td>95.93</td><td>4.80</td></tr><tr><td>FGSM</td><td>mixed</td><td>15</td><td>1</td><td>12.14</td></tr><tr><td>Free (m = 4)</td><td>mixed</td><td>92</td><td>25.28</td><td>38.76</td></tr></table>",
+        "bbox": [
+            246,
+            284,
+            751,
+            478
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Using the minimum number of epochs needed for each training method to reach a baseline of $45 \\%$ robust accuracy, we report the total training time in Table 3. We find that while all adversarial training methods benefit from the DAWNBench improvements, FGSM adversarial training is the fastest, capable of learning a robust CIFAR10 classifier in 6 minutes using only 15 epochs. Interestingly, we also find that PGD and free adversarial training take comparable amounts of time, largely because free adversarial training does not benefit from the cyclic learning rate as much as PGD or FGSM adversarial training. ",
+        "bbox": [
+            173,
+            522,
+            825,
+            621
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.3 FAST IMAGENET ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            651,
+            331,
+            665
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Finally, we apply all of the same techniques (FGSM adversarial training, mixed-precision, and cyclic learning rate) on the ImageNet benchmark. In addition, the top submissions from the DAWNBench competition for ImageNet utilize two more improvements on top of this, the first of which is the removal of weight decay regularization from batch normalization layers. The second addition is to progressively resize images during training, starting with larger batches of smaller images in the beginning and moving on to smaller batches of larger images later. Specifically, training is divided into three phases, where phases 1 and 2 use images resized to 160 and 352 pixels respectively, and phase 3 uses the entire image. We train models to be robust at $\\epsilon = 2 / 2 5 5$ and $\\epsilon = 4 / 2 5 5$ and compare to free adversarial training in Table 4, showing similar levels of robustness. In addition to using ten restarts, we also report the PGD accuracy with one restart to reproduce the evaluation done by Shafahi et al. (2019). ",
+        "bbox": [
+            173,
+            683,
+            825,
+            835
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "With these techniques, we can train an ImageNet classifier using 15 epochs in 12 hours using FGSM adversarial training, taking a fraction of the cost of free adversarial training as shown in Table 5.7 We compare to the best performing variation of free adversarial training which which uses $m = 4$ minibatch replays over 92 epochs of training (scaled down accordingly to 23 passes over the data). Note that free adversarial training can also be enhanced with mixed-precision arithmetic, which reduces the runtime by $2 5 \\%$ , but is still slower than FGSM-based training. Directly combining free adversarial training with the other fast techniques used in FGSM adversarial training for ImageNet results in reduced performance which we describe in Appendix F. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            215
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5.4 CATASTROPHIC OVERFITTING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            236,
+            419,
+            250
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "While FGSM adversarial training works in the context of this paper, many other researchers have tried and failed to have FGSM adversarial training work. In addition to using a zero initialization or too large of a step size as seen in Table 1, other design decisions (like specific learning rate schedules or numbers of epochs) for the training procedure can also make it more likely for FGSM adversarial training to fail. However, all of these failure modes result in what we call “catastrophic overfitting”, where the robust accuracy with respect to a PGD adversarial suddenly and drastically drops to $0 \\%$ (on the training data). Due to the rapid deterioration of robust performance, these alternative versions of FGSM adversarial training can be salvaged to some degree with a simple early-stopping scheme by measuring PGD accuracy on a small minibatch of training data, and the recovered results for some of these failure modes are shown in Table 1. Catastrophic overfitting and the early-stopping scheme are discussed in more detail in Appendix D. ",
+        "bbox": [
+            174,
+            263,
+            825,
+            416
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5.5 TAKEAWAYS FROM FGSM ADVERSARIAL TRAINING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            438,
+            575,
+            452
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "While it may be surprising that FGSM adversarial training can result in robustness to full PGD adversarial attacks, this work highlights some empirical hypotheses and takeaways which we describe below. ",
+        "bbox": [
+            178,
+            465,
+            823,
+            507
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "1. Adversarial examples need to span the entire threat model. One of the reasons why FGSM and $\\mathrm { R + F G S M }$ as done by Tramer et al. (2017) may have failed is due to the restricted nature \\` of the generated examples: the restricted (or lack of) initialization results in perturbations which perturb each dimension by either 0 or $\\pm \\epsilon .$ , and so adversarial examples with feature perturbations in between are never seen. This is discussed further in Appendix D. 2. Defenders don’t need strong adversaries during training. This work suggests that rough approximations to the inner optimization problem are sufficient for adversarial training. This is in contrast to the usage of strong adversaries at evaluation time, where it is standard practice to use multiple restarts and a large number of PGD steps. ",
+        "bbox": [
+            212,
+            521,
+            825,
+            656
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            679,
+            318,
+            695
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Our findings show that FGSM adversarial training, when used with random initialization, can in fact be just as effective as the more costly PGD adversarial training. While a single iteration of FGSM adversarial training is double the cost of free adversarial training, it converges significantly faster, especially with a cyclic learning rate schedule. As a result, we are able to learn adversarially robust classifiers for CIFAR10 in minutes and for ImageNet in hours, even faster than free adversarial training but with comparable levels of robustness. We believe that leveraging these significant reductions in time to train robust models will allow future work to iterate even faster, and accelerate research in learning models which are resistant to adversarial attacks. By demonstrating that extremely weak adversarial training is capable of learning robust models, this work also exposes a new potential direction in more rigorously explaining when approximate solutions to the inner optimization problem are sufficient for robust optimization, and when they fail. ",
+        "bbox": [
+            174,
+            714,
+            825,
+            867
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            287,
+            117
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Anish Athalye, Logan Engstrom, Andrew Ilyas, and Kevin Kwok. Synthesizing robust adversarial examples. arXiv preprint arXiv:1707.07397, 2017. ",
+        "bbox": [
+            174,
+            126,
+            823,
+            155
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Anish Athalye, Nicholas Carlini, and David Wagner. Obfuscated gradients give a false sense of security: Circumventing defenses to adversarial examples. arXiv preprint arXiv:1802.00420, 2018. ",
+        "bbox": [
+            174,
+            162,
+            823,
+            204
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jacob Buckman, Aurko Roy, Colin Raffel, and Ian Goodfellow. Thermometer encoding: One hot way to resist adversarial examples. 2018. ",
+        "bbox": [
+            171,
+            213,
+            825,
+            243
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nicholas Carlini. Is ami (attacks meet interpretability) robust to adversarial examples? arXiv preprint arXiv:1902.02322, 2019. ",
+        "bbox": [
+            173,
+            251,
+            825,
+            280
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nicholas Carlini and David Wagner. Defensive distillation is not robust to adversarial examples. arXiv preprint arXiv:1607.04311, 2016. ",
+        "bbox": [
+            169,
+            287,
+            823,
+            318
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nicholas Carlini and David Wagner. Adversarial examples are not easily detected: Bypassing ten detection methods. In Proceedings of the 10th ACM Workshop on Artificial Intelligence and Security, pp. 3–14. ACM, 2017a. ",
+        "bbox": [
+            173,
+            325,
+            821,
+            368
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nicholas Carlini and David Wagner. Towards evaluating the robustness of neural networks. In 2017 IEEE Symposium on Security and Privacy (SP), pp. 39–57. IEEE, 2017b. ",
+        "bbox": [
+            169,
+            377,
+            823,
+            407
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nicholas Carlini, Anish Athalye, Nicolas Papernot, Wieland Brendel, Jonas Rauber, Dimitris Tsipras, Ian Goodfellow, and Aleksander Madry. On evaluating adversarial robustness. arXiv preprint arXiv:1902.06705, 2019. ",
+        "bbox": [
+            174,
+            414,
+            823,
+            457
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jeremy M Cohen, Elan Rosenfeld, and J Zico Kolter. Certified adversarial robustness via randomized smoothing. arXiv preprint arXiv:1902.02918, 2019. ",
+        "bbox": [
+            168,
+            465,
+            823,
+            494
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Cody Coleman, Deepak Narayanan, Daniel Kang, Tian Zhao, Jian Zhang, Luigi Nardi, Peter Bailis, Kunle Olukotun, Chris Re, and Matei Zaharia. Dawnbench: An end-to-end deep learning bench-´ mark and competition. Training, 100(101):102, 2017. ",
+        "bbox": [
+            174,
+            502,
+            821,
+            546
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Francesco Croce, Maksym Andriushchenko, and Matthias Hein. Provable robustness of relu networks via maximization of linear regions. arXiv preprint arXiv:1810.07481, 2018. ",
+        "bbox": [
+            169,
+            554,
+            821,
+            584
+        ],
+        "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 Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 9185–9193, 2018. ",
+        "bbox": [
+            174,
+            592,
+            821,
+            636
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Logan Engstrom, Andrew Ilyas, and Anish Athalye. Evaluating and understanding the robustness of adversarial logit pairing. arXiv preprint arXiv:1807.10272, 2018. ",
+        "bbox": [
+            169,
+            642,
+            823,
+            672
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Reuben Feinman, Ryan R Curtin, Saurabh Shintre, and Andrew B Gardner. Detecting adversarial samples from artifacts. arXiv preprint arXiv:1703.00410, 2017. ",
+        "bbox": [
+            171,
+            680,
+            823,
+            709
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ian J Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. arXiv preprint arXiv:1412.6572, 2014. ",
+        "bbox": [
+            169,
+            717,
+            825,
+            747
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sven Gowal, Krishnamurthy Dvijotham, Robert Stanforth, Rudy Bunel, Chongli Qin, Jonathan Uesato, Timothy Mann, and Pushmeet Kohli. On the effectiveness of interval bound propagation for training verifiably robust models. arXiv preprint arXiv:1810.12715, 2018. ",
+        "bbox": [
+            176,
+            755,
+            823,
+            797
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Chuan Guo, Mayank Rana, Moustapha Cisse, and Laurens Van Der Maaten. Countering adversarial images using input transformations. arXiv preprint arXiv:1711.00117, 2017. ",
+        "bbox": [
+            173,
+            806,
+            821,
+            837
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 770–778, 2016. ",
+        "bbox": [
+            174,
+            843,
+            821,
+            886
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Harini Kannan, Alexey Kurakin, and Ian Goodfellow. Adversarial logit pairing. arXiv preprint arXiv:1803.06373, 2018. ",
+        "bbox": [
+            173,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Guy Katz, Clark Barrett, David L Dill, Kyle Julian, and Mykel J Kochenderfer. Reluplex: An efficient smt solver for verifying deep neural networks. In International Conference on Computer Aided Verification, pp. 97–117. Springer, 2017. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            147
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Alexey Kurakin, Ian Goodfellow, and Samy Bengio. Adversarial examples in the physical world. arXiv preprint arXiv:1607.02533, 2016. ",
+        "bbox": [
+            171,
+            156,
+            821,
+            185
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jiajun Lu, Hussein Sibai, Evan Fabry, and David Forsyth. No need to worry about adversarial examples in object detection in autonomous vehicles. arXiv preprint arXiv:1707.03501, 2017. ",
+        "bbox": [
+            171,
+            195,
+            821,
+            224
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Aleksander Madry, Aleksandar Makelov, Ludwig Schmidt, Dimitris Tsipras, and Adrian Vladu. Towards deep learning models resistant to adversarial attacks. arXiv preprint arXiv:1706.06083, 2017. ",
+        "bbox": [
+            173,
+            234,
+            825,
+            277
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Pratyush Maini, Eric Wong, and J Zico Kolter. Adversarial robustness against the union of multiple perturbation models. arXiv preprint arXiv:1909.04068, 2019. ",
+        "bbox": [
+            171,
+            287,
+            825,
+            318
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jan Hendrik Metzen, Tim Genewein, Volker Fischer, and Bastian Bischoff. On detecting adversarial perturbations. arXiv preprint arXiv:1702.04267, 2017. ",
+        "bbox": [
+            171,
+            327,
+            825,
+            357
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Paulius Micikevicius, Sharan Narang, Jonah Alben, Gregory Diamos, Erich Elsen, David Garcia, Boris Ginsburg, Michael Houston, Oleksii Kuchaiev, Ganesh Venkatesh, et al. Mixed precision training. arXiv preprint arXiv:1710.03740, 2017. ",
+        "bbox": [
+            176,
+            366,
+            825,
+            410
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Matthew Mirman, Timon Gehr, and Martin Vechev. Differentiable abstract interpretation for provably robust neural networks. In International Conference on Machine Learning, pp. 3575–3583, 2018. ",
+        "bbox": [
+            174,
+            419,
+            825,
+            462
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Marius Mosbach, Maksym Andriushchenko, Thomas Trost, Matthias Hein, and Dietrich Klakow. Logit pairing methods can fool gradient-based attacks. arXiv preprint arXiv:1810.12042, 2018. ",
+        "bbox": [
+            174,
+            472,
+            823,
+            502
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Nicolas Papernot, Patrick McDaniel, Xi Wu, Somesh Jha, and Ananthram Swami. Distillation as a defense to adversarial perturbations against deep neural networks. In 2016 IEEE Symposium on Security and Privacy $( S P )$ , pp. 582–597. IEEE, 2016. ",
+        "bbox": [
+            174,
+            511,
+            825,
+            555
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Aditi Raghunathan, Jacob Steinhardt, and Percy S Liang. Semidefinite relaxations for certifying robustness to adversarial examples. In Advances in Neural Information Processing Systems, pp. 10877–10887, 2018. ",
+        "bbox": [
+            174,
+            564,
+            823,
+            608
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Hadi Salman, Greg Yang, Jerry Li, Pengchuan Zhang, Huan Zhang, Ilya Razenshteyn, and Sebastien Bubeck. Provably robust deep learning via adversarially trained smoothed classifiers. arXiv preprint arXiv:1906.04584, 2019. ",
+        "bbox": [
+            173,
+            617,
+            825,
+            660
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ali Shafahi, Mahyar Najibi, Amin Ghiasi, Zheng Xu, John Dickerson, Christoph Studer, Larry S Davis, Gavin Taylor, and Tom Goldstein. Adversarial training for free! arXiv preprint arXiv:1904.12843, 2019. ",
+        "bbox": [
+            173,
+            670,
+            825,
+            713
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Aman Sinha, Hongseok Namkoong, and John Duchi. Certifying some distributional robustness with principled adversarial training. arXiv preprint arXiv:1710.10571, 2017. ",
+        "bbox": [
+            171,
+            723,
+            825,
+            753
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Leslie N Smith. Cyclical learning rates for training neural networks. In 2017 IEEE Winter Conference on Applications of Computer Vision (WACV), pp. 464–472. IEEE, 2017. ",
+        "bbox": [
+            173,
+            763,
+            823,
+            792
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Leslie N Smith and Nicholay Topin. Super-convergence: Very fast training of residual networks using large learning rates. 2018. ",
+        "bbox": [
+            171,
+            803,
+            823,
+            832
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yang Song, Taesup Kim, Sebastian Nowozin, Stefano Ermon, and Nate Kushman. Pixeldefend: Leveraging generative models to understand and defend against adversarial examples. arXiv preprint arXiv:1710.10766, 2017. ",
+        "bbox": [
+            176,
+            842,
+            825,
+            885
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. arXiv preprint arXiv:1312.6199, 2013. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Guanhong Tao, Shiqing Ma, Yingqi Liu, and Xiangyu Zhang. Attacks meet interpretability: Attribute-steered detection of adversarial samples. In Advances in Neural Information Processing Systems, pp. 7717–7728, 2018. ",
+        "bbox": [
+            178,
+            103,
+            821,
+            146
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Vincent Tjeng, Kai Xiao, and Russ Tedrake. Evaluating robustness of neural networks with mixed integer programming. arXiv preprint arXiv:1711.07356, 2017. ",
+        "bbox": [
+            173,
+            155,
+            823,
+            184
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Florian Tramer and Dan Boneh. Adversarial training and robustness for multiple perturbations. \\` arXiv preprint arXiv:1904.13000, 2019. ",
+        "bbox": [
+            171,
+            193,
+            823,
+            222
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Florian Tramer, Alexey Kurakin, Nicolas Papernot, Ian Goodfellow, Dan Boneh, and Patrick Mc- \\` Daniel. Ensemble adversarial training: Attacks and defenses. arXiv preprint arXiv:1705.07204, 2017. ",
+        "bbox": [
+            176,
+            229,
+            823,
+            272
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Jonathan Uesato, Brendan O’Donoghue, Aaron van den Oord, and Pushmeet Kohli. Adversarial risk and the dangers of evaluating against weak attacks. arXiv preprint arXiv:1802.05666, 2018. ",
+        "bbox": [
+            173,
+            281,
+            823,
+            310
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Jianyu Wang. Bilateral adversarial training: Towards fast training of more robust models against adversarial attacks. arXiv preprint arXiv:1811.10716, 2018. ",
+        "bbox": [
+            174,
+            319,
+            821,
+            349
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Eric Wong and J Zico Kolter. Provable defenses against adversarial examples via the convex outer adversarial polytope. arXiv preprint arXiv:1711.00851, 2017. ",
+        "bbox": [
+            174,
+            357,
+            821,
+            387
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Eric Wong, Frank Schmidt, Jan Hendrik Metzen, and J Zico Kolter. Scaling provable adversarial defenses. In Advances in Neural Information Processing Systems, pp. 8400–8409, 2018. ",
+        "bbox": [
+            174,
+            395,
+            823,
+            425
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Kai Y Xiao, Vincent Tjeng, Nur Muhammad Shafiullah, and Aleksander Madry. Training for faster adversarial robustness verification via inducing relu stability. arXiv preprint arXiv:1809.03008, 2018. ",
+        "bbox": [
+            176,
+            433,
+            823,
+            476
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Yuzhe Yang, Guo Zhang, Dina Katabi, and Zhi Xu. Me-net: Towards effective adversarial robustness with matrix estimation. arXiv preprint arXiv:1905.11971, 2019. ",
+        "bbox": [
+            174,
+            484,
+            821,
+            513
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Dinghuai Zhang, Tianyuan Zhang, Yiping Lu, Zhanxing Zhu, and Bin Dong. You only propagate once: Painless adversarial training using maximal principle. arXiv preprint arXiv:1905.00877, 2019. ",
+        "bbox": [
+            174,
+            522,
+            826,
+            564
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/cf1cfe5cb14afb5eb0f502182c34291c2d3a31eb97922dc3ecd5ea5050629e5a.jpg",
+        "table_caption": [
+            "Table 6: Ablation study showing the performance of $\\mathrm { R + F G S M }$ from Tramer et al. (2017) and the \\` various changes for the version of FGSM adversarial training done in this paper, over 10 random seeds. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>Step size</td><td>Initialization</td><td>Robust accuracy</td></tr><tr><td>R+FGSM (Tramer et al., 2017)</td><td>0.15</td><td>Hypercube(0.15)</td><td>34.58 ± 36.06%</td></tr><tr><td>R+FGSM (+full step size)</td><td>0.30</td><td>Hypercube(0.15)</td><td>26.53 ± 32.48%</td></tr><tr><td>R+FGSM(+uniform init.)</td><td>0.15</td><td>Uniform(0.3)</td><td>72.92 ±10.40%</td></tr><tr><td>Uniform + full (ours)</td><td>0.30</td><td>Uniform(0.3)</td><td>86.21 ± 00.75%</td></tr></table>",
+        "bbox": [
+            217,
+            160,
+            779,
+            241
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/9671f005d45c6ef3ea074aa8debe16b5b4b9a96657f64cd6c70bb1bd3d272532.jpg",
+        "table_caption": [
+            "Table 7: Training parameters used for the DAWNBench experiments of Table 1 "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Parameter</td><td>FGSM</td><td>PGD</td><td>Free</td></tr><tr><td>Epochs</td><td>30</td><td>40</td><td>96</td></tr><tr><td>Max learning rate</td><td>0.2</td><td>0.2</td><td>0.04</td></tr></table>",
+        "bbox": [
+            225,
+            295,
+            772,
+            349
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A A DIRECT COMPARISON TO $\\mathrm { R + F G S M }$ FROM TRAMER ET AL \\` . (2017) ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            383,
+            776,
+            401
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "While a randomized version of FGSM adversarial training was proposed by Tramer et al. (2017), it \\` was not shown to be as effective as adversarial training against a PGD adversary. Here, we note the two main differences between our approach and that of Tramer et al. (2017). \\` ",
+        "bbox": [
+            176,
+            420,
+            825,
+            463
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "1. The random initialization used is different. For a data point $x$ , we initialize with the uniform distribution in the entire perturbation region with ",
+        "bbox": [
+            205,
+            479,
+            825,
+            508
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/185229118465371ee4fa12e254d041d2861df274573ae778fe9daa7373ba74d1.jpg",
+        "text": "$$\nx ^ { \\prime } = x + \\mathrm { U n i f o r m } ( - \\epsilon , \\epsilon ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            441,
+            520,
+            616,
+            537
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "In comparison, Tramer et al. (2017) instead initialize on the surface of a hypercube with \\` radius $\\epsilon / 2$ with ",
+        "bbox": [
+            230,
+            549,
+            825,
+            579
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e977387ac507d5168794d505f3d5e1aa3b94575906d2dc86f2f7d046154b0e51.jpg",
+        "text": "$$\nx ^ { \\prime } = x + \\frac { \\epsilon } { 2 } \\mathrm { N o r m a l } ( 0 , 1 ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            442,
+            584,
+            614,
+            612
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "2. The step sizes used for the FGSM step are different. We use a full step size of $\\alpha = \\epsilon$ whereas Tramer et al. (2017) use a step size of \\` $\\alpha = \\epsilon / 2$ . ",
+        "bbox": [
+            205,
+            627,
+            823,
+            656
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "To study the effect of these two differences, we run all combinations of either initialization with either step size on MNIST. The results are summarized in Table 6. ",
+        "bbox": [
+            176,
+            672,
+            821,
+            702
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We find that using a uniform initialization adds the greatest marginal improvement to the original $\\mathrm { R + F G S M }$ attack, while using a full step size doesn’t seem to help on its own. Implementing both of these improvements results in the form of FGSM adversarial training presented in this paper. Additionally, note that $\\mathrm { R + F G S M }$ as done by Tramer et al. (2017) has high variance in robust perfor- \\` mance when done over multiple random seeds, whereas our version of FGSM adversarial training is significantly more consistent and has a very low standard deviation over random seeds. ",
+        "bbox": [
+            174,
+            708,
+            825,
+            792
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "B TRAINING PARAMETERS FOR TABLE 1 ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            819,
+            526,
+            835
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "For all methods, we use a batch size of 128, and SGD optimizer with momentum 0.9 and weight decay $5 * 1 0 ^ { - 4 }$ . We report the average results over 3 random seeds. The remaining parameters for learning rate schedules and number of epochs for the DAWNBench experiments are in Table 7. For runs using early-stopping, we use a 5-step PGD adversary with 1 restart on 1 training minibatch to detect overfitting to the FGSM adversaries, as described in more detail in Section D. ",
+        "bbox": [
+            174,
+            853,
+            825,
+            924
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/d1bba9c25633d8962669c3935a2f3466ef9e4efb4a4924d48415fa31a1a505e2.jpg",
+        "image_caption": [
+            "Figure 3: Robust test performance of FGSM adversarial training over different step sizes for $\\epsilon =$ 8/255. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            300,
+            99,
+            696,
+            295
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/438b9fa287165347faded06d7f88a2848edd6e8d301f039a22b62f0e9f54a0e1.jpg",
+        "image_caption": [
+            "Figure 4: Learning curves for FGSM adversarial training plotting the training loss and error rates incurred by an FGSM and PGD adversary when trained with zero-initialization FGSM at $\\epsilon = 8 / 2 5 5$ , depicting the catastrophic overfitting where PGD performance suddenly degrades while the model overfits to the FGSM performance. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            199,
+            347,
+            820,
+            489
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "C OPTIMAL STEP SIZE FOR FGSM ADVERSARIAL TRAINING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            583,
+            689,
+            599
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Here, we test the effect of step size on the performance of FGSM adversarial training. We plot the mean and standard error of the robust accuracy for models trained for 30 epochs over 3 random seeds in Figure 3, and vary the step size from $\\alpha = 1 / 2 5 5$ to $\\alpha = 1 6 / 2 5 5$ . ",
+        "bbox": [
+            176,
+            616,
+            825,
+            659
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "We find that we get increasing robust performance as we increase the step size up to $\\alpha = 1 0 / 2 5 5$ . Beyond this, we see no further benefit, or find that the model is prone to overfitting to the adversarial examples, since the large step size forces the model to overfit to the boundary of the perturbation region. ",
+        "bbox": [
+            174,
+            665,
+            825,
+            722
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "D CATASTROPHIC OVERFITTING AND THE EFFECT OF EARLY STOPPING ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            746,
+            774,
+            761
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "While the main experiments in this paper work as is (with the cyclic learning rate and FGSM adversarial training with uniform random initialization), many of the variations of FGSM adversarial training which have been found to not succeed all fail similarly: the model will very rapidly (over the span of a couple epochs) appear to overfit to the FGSM adversarial examples. What was previously a reasonably robust model will quickly transform into a non-robust model which suffers $0 \\%$ robust accuracy (with respect to a PGD adversary). This phenomenon, which we call catastrophic overfitting, can be seen in Figure 4 which plots the learning curves for standard, vanilla FGSM adversarial training from zero-initialization. ",
+        "bbox": [
+            174,
+            776,
+            825,
+            888
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Indeed, one of the reasons for this failure may lie in the lack of diversity in adversarial examples generated by these FGSM adversaries. For example, using a zero initialization or using the random initialization scheme from Tramer et al. (2017) will result in adversarial examples whose features \\` have been perturbed by $\\{ - \\epsilon , 0 , \\epsilon \\}$ , and so the network learns a decision boundary which is robust only at these perturbation values. This can be verified by running a PGD adversarial attack on models which have catastrophically overfitted, where the perturbations tend to be more in between the origin and the boundary of the threat model (relative to a non-overfitted model, which tends to have perturbations near the boundary), as seen in Figure 5. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/aa3c7e3e733e662e25a53af4ba6b880dc993f15eb191c30368308466f3cb59bc.jpg",
+        "image_caption": [
+            "Figure 5: Histogram of the resulting perturbations from a PGD adversary for each feature for a successfully trained robust CIFAR10 model and a catastrophically overfitted CIFAR10 model. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            299,
+            99,
+            699,
+            313
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/35c4e3ab49eb82d71b381ff6080bbec6986a6fc80d5b8dbfb23fdf77aee5f45d.jpg",
+        "image_caption": [
+            "Figure 6: Robust test performance of FGSM adversarial training over different step sizes for $\\epsilon =$ $8 / 2 5 5$ with early stopping to avoid catastrophic overfitting. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            300,
+            381,
+            696,
+            575
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            659,
+            825,
+            742
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "These failure modes, including the other failure modes discussed in Section 5.4, can be easily detected by evaluating the PGD performance on a small subset of the training data, as the catastrophic failure will result in $0 \\%$ robust accuracy for a PGD adversary on the training set. In practice, we find that this can be a simple as a single minibatch with a 5-step PGD adversary, which can be quickly checked at the end of the epoch. If robust accuracy with respect to this adversary suddenly drops, then we have catastrophic overfitting. Using a PGD adversary on a training minibatch to detect catastrophic overfitting, we can early stop to avoid catastrophic overfitting and achieve a reasonable amount of robust performance. ",
+        "bbox": [
+            174,
+            750,
+            825,
+            861
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "For a concrete example, recall from Section C that step sizes larger than $1 1 / 2 5 5$ result in $0 \\%$ robust accuracy, due to this catastrophic overfitting phenomenon. By using early stopping to catch the model at its peak performance before overfitting, FGSM adversarial training with larger step sizes can actually achieve some degree of robust accuracy, as shown in Figure 6. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "table",
+        "img_path": "images/177a9fb5b030057d78463f7d6824f59d299b5e9154c7dc244200773aff2df42c.jpg",
+        "table_caption": [
+            "Table 8: Training parameters used for Figure 2 "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Parameter</td><td>FGSM</td><td>PGD</td><td>Free</td></tr><tr><td>Max learning rate</td><td>0.2</td><td>0.2</td><td>0.04</td></tr></table>",
+        "bbox": [
+            227,
+            126,
+            772,
+            165
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "table",
+        "img_path": "images/a8c4f3c01ab4a9bb5aa8faac7cd4f7e217ec7e50b3cecd00159412f128324032.jpg",
+        "table_caption": [
+            "Table 9: ImageNet classifiers trained with free adversarial training methods at $m = 3$ minibatch replay when augmented with DAWNBench optimizations, against $\\ell _ { \\infty }$ perturbations of radius $\\epsilon =$ 4/255, where 30 epochs of free training is equivalent to 15 epochs of FGSM training "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>Step size</td><td>Epochs</td><td>Standard acc.</td><td>PGD+1</td><td>PGD+10</td></tr><tr><td>Free+DAWNBench</td><td>4/255</td><td>15</td><td>49.87%</td><td>22.78%</td><td>22.18%</td></tr><tr><td>Free+DAWNBench</td><td>5/255</td><td>15</td><td>50.48%</td><td>22.88%</td><td>22.25%</td></tr><tr><td>Free+DAWNBench</td><td>4/255</td><td>30</td><td>49.87%</td><td>28.17%</td><td>27.08%</td></tr><tr><td>Free+DAWNBench</td><td>5/255</td><td>30</td><td>50.48%</td><td>28.73%</td><td>27.81%</td></tr><tr><td>Free (m = 4)</td><td>4/255</td><td>92</td><td>60.42%</td><td>31.22%</td><td>31.08%</td></tr><tr><td>FGSM</td><td>5/255</td><td>15</td><td>55.45%</td><td>30.28%</td><td>30.18%</td></tr></table>",
+        "bbox": [
+            217,
+            236,
+            781,
+            352
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "E TRAINING PARAMETERS FOR FIGURE 2 ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            381,
+            534,
+            397
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "For all methods, we use a batch size of 128, and SGD optimizer with momentum 0.9 and weight decay $5 * 1 0 ^ { - 4 }$ . We report the average results over 3 random seeds. Maximum learning rates used for the cyclic learning rate schedule are shown in Table 8. ",
+        "bbox": [
+            173,
+            412,
+            825,
+            455
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "F COMBINING FREE ADVERSARIAL TRAINING WITH DAWNBENCH IMPROVEMENTS ON IMAGENET ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            477,
+            746,
+            508
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "While adding mixed-precision is a direct speedup to free adversarial training without hurting performance, using other optimization tricks such as the cyclic learning rate schedule, progressive resizing, and batch-norm regularization may affect the final performance of free adversarial training. Since ImageNet is too large to run a comprehensive search over the various parameters as was done for CIFAR10 in Table 3, we instead test the performance of free adversarial training when used as a drop-in replacement for FGSM adversarial training with all the same optimizations used for FGSM adversarial training. We use free adversarial training with $m = 3$ minibatch-replay, with 2 epochs for phase one, 2 epochs for phase two, and 1 epoch for phase three to be equivalent to 15 epochs of standard training. $\\mathrm { P G D } { + } N$ denotes the accuracy under a PGD adversary with $N$ restarts. ",
+        "bbox": [
+            173,
+            523,
+            825,
+            650
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "A word of caution: this is not to claim that free adversarial training is completely incompatible with the DAWNBench optimizations on ImageNet. By giving free adversarial training more epochs, it may be possible recover the same or better performance. However, tuning the DAWNBench techniques to be optimal for free adversarial training is not the objective of this paper, and so this is merely to show what happens if we naively apply the same DAWNBench tricks used for FGSM adversarial training to free adversarial training. Since free adversarial training requires more epochs even when tuned with DAWNBench improvements for CIFAR10, we suspect that the same behavior occurs here for ImageNet, and so 15 epochs is likely not enough to obtain top performance for free adversarial training. Since one epoch of FGSM adversarial training is equivalent to two epochs of free training, a fairer comparison is to give free adversarial training 30 epochs instead of 15. Even with double the epochs (and thus the same compute time as FGSM adversarial training), we find that it gets closer but doesn’t quite recover the original performance of free adversarial training. ",
+        "bbox": [
+            174,
+            656,
+            825,
+            824
+        ],
+        "page_idx": 16
+    }
+]

parse/train/BkisuzWRW/BkisuzWRW.md

@@ -0,0 +1,308 @@
+# ZERO-SHOT VISUAL IMITATION
+
+Deepak Pathak∗, Parsa Mahmoudieh∗, Guanghao Luo∗, Pulkit Agrawal∗, Dian Chen, Yide Shentu, Evan Shelhamer, Jitendra Malik, Alexei A. Efros, Trevor Darrell
+
+UC Berkeley
+
+{pathak,parsa.m,michaelluo,pulkitag,dianchen, fredshentu,shelhamer,malik,efros,trevor}@cs.berkeley.edu
+
+# ABSTRACT
+
+The current dominant paradigm for imitation learning relies on strong supervision of expert actions to learn both what and how to imitate. We pursue an alternative paradigm wherein an agent first explores the world without any expert supervision and then distills its experience into a goal-conditioned skill policy with a novel forward consistency loss. In our framework, the role of the expert is only to communicate the goals (i.e., what to imitate) during inference. The learned policy is then employed to mimic the expert (i.e., how to imitate) after seeing just a sequence of images demonstrating the desired task. Our method is “zero-shot” in the sense that the agent never has access to expert actions during training or for the task demonstration at inference. We evaluate our zero-shot imitator in two real-world settings: complex rope manipulation with a Baxter robot and navigation in previously unseen office environments with a TurtleBot. Through further experiments in VizDoom simulation, we provide evidence that better mechanisms for exploration lead to learning a more capable policy which in turn improves end task performance. Videos, models, and more details are available at https://pathak22.github.io/zeroshot-imitation/.
+
+# 1 INTRODUCTION
+
+Imitating expert demonstration is a powerful mechanism for learning to perform tasks from raw sensory observations. The current dominant paradigm in learning from demonstration (LfD) (Argall et al., 2009; $\mathrm { N g }$ & Russell, 2000; Pomerleau, 1989; Schaal, 1999) requires the expert to either manually move the robot joints (i.e., kinesthetic teaching) or teleoperate the robot to execute the desired task. The expert typically provides multiple demonstrations of a task at training time, and this generates data in the form of observation-action pairs from the agent’s point of view. The agent then distills this data into a policy for performing the task of interest. Such a heavily supervised approach, where it is necessary to provide demonstrations by controlling the robot, is incredibly tedious for the human expert. Moreover, for every new task that the robot needs to execute, the expert is required to provide a new set of demonstrations.
+
+Instead of communicating how to perform a task via observation-action pairs, a more general formulation allows the expert to communicate only what needs to be done by providing the observations of the desired world states via a video or a sparse sequence of images. This way, the agent is required to infer how to perform the task (i.e., actions) by itself. In psychology, this is known as observational learning (Bandura & Walters, 1977). While this is a harder learning problem, it is a more interesting setting, because the expert can demonstrate multiple tasks quickly and easily.
+
+An agent without any prior knowledge will find it extremely hard to imitate a task by simply watching a visual demonstration in all but the simplest of cases. Thus, the natural question is: in order to imitate, what form of prior knowledge must the agent possess? A large body of work (Breazeal & Scassellati, 2002; Dillmann, 2004; Ikeuchi & Suehiro, 1994; Kuniyoshi et al., 1989; 1994; Yang et al., 2015) has sought to capture prior knowledge by manually pre-defining the state that must be inferred from the observations. The agent then infers how to perform the task (i.e., plan for imitation) using this state. Unfortunately, computer vision systems are often unable to estimate the state variables accurately and it has proven non-trivial for downstream planning systems to be robust to such errors.
+
+![](images/434a373c7a71373e1b8cff5cbcc2f991d2bed131753c2fa08b2da192ece06e28.jpg)  
+Figure 1: The goal-conditioned skill policy (GSP) takes as input the current and goal observations and outputs an action sequence that would lead to that goal. We compare the performance of the following GSP models: (a) Simple inverse model; (b) Mutli-step GSP with previous action history; (c) Mutli-step GSP with previous action history and a forward model as regularizer, but no forward consistency; (d) Mutli-step GSP with forward consistency loss proposed in this work.
+
+In this paper, we follow (Agrawal et al., 2016; Levine et al., 2016; Pinto & Gupta, 2016) in pursuing an alternative paradigm, where an agent explores the environment without any expert supervision and distills this exploration data into goal-directed skills. These skills can then be used to imitate the visual demonstration provided by the expert (Nair et al., 2017). Here, by skill we mean a function that predicts the sequence of actions to take the agent from the current observation to the goal. We call this function a goal-conditioned skill policy (GSP). The GSP is learned in a self-supervised way by re-labeling the states visited during the agent’s exploration of the environment as goals and the actions executed by the agent as the prediction targets, similar to (Agrawal et al., 2016; Andrychowicz et al., 2017). During inference, given goal observations from a demonstration, the GSP can infer how to reach these goals in turn from the current observation, and thereby imitate the task step-by-step.
+
+One critical challenge in learning the GSP is that, in general, there are multiple possible ways of going from one state to another: that is, the distribution of trajectories between states is multimodal. We address this issue with our novel forward consistency loss based on the intuition that, for most tasks, reaching the goal is more important than how it is reached. To operationalize this, we first learn a forward model that predicts the next observation given an action and a current observation. We use the difference in the output of the forward model for the GSP-selected action and the ground truth next state to train the GSP. This loss has the effect of making the GSP-predicted action consistent with the ground-truth action instead of exactly matching the actions themselves, thus ensuring that actions that are different from the ground-truth—but lead to the same next state— are not inadvertently penalized. To account for varying number of steps required to reach different goals, we propose to jointly optimize the GSP with a goal recognizer that determines if the current goal has been satisfied. See Figure 1 for a schematic illustration of the GSP architecture.
+
+We call our method zero-shot because the agent never has access to expert actions, neither during training of the GSP nor for task demonstration at inference. In contrast, most recent work on oneshot imitation learning requires full knowledge of actions and a wealth of expert demonstrations during training (Duan et al., 2017; Finn et al., 2017). In summary, we propose a method that (1) does not require any extrinsic reward or expert supervision during learning, (2) only needs demonstrations during inference, and (3) restricts demonstrations to visual observations alone rather than full stateactions. Instead of learning by imitation, our agent learns to imitate.
+
+We evaluate our zero-shot imitator on real-world robots for rope manipulation tasks using a Baxter and office navigation using a TurtleBot. We show that the proposed forward consistency loss improves the performance on the complex task of knot tying from $3 \hat { 6 } \%$ to $6 0 \%$ accuracy. In navigation experiments, we steer a simple wheeled robot around partially-observable office environments and show that the learned GSP generalizes to unseen environments. Furthermore, using navigation experiments in VizDoom environment, we show that (GSP) learned using curiosity-driven exploration (Oudeyer et al., 2007; Pathak et al., 2017; Schmidhuber, 1991) can more accurately follow demonstrations as compared to using random exploration data for learning the GSP. Overall our experiments show that the forward-consistent GSP can be used to imitate a variety of tasks without making environment or task-specific assumptions.
+
+# 2 LEARNING TO IMITATE WITHOUT EXPERT SUPERVISION
+
+Let $\boldsymbol { S } : \{ x _ { 1 } , a _ { 1 } , x _ { 2 } , a _ { 2 } , . . . , x _ { T } \}$ be the sequence of observations and actions generated by the agent as it explores its environment using the policy $a = \pi _ { E } ( s )$ . This exploration data is used to learn the goal-conditioned skill policy (GSP) $\pi$ takes as input a pair of observations $( x _ { i } , x _ { g } )$ and outputs sequence of actions $( \vec { a } _ { \tau } : a _ { 1 } , a _ { 2 } . . . a _ { K } )$ required to reach the goal observation $( x _ { g } )$ from the current observation $( x _ { i } )$ .
+
+$$
+\vec { a } _ { \tau } = \pi ( x _ { i } , x _ { g } ; \theta _ { \pi } )
+$$
+
+where states $x _ { i } , x _ { g }$ are sampled from the $s$ . The number of actions, $K$ , is also inferred by the model. We represent $\pi$ by a deep network with parameters $\theta _ { \pi }$ in order to capture complex mappings from visual observations $( x )$ to actions. $\pi$ can be thought of as a variable-step generalization of the inverse dynamics model (Jordan & Rumelhart, 1992), or as the policy corresponding to a universal value function (Foster & Dayan, 2002; Schaul et al., 2015), with the difference that $x _ { g }$ need not be the end goal of a task but can also be an intermediate sub-goal.
+
+Let the task to be imitated be provided as a sequence of images $\mathcal { D } : \{ x _ { 1 } ^ { d } , x _ { 2 } ^ { d } , . . . , x _ { N } ^ { d } \}$ captured when the expert demonstrates the task. This sequence of images $\mathcal { D }$ could either be temporally dense or sparse. Our agent uses the learned $\mathrm { G S P } \pi$ to imitate the sequence of visual observations $\mathcal { D }$ starting from its initial state $x _ { 0 }$ by following actions predicted by $\bar { \pi } ( x _ { 0 } , x _ { 1 } ^ { d } ; \theta _ { \pi } )$ . Let the observation after executing the predicted action be $x _ { 0 } ^ { \bar { \prime } }$ . Since multiple actions might be required to reach close to $x _ { 1 } ^ { d }$ , the agent queries a separate goal recognizer network to ascertain if the current observation is close to the goal or not. If the answer is negative, the agent executes the action $a = \pi ( x _ { 0 } ^ { \prime } , x _ { 1 } ^ { d } ; \theta _ { \pi } )$ . This process is repeated iteratively until the goal recognizer outputs that agent is near the goal, or a maximum number of steps are reached. Let the observation of the agent at this point be ${ \hat { x } } _ { 1 }$ . After reaching close to the first observation $( x _ { 1 } ^ { d } )$ in the demonstration, the agent sets its goal as $( x _ { 2 } ^ { d } )$ and repeats the process. The agent stops when all observations in the demonstrations are processed.
+
+Note that in the method of imitation described above, the expert is never required to convey to the agent what actions it performed. In the following subsections we describe how we learn the GSP, forward consistency loss, goal recognizer network and various baseline methods.
+
+# 2.1 LEARNING THE GOAL-CONDITIONED SKILL POLICY (GSP)
+
+We first describe the one-step version of GSP and then extend it to variable length multi-step skills. One-step trajectories take the form of $( x _ { t } , a _ { t } , x _ { t + 1 } )$ and GSP, $\hat { a _ { t } } = \pi ( x _ { t } , x _ { t + 1 } ; \theta _ { \pi } )$ , is trained by minimizing the standard cross-entropy loss $\mathcal { L } ( a _ { t } , \hat { a } _ { t } )$ ,
+
+$$
+\mathcal { L } ( a _ { t } , \hat { a } _ { t } ) = p ( a _ { t } | x _ { t } , x _ { t + 1 } ) \log ( \hat { a _ { t } } )
+$$
+
+with respect to parameters $\theta _ { \pi }$ , where $p$ and $\hat { a _ { t } }$ are the ground-truth and predicted action distributions. While we do not have access to true $p$ , we empirically approximate it using samples from the distribution, $a _ { t }$ , that are executed by the agent during exploration. For minimizing the crossentropy loss, it is common to assume $p$ as a delta function at $a _ { t }$ . However, this assumption is notably violated if $p$ is inherently multi-modal and high-dimensional. If we optimize say a deep neural network assuming $p$ to be a delta function, the same inputs will be presented with different targets (due to multi-modality) leading to high-variance in gradients which in turn would make learning challenging.
+
+In our setup, such multi-modality can occur because multiple actions can lead the agent to the same future observation from the initial observation. For instance, in navigation, if the agent is stuck against a corner, turning or moving forward all collapse to the same effect. The issue of multimodality becomes more critical as the length of trajectories grow, because more and more paths may take the agent from the initial observation to the goal observation given more time. Furthermore, it would require many samples to even obtain a good empirical estimate of a high-dimensional multimodal action distribution $p$ .
+
+# 2.2 FORWARD CONSISTENCY LOSS
+
+One way to account for multi-modality is by employing the likes of variational autoencoders (Kingma & Welling, 2013; Rezende et al., 2014). However, in many practical situations it is not feasible to obtain ample data for each mode. In this work, we propose an alternative based on the insight that in many scenarios, we only care about whether the agent reached the final state or not and the exact trajectory is of lesser interest. Instead of penalizing the actions predicted by the GSP to match the ground truth, we propose to learn the parameters of GSP by minimizing the distance between observation $\hat { x } _ { t + 1 }$ resulting by executing the predicted action $\hat { a } _ { t } = \pi ( x _ { t } , x _ { t + 1 } ; \theta _ { \pi } )$ and the observation $x _ { t + 1 }$ , which is the result of executing the ground truth action $a _ { t }$ being used to train the GSP. In this formulation, even if the predicted and ground-truth action are different, the predicted action will not be penalized if it leads to the same next state as the ground-truth action. While this formulation will not explicitly maintain all modes of the action distribution, it will reduce the variance in gradients and thus help learning. We call this penalty the forward consistency loss.
+
+Note that it is not immediately obvious as to how to operationalize forward consistency loss for two reasons: (a) we need the access to a good forward dynamics model that can reliably predict the effect of an action (i.e., the next observation state) given the current observation state, and (b) such a dynamics model should be differentiable in order to train the GSP using the state prediction error. Both of these issues could be resolved if an analytic formulation of forward dynamics is known.
+
+In many scenarios of interest, especially if states are represented as images, an analytic forward model is not available. In this work, we learn the forward dynamics $f$ model from the data, and is defined as $\tilde { x } _ { t + 1 } = f ( x _ { t } , a _ { t } ; \theta _ { f } )$ . Let $\hat { x } _ { t + 1 } = f ( x _ { t } , \hat { a } _ { t } ; \theta _ { f } )$ be the state prediction for the action predicted by $\pi$ . Because the forward model is not analytic and learned from data, in general, there is no guarantee that $\tilde { x } _ { t + 1 } = \widehat { x } _ { t + 1 }$ , even though executing these two actions, $a _ { t } , { \hat { a } } _ { t }$ , in the real-world will have the same effect. In order to make the outcome of action predicted by the GSP and the ground-truth action to be consistent with each other, we include an additional term, $\lVert x _ { t + 1 } - \hat { x } _ { t + 1 } \rVert _ { 2 } ^ { 2 }$ in our loss function and infer the parameters $\theta _ { f }$ by minimizing $\begin{array} { r l r } { \| x _ { t + 1 } - \tilde { x } _ { t + 1 } \| _ { 2 } ^ { 2 } } & { { } + } & { \lambda \| x _ { t + 1 } - } \end{array}$ $\hat { x } _ { t + 1 } \| _ { 2 } ^ { 2 }$ , where $\lambda$ is a scalar hyper-parameter. The first term ensures that the learned forward model explains ground truth transitions $( x _ { t } , a _ { t } , x _ { t + 1 } )$ collected by the agent and the second term ensures consistency. The joint objective for training GSP with forward model consistency is:
+
+$$
+\begin{array} { r l } { \underset { \theta _ { \pi } , \theta _ { f } } { \operatorname* { m i n } } } & { \| x _ { t + 1 } - \tilde { x } _ { t + 1 } \| _ { 2 } ^ { \overline { { 2 } } } + \lambda \| x _ { t + 1 } - \hat { x } _ { t + 1 } \| _ { 2 } ^ { 2 } + \mathcal { L } ( a _ { t } , \hat { a } _ { t } ) } \\ { \mathrm { s . t . } } & { \tilde { x } _ { t + 1 } = f ( x _ { t } , a _ { t } ; \theta _ { f } ) } \\ & { \hat { x } _ { t + 1 } = f ( x _ { t } , \hat { a } _ { t } ; \theta _ { f } ) } \\ & { \hat { a } _ { t } = \pi ( x _ { t } , x _ { t + 1 } ; \theta _ { \pi } ) } \end{array}
+$$
+
+Note that learning $\theta _ { \pi } , \theta _ { f }$ jointly from scratch is precarious, because the forward model $f$ might not be good in the beginning, and hence could make the gradient updates noisier for $\pi$ . To address this issue, we first pre-train the forward model with only the first term and GSP separately by blocking the gradient flow and then fine-tune jointly.
+
+Generalization to feature space dynamics Past work has shown that learning forward dynamics in the feature space as opposed to raw observation space is more robust and leads to better generalization (Agrawal et al., 2016; Pathak et al., 2017). Following these works, we extend the GSP to make predictions in feature representation $\phi ( x _ { t } ) , \phi ( x _ { t + 1 } )$ of the observations $x _ { t } , x _ { t + 1 }$ respectively learned through the self-supervised task of action prediction. The forward consistency loss is then computed by making predictions in this feature space $\phi$ instead of raw observations. The optimization objective for feature space generalization with mutli-step objective is shown in Equation (4).
+
+Generalization to multi-step GSP We extend our one-step optimization to variable length sequence of actions in a straightforward manner by having a multi-step GSP $\pi _ { m }$ model with a stepwise forward consistency loss. The GSP $\pi _ { m }$ maintains an internal recurrent memory of the system and outputs actions conditioned on current observation $x _ { t }$ , starting from $x _ { i }$ to reach goal observation $x _ { T }$ . The forward consistency loss is computed at each time step, and jointly optimized with the action prediction loss over the whole trajectory. The final multi-step objective with feature space dynamics is as follows:
+
+$$
+\begin{array} { r l } { \underset { \theta _ { \pi } , \theta _ { f } , \theta _ { \phi } } { \operatorname* { m i n } } } & { \displaystyle \sum _ { t = i } ^ { t = T } \Big ( \| \phi ( x _ { t + 1 } ) - \tilde { \phi } ( x _ { t + 1 } ) \| _ { 2 } ^ { 2 } + \lambda \| \phi ( x _ { t + 1 } ) - \hat { \phi } ( x _ { t + 1 } ) \| _ { 2 } ^ { 2 } + \mathcal L ( a _ { t } , \hat { a } _ { t } ) \Big ) } \\ { \mathrm { s . t . } } & { \tilde { \phi } ( x _ { t + 1 } ) = f ( \phi ( x _ { t } ) , a _ { t } ; \theta _ { f } ) } \\ & { \hat { \phi } ( x _ { t + 1 } ) = f ( \phi ( x _ { t } ) , \hat { a } _ { t } ; \theta _ { f } ) } \\ & { \hat { a } _ { t } = \pi ( \phi ( x _ { t } ) , \phi ( x _ { T } ) ; \theta _ { \pi } ) } \end{array}
+$$
+
+where $\phi ( . )$ is represented by a CNN with parameters $\theta _ { \phi }$ . The number of steps taken by the multistep GSP $\pi _ { m }$ to reach the goal at inference is variable depending on the decision of goal recognizer; described in next subsection. Note that, in this objective, if $\phi$ is identity then the dynamics simply reduces to modeling in raw observation space. We analyze feature space prediction in VizDoom 3D navigation and stick to observation space in the rope manipulation and the office navigation tasks.
+
+The multi-step forward-consistent $G S P \pi _ { m }$ is implemented using a recurrent network which at every step takes as input the feature representation of the current $( \phi ( x _ { t } ) )$ state, goal $( \phi ( x _ { T } ) )$ states, action at the previous time step $\left( a _ { t - 1 } \right)$ and the internal hidden representation $h _ { t - 1 }$ of the recurrent units and predicts $\hat { a } _ { t }$ . Note that inputting the previous action to $\mathrm { G S P } \pi _ { m }$ at each time step could be redundant given that hidden representation is already maintaining a history of the trajectory. Nonetheless, it is helpful to explicitly model this history. This formulation amounts to building an auto-regressive model of the joint action that estimates probability $P ( a _ { t } | x _ { 1 } , a _ { 1 } , . . . a _ { t - 1 } , x _ { t } , x _ { g } )$ at every time step. It is possible to further extend our forward-consistent GSP $\pi _ { m }$ to build multi-step forward model, but we leave that direction of future work.
+
+# 2.3 GOAL RECOGNIZER
+
+We train a goal recognizer network to figure out if the current goal is reached and therefore allow the agent to take variable numbers of steps between goals. Goal recognition is especially critical when the agent has to transit through a sequence of intermediate goals, as is the case for visual imitation, as otherwise compounding error could quickly lead to divergence from the demonstration. This recognition is simple given knowledge of the true physical state, but difficult when working with visual observations. Aside from the usual challenges of visual recognition, the dependence of observations on the agent’s own dynamics further complicates goal recognition, as the same goal can appear different while moving forward or turning during navigation.
+
+We pose goal recognition as a binary classification problem that given an observation $x _ { i }$ and the goal $x _ { g }$ infers if $x _ { i }$ is close to $x _ { g }$ or not. Lacking expert supervision of goals, we draw goal observations at random from the agent’s experience during exploration, since they are known to be feasible. For each such pseudo-goal, we consider observations that were only a few actions away to be positives (i.e., close to the goal) and the remaining observations that were more than a fixed number of actions (i.e., a margin) away as negatives. We trained the goal classifier using the standard cross-entropy loss. Like the skill policy, our goal recognizer is conditioned on the goal for generalization across goals. We found that training an independent goal recognition network consistently outperformed the alternative approach that augments the action space with a “stop” action. Making use of temporal proximity as supervision has also been explored for feature learning in the concurrent work of Sermanet et al. (2018).
+
+# 2.4 ABLATIONS AND BASELINES
+
+Our proposed formulation of GSP composed of following components: (a) recurrent variable-length skill policy network, (b) explicitly encoding previous action in the recurrence, (c) goal recognizer, (d) forward consistency loss function, and (w) learning forward dynamics in the feature space instead of raw observation space. We systematically ablate these components of forward-consistent GSP, to quantitatively review the importance of each component and then perform comparisons to the prior approaches that could be deployed for the task of visual imitation.
+
+![](images/eae4b6382f956de78ccfb3d61bb1504645c7601322aa79336c4ca70b4e33e508.jpg)  
+Figure 2: Qualitative visualization of results for rope manipulation task using Baxter robot. (a) Our robotics system setup. (b) The sequence of human demonstration images provided by the human during inference for the task of knot-tying (top row), and the sequences of observation states reached by the robot while imitating the given demonstration (bottom rows). (c) The sequence of human demonstration images and the ones reached by the robot for the task of manipulating rope into $\mathbf { \partial } ^ { \cdot } \mathbf { S } ^ { \prime }$ shape. Our agent is able to successfully imitate the demonstration.
+
+The following methods will be evaluated and compared to in the subsequent experiments section: (1) Classical methods: In visual navigation, we attempted to compare against the state-of-the-art open source classical methods, namely, ORB-SLAM2 (Davison & Murray, 1998; Mur-Artal & Tardos, ´ 2017) and Open-SFM (Mapillary, 2016). (2) Inverse Model: Nair et al. (2017) leverage vanilla inverse dynamics to follow demonstration in rope manipulation setup. We compare to their method in both visual navigation and manipulation. (3) GSP-NoPrevAction-NoFwdConst is the ablation of our recurrent GSP without previous action history and without forward consistency loss. (4) GSP-NoFwdConst refers to our recurrent GSP with previous action history, but without forward consistency objective. (5) GSP-FwdRegularizer refers to the model where forward prediction is only used to regularize the features of GSP but has no role to play in the loss function of predicted actions. The purpose of this variant is to particularly ablate the benefit of consistency loss function with respect to just having forward model as feature regularizer. (6) GSP refers to our complete method with all the components. We now discuss the experiments and evaluate these baselines.
+
+# 3 EXPERIMENTS
+
+We evaluate our model by testing its performance on: rope manipulation using Baxter robot, navigation of a wheeled robot in cluttered office environments, and simulated 3D navigation. The key requirements of a good skill policy are that it should generalize to unseen environments and new goals while staying robust to irrelevant distractors in the observations. For rope manipulation, we evaluate generalization by testing the ability of the robot to manipulate the rope into configurations such as knots that were not seen during random exploration. For navigation, both real-world and simulation, we check generalization by testing on a novel building/floor.
+
+# 3.1 ROPE MANIPULATION
+
+Manipulation of non-rigid and deformable objects, e.g., rope, is a challenging problem in robotics. Even humans learn complex rope manipulation such as tying knots, either by observing an expert
+
+<table><tr><td>Method</td><td>Success %</td></tr><tr><td>Inverse Model [Nair et.al. 2017]</td><td>36%± 9.6%</td></tr><tr><td>Forward-regularized GSP</td><td>44%± 9.9%</td></tr><tr><td>Forward-consistent GSP [Ours]</td><td>60% ± 9.8%</td></tr><tr><td></td><td></td></tr></table>
+
+![](images/c118b28d8a83c13253a4b46c69b0cdd73a3ab2269efb886b97d23af45a7c11ed.jpg)  
+Manipulation of non-rigid and deformable objects, e.g., rope, is a challenging problem iFigure 3: GSP trained using forward consistency loss significantly outperforms the baselines at the Even huperformtask of (a) manipulating rope into $\mathbf { \partial } ^ { 6 } \mathbf { S } ^ { \prime }$ s learn complex rope manipulation such as tying knots, either by observingby receiving explicit instructions. To test whether our agent could manipu shape as measured by TPS-RPM error and (b) knot-tying by simply observing a human, we use the dawhere we report success rate with bootstrap standard deviation.
+
+60K interaction pairs of the form (xt, at, xt+1) that are used to train the GSP.perform it or by receiving explicit instructions. We test whether our agent could manipulate ropes During inference, our proposed approach is tasked to follow a visual demonstration provby simply observing a human perform it. We use the data collected by Nair et al. (2017), where human expert for manipulating the rope into a complex ‘S’ shape and tying a knot. Our agea Baxter robot manipulated a rope kept on the table in front of it. During exploration, the robot robot, only gets to observe the image sequence of intermediate states, as human manipinteracts with the rope by using a pick and place primitive that chooses a random point on the rope rope, without any access to the corresponding actions. Note that the knot shape is never enand displaces it by a randomly chosen length and direction. This process is repeated a number of generalize to be able to follow thtimes to collect about 60K interaction pairs of the form $( x _ { t } , a _ { t } , x _ { t + 1 } )$ ration. More details follow in the suppthat are used to train the GSP.
+
+During inference, our proposed approach is tasked to follow a visual demonstration provided by a Metric The performance of thhuman expert for manipulating the rope into a complex $\mathbf { \partial } ^ { \bullet } \mathbf { S } ^ { \bullet }$ odel is evaluated by measuring the non-rigid registr shape and tying a knot. Our agent, Baxter the demonstration. The matching cost is measured using the thin plate spline robust pointrobot, only gets to observe the image sequence of intermediate states, as human manipulates the technique (TPS-RPM) described in (Chui & Rangarajan, 2003). While TPS-RPM providrope, without any access to the corresponding actions. Note that the knot shape is never encountered metric for measuring performance for constructing the ‘S’ shape, it is not an appropriateduring the self-supervised data collection phase and therefore the learned GSP model would have to knots because the configuration of the rope in a knot is 3D due to intertwining of the ropegeneralize to be able to follow the human demonstration. More details follow in the supplementary material, Section A.1.
+
+Visual Imitation We compare our approach to the previous best method of visual imitMetric The performance of the model is evaluated by measuring the non-rigid registration cost deploys an inverse model which takes as input a pair of current and goal images to between the rope state achieved by the robot and the state demonstrated by the human at every step in for a fair comparison. The comparison is performed apples-to-apples and the only differethe demonstration. The matching cost is measured using the thin plate spline robust point matching we deploy forward-consistency loss for our approach. The results in Figure 2 show that otechnique (TPS-RPM) described in (Chui & Rangarajan, 2003). While TPS-RPM provides a good significantly outperforms the basmetric for measuring performance for constructing the $\mathbf { \epsilon } ^ { 6 } \mathbf { S } ^ { \prime }$ at task of manipulating the rope in the ‘S’ shape and shape, it is not an appropriate metric for an accuracy of 60% in comparison to 36% achieved by the baseline.knots because the configuration of the rope in a knot is 3D due to intertwining of the rope, and it fails to find the correct point correspondences. We, therefore, use success rate as the metric in knot 3.2 NAV IGAT ION IN INDOOR OFFICE ENVIRONMENTStying where the completion of a successful knot is judged by human verification.
+
+A natural way to instruct a robot to move in an indoor office environment is to ask it tVisual Imitation Qualitative examples of our agent trying to manipulate rope are shown in Figure 2. command the robot, in this work, we communicate with the robot by either showing it a sinWe compare our approach to the baseline that deploys an inverse model which takes as input a pair of the goal, or a sequence of images leading to faraway goals. In both scenarios, the robot iof current and goal images to output the desired action to reach the goal (Nair et al., 2017). We reto autonomously determine the motor commands for moving to the goal. We used Turtimplement the baseline and train in our setup for a fair comparison. To further ablate the importance navigation using an onboard camera for sensing RGB images. For learning the GSP, an aof consistency loss, we compare to a baseline that just uses a forward model as a regularizer of features. The results in Figure 3 show that our method significantly outperforms the baseline at task twoof manipulating the rope in the $\mathbf { \partial } ^ { \cdot } \mathbf { S } ^ { \prime }$ ors of a academic building in total. We then dep shape and achieves a success rate of $6 0 \%$ the learned model on ain comparison to $3 6 \%$ achieved by the baseline.
+
+# 3.2 NAVIGATION IN INDOOR OFFICE ENVIRONMENTS
+
+A natural way to instruct a robot to move in an indoor office environment is to ask it to go near a certain location, such as a refrigerator or a someone’s office. Instead of using language to command the robot, in this work, we communicate with the robot by either showing it a single image of the goal, or a sequence of images leading to faraway goals. In both scenarios, the robot is required to autonomously determine the motor commands for moving to the goal. We used TurtleBot2 for navigation using an onboard camera for sensing RGB images. For learning the GSP, an automated
+
+![](images/a29bde948214b45c66c17edaa9b35cd33f80620e6ae9d7303d434715280bc509.jpg)  
+Figure 4: Visualization of the TurtleBot trajectory to reach a goal image (right) from the initial image (top-left). Since the initial and goal image have no overlap, the robot first explores the environment by turning in place. Once it detects overlap between its current image and goal image (i.e. step 42 onward), it moves towards the goal. Note that we did not explicitly train the robot to explore and such exploratory behavior naturally emerged from the self-supervised learning.
+
+<table><tr><td>Model Name</td><td>Run Id-1</td><td>Run Id-2</td><td>Run Id-3</td><td>Run Id-4</td><td>Run Id-5</td><td>Run Id-6</td><td>Run Id-7</td><td>Run Id-8</td><td>Num Success</td></tr><tr><td>Random Search</td><td>Fail</td><td>Fail</td><td>Fail</td><td>Fail</td><td>Fail</td><td>Fail</td><td>Fail</td><td>Fail</td><td>0</td></tr><tr><td>Inverse Model[Nair et.al. 2017]</td><td>Fail</td><td>Fail</td><td>Fail</td><td>Fail</td><td>Fail</td><td>Fail</td><td>Fail</td><td>Fail</td><td>0</td></tr><tr><td>GSP-NoPrevAction-NoFwdConst</td><td>39 steps</td><td>34 steps</td><td>Fail</td><td>Fail</td><td>Fail</td><td>Fail</td><td>Fail</td><td>Fail</td><td>2</td></tr><tr><td>GSP-NoFwdConst</td><td>22 steps</td><td>22 steps</td><td>39 steps</td><td>48 steps</td><td>Fail</td><td>Fail</td><td>Fail</td><td>Fail</td><td>4</td></tr><tr><td>GSP (Ours)</td><td>119 steps</td><td>66 steps</td><td>144 steps</td><td>67 steps</td><td>51 steps</td><td>Fail</td><td>100 steps</td><td>Fail</td><td>6</td></tr></table>
+
+Table 1: Quantitative evaluation of various methods on the task of navigating using a single image of goal in an unseen environment. Each column represents a different run of our system for a different initial/goal image pair. Our full GSP model takes longer to reach the goal on average given a successful run but reaches the goal successfully at a much higher rate.
+
+self-supervised scheme for data collection was devised that doesn’t require human supervision. The robot collected a number of navigation trajectories from two floors of a academic building which in total contain 230K interactions data, i.e. $( x _ { t } , a _ { t } , x _ { t + 1 } )$ . We then deployed the learned model on a separate floor of a building with substantially different textures and furniture layout for performing visual imitation at test time. The details of the robotic setup, data collection, and network architecture of GSP are described in supplementary material, Section A.2.
+
+1) Goal Finding We first tested if the GSP learned by the TurtleBot can enable it to find its way to a goal that is within the same room from just a single image of the goal. To test the extrapolative generalization, we keep the Turtlebot approximately 20-30 steps away from the target location in a way that current and goal observations have no overlap as shown in Figure 4. We test the robot in an indoor office environment on a different floor that it has never encountered before. We judge the robot to be successful if it stops close to the goal and failure if it crashed into furniture or does not reach the goal within 200 steps. Since the initial and goal images have no overlap, classical techniques such as structure from motion that rely on feature matching cannot be used to infer the executed action. Therefore, in order to reach the goal, the robot must explore its surroundings. We find that our GSP model outperforms the baseline models in reaching the target location. Our model learns the exploratory behavior of rotating in place until it encounters an overlap between its current and goal image. Results are shown in Table 1 and videos are available at the website 1.
+
+2) Visual Imitation In the previous paragraph, we saw that the robot can reach a goal that’s within the same room. However, our agent is unable to reach far away goals such as in other rooms using just a single image. In such scenarios, an expert might communicate instructions like go to the door, turn right, go to the closest chair etc. Instead of language instruction, in our setup we provide a sequence of landmark images to convey the same high-level idea. These landmark images were captured from the robot’s camera as the expert moved the robot from the start to a goal location. However, note that it is not necessary for the expert to control the robot to capture the images because we don’t make use of the expert’s actions, but only the images. Instead of providing the image after every action in the demonstration, we only provided every fifth image. The rationale behind this choice is that we want to sample the demonstration sparsely to minimize the agent’s
+
+![](images/d73cebcd59f84f7349737b59d7c4d067bdee1cbd515f7bbb88ec98234df23365.jpg)  
+Figure 5: The performance of TurtleBot at following a visual demonstration given as a sequence of images (top row). The TurtleBot is positioned in a manner such that the first image in demonstration has no overlap with its current observation. Even under this condition the robot is able to move close to the first demo image (shown as Robot WayPoint-1) and then follow the provided demonstration until the end. This also exemplifies a failure case for classical methods; there are no possible keypoint matches between WayPoint-1 and WayPoint-2, and the initial observation is even farther from WayPoint-1.
+
+<table><tr><td></td><td colspan="3">Maze Demonstration</td><td colspan="3">Loop Demonstration</td></tr><tr><td>Model Name</td><td>Run-1</td><td>Run-2</td><td>Run-3</td><td>Run-1</td><td>Run-2</td><td>Run-3</td></tr><tr><td>SIFT</td><td>10%</td><td>5%</td><td>15%</td><td></td><td></td><td></td></tr><tr><td>GSP-NoPrevAction-NoFwdConst</td><td>60%</td><td>70%</td><td>100%</td><td></td><td>一</td><td></td></tr><tr><td>GSP-NoFwdConst</td><td>65%</td><td>90%</td><td>100%</td><td>0%</td><td>0%</td><td>0%</td></tr><tr><td>GSP (ours)</td><td>100%</td><td>60%</td><td>100%</td><td>0%</td><td>100%</td><td>100%</td></tr></table>
+
+Table 2: Quantitative evaluation of TurtleBot’s performance at following visual demonstrations in two scenarios: maze and the loop. We report the $\%$ of landmarks reached by the agent across three runs of two different demonstrations. Results show that our method outperforms the baselines. Note that 3 more trials of the loop demonstration were tested under significantly different lighting conditions and neither model succeeded. Detailed results are available in the supplementary materials.
+
+reliance on the expert. Such sub-sampling (as shown in Figure 5) provides an easy way to vary the complexity of the task.
+
+We evaluate via multiple runs of two demonstrations, namely, maze demonstration where the robot is supposed to navigate through a maze-like path and perturbed loop demonstration, where the robot is supposed to make a complete loop as instructed by demonstration images. The loop demonstration is longer and more difficult than the maze. We start the agent from different starting locations and orientations with respect to that of demonstration. Each orientation is initialized such that no part of the demonstration’s initial frame is visible. Results are shown in Table 2. When we sample every frame, our method and classical structure from motion can both be used to follow the demonstration. However, at sub-sampling rate of five, SIFT-based feature matching approaches did not work and ORBSLAM2 (Mur-Artal & Tardos, 2017) failed to generate a map, whereas our ´ method was successful. Notice that providing sparse landmark images instead of dense video adds robustness to the visual imitation task. In particular, consider the scenario in which the environment has changed since the time the demonstration was recorded. By not requiring the agent to match every demonstration image frame-by-frame, it becomes less sensitive to changes in the environment.
+
+# 3.3 3D NAVIGATION IN VIZDOOM
+
+We have evaluated our approach on real-robot scenarios thus far. To further analyze the performance and robustness of our approach through large scale experiments, we setup the same navigation task as described in previous subsection in a simulated VizDoom environment. Our goal is to measure: (1) the robustness of each method with proper error bars, (2) the role of initial self-supervised data collection for performance on visual imitation, (3) the quantitative difference in modeling forward consistency loss in feature space in comparison to raw visual space.
+
+Table 3: Quantitative evaluation of our proposed GSP and the baseline models at following visual demonstrations in VizDoom 3D Navigation. Medians and $9 5 \%$ confidence intervals are reported for demonstration completion and efficiency over 50 seeds and 5 human paths per environment type.   
+
+<table><tr><td>Model Name</td><td>Same Map, Same Texture Median%</td><td>Efficiency %</td><td>Same Map,Diff Texture Median %</td><td>Efficiency %</td><td>Diff Map,Diff Texture Median %</td><td>Efficiency %</td></tr><tr><td colspan="7">Random Exploration for Data Collection:</td></tr><tr><td>GSP-NoFwdConst</td><td>63.2 ± 5.7</td><td>36.4 ± 3.3</td><td>32.2 ± 0.7</td><td>28.9 ± 4.0</td><td>34.5 ± 0.6</td><td>23.1 ± 2.4</td></tr><tr><td>GSP (ours pixels)</td><td>62.2 ± 5.1</td><td>43.0±2.6</td><td>32.4 ± 0.8</td><td>30.9 ± 2.9</td><td>35.4 ± 1.1</td><td>29.3 ± 3.9</td></tr><tr><td>GSP (ours features)</td><td>68.9 ± 6.9</td><td>53.9 ±4.0</td><td>32.4 ± 0.7</td><td>47.4 ± 7.6</td><td>39.1 ± 2.0</td><td>30.4 ± 2.5</td></tr><tr><td colspan="7">Curiosity-driven Exploration for Data Collection:</td></tr><tr><td>GSP-NoFwdConst</td><td>78.2 ± 2.3</td><td>63.0 ± 4.3</td><td>43.2 ± 2.6</td><td>33.9 ± 3.0</td><td>40.2 ±4.0</td><td>27.3 ±1.9</td></tr><tr><td>GSP-FwdRegularizer</td><td>78.4± 3.4</td><td>59.8 ± 4.1</td><td>50.6 ± 4.7</td><td>30.9 ±3.0</td><td>37.9 ± 1.1</td><td>28.9 ±1.7</td></tr><tr><td>GSP (ours pixels)</td><td>78.2 ± 3.4</td><td>65.2 ± 4.2</td><td>47.1 ± 4.7</td><td>32.4±3.0</td><td>44.8 ± 4.0</td><td>29.5 ± 1.9</td></tr><tr><td>GSP (ours features)</td><td>78.2 ±4.6</td><td>67.0± 3.3</td><td>49.4 ± 4.8</td><td>26.9 ± 1.5</td><td>47.1 ± 3.0</td><td>24.1 ±1.7</td></tr></table>
+
+In VizDoom, we collect data by deploying two types of exploration methods: random exploration and curiosity-driven exploration (Pathak et al., 2017). The hypothesis is that if the initial data collected by the robot is driven by a better strategy than just random, this should eventually help the agent follow long demonstrations better. Our environment consists of 2 maps in total. We train on one map with 5 different starting positions for collecting exploration data. For validation, we collect 5 human demonstrations in a map with the same layout as in training but with different textures. For zero-shot generalization, we collect 5 human demonstrations in a novel map layout with novel textures. Exact details for data collection and training setup are in the supplementary, Section A.3.
+
+Metric We report the median of maximum distance reached by the robot in following the given sequence of demonstration images. The maximum distance reached is the distance of farthest landmark point that the agent reaches contiguously, i.e., without missing any intermediate landmarks. Measuring the farthest landmark reached does not capture how efficiently it is reached. Hence, we further measure efficiency of the agent as the ratio of number of steps taken by the agent to reach farthest contiguous landmark with respect to the number of steps shown in human demonstrations.
+
+Visual Imitation The task here is same as the one in real robot navigation where the agent is shown a sparse sequence of images to imitate. The results are in Table 3. We found that the exploration data collected via curiosity significantly improves the final imitation performance across all methods including the baselines with respect to random exploration. Our baseline GSP model with a forward regularizer instead of consistency loss ends up overfitting to the training layout. In contrast, our forward-consistent GSP model outperforms other methods in generalizing to new map with novel textures. This indicates that the forward consistency is possibly doing more than just regularizing the policy features. Training forward consistency loss in feature space further enhances the generalization even when both pixel and feature space models perform similarly on training environment.
+
+# 4 RELATED WORK
+
+Our work is closely related to imitation learning, but we address a different problem statement that gives less supervision and requires generalization across tasks during inference.
+
+Imitation Learning The two main threads of imitation learning are behavioral cloning (Argall et al., 2009; Pomerleau, 1989), which directly supervises the mapping of states to actions, and inverse reinforcement learning (Abbeel & Ng, 2004; Ho & Ermon, 2016; Levine et al., 2016; $\mathrm { N g }$ & Russell, 2000; Ziebart et al., 2008), which recovers a reward function that makes the demonstration optimal (or nearly optimal). Inverse RL is most commonly achieved with state-actions, and is difficult to extend to fitting the reward to observations alone, though in principle state occupancy could be sufficient. Recent work in imitation learning (Duan et al., 2017; Finn et al., 2017; Gupta et al., 2017) can generalize to novel goals, but require a wealth of demonstrations comprised of expert state-actions for learning. Our approach does not require expert actions at all.
+
+Visual Demonstration The common scenario in LfD is to assume full knowledge of expert states and actions during demonstrations, but several papers have focused on relaxing this supervision to visual observations alone. Nair et al. (2017) observe a sequence of images from the expert demonstration for performing rope manipulations. Sermanet et al. (2017; 2018) imitate humans with robots by self-supervised learning but require expert supervision at training time. Third person imitation learning (Stadie et al., 2017) and the concurrent work of imitation-from-observation (Liu et al., 2018) learn to translate expert observations into agent observations such that they can do policy optimization to minimize the distance between the agent trajectory and the translated demonstration, but they require demonstrations for learning. Visual servoing is a standard problem in robotics (Koichi & Tom, 1993) that seeks to take actions that align the agent’s observation with a target configuration of carefully-designed visual features (Wilson et al., 1996; Yoshimi & Allen, 1994) or raw pixel intensities (Caron et al., 2013). Classical methods rely on fixed features or policies, but more recently end-to-end learning has improved results (Lampe & Riedmiller, 2013; Lee et al., 2017).
+
+Forward/Inverse Dynamics and Consistency Numerous prior works, such as Ebert et al. (2017); Oh et al. (2015); Watter et al. (2015), have learned forward dynamics model for planning actions. The works of Agrawal et al. (2016); Jordan & Rumelhart (1992); Pathak et al. (2017); Wolpert et al. (1995) jointly learn forward and inverse dynamics model but do not optimize for consistency between the forward and inverse dynamics. We empirically show that learning models by our forward consistency loss significantly improves task performance. Enforcing consistency as a meta-supervision has also been successful in finding visual correspondences (Zhou et al., 2016) or unpaired image translations (Zhu et al., 2017).
+
+Goal Conditioning By parameterizing the value or policy function with a goal, an agent can learn and do multiple tasks. The idea of learning goal-conditioned policies has been explored in (Agrawal et al., 2016; Andrychowicz et al., 2017; Nair et al., 2017; Schaul et al., 2015). Similarly to hindsight experience replay (Andrychowicz et al., 2017) we draw goals from experience, but our policy optimization has better sample efficiency through supervised learning and dynamics modeling instead of reinforcement learning. Moreover, we work from high-dimensional visual inputs instead of knowledge of the true states and do not make use of a task reward during training. In our setting, all of the expert goals are followed zero-shot since they are only revealed after learning.
+
+# 5 DISCUSSION
+
+In this work, we presented a method for imitating expert demonstrations from visual observations alone. In contrast to most work in imitation learning, we never require access to expert actions. The key idea is to learn a GSP using data collected by self-supervised exploration. However, this limits the quality of the learned GSP as per the exploration data. For instance, we deploy random exploration on our real-world navigation robot, which means that it would almost never follow trajectories that go between rooms. Consequently, the learned GSP is unable to navigate towards a goal image taken in another room without requiring intermediate sub-goals. Pathak et al. (2017) show that the agent learns to move along corridors and transition between rooms purely driven by curiosity in VizDoom. Training GSP on such a structured data could equip the agent with more interesting search behaviors, e.g., going across rooms to find a goal. In general, using better methods of exploration for training the GSP could be a fruitful direction toward generalizing zeroshot imitation.
+
+One limitation of our approach is that we require first-person view demonstrations. Extension to third-person demonstrations (Liu et al., 2018; Stadie et al., 2017) would make the method applicable in more general scenarios. Another limitation is that, in the current framework, it is implicitly assumed that the statistics of visual observations when the expert demonstrates the task and the agent follows it are similar. For e.g., when the expert performs a demonstration in one setting, say in daylight and the agent needs to imitate say in the evening, the change in the lighting conditions might result in worse performance. Making the GSP robust to such nuisance changes or other changes in environment by domain adaptation would be necessary to scale the method to practical problems. Another thing to note is that, in the current framework, we do not learn from expert demonstrations, but simply imitate them. It would be interesting to investigate ways for an agent to learn from the expert to bias its exploration to more useful parts of the environment.
+
+While we used a sequence of images to provide a demonstration, our work makes no image-specific assumptions and can be extended to using formal language for communicating goals. For instance, after training the GSP, instead of transforming an image into features $\phi$ as described in section 2.2, one could possibly learn a mapping to transform language instructions into this feature space.
+
+# ACKNOWLEDGMENTS
+
+We would like to thank members of BAIR for fruitful discussions and comments. This work was supported in part by DARPA; NSF IIS-1212798, IIS-1427425, IIS-1536003, Berkeley DeepDrive, and an equipment grant from NVIDIA and the Valrhona Reinforcement Learning Fellowship. DP is supported by NVIDIA and Snapchat’s graduate fellowships.
+
+REFERENCES   
+Pieter Abbeel and Andrew Y. Ng. Apprenticeship learning via inverse reinforcement learning. In ICML, 2004. 10   
+Pulkit Agrawal, Ashvin Nair, Pieter Abbeel, Jitendra Malik, and Sergey Levine. Learning to poke by poking: Experiential learning of intuitive physics. NIPS, 2016. 2, 4, 11   
+Marcin Andrychowicz, Filip Wolski, Alex Ray, Jonas Schneider, Rachel Fong, Peter Welinder, Bob McGrew, Josh Tobin, Pieter Abbeel, and Wojciech Zaremba. Hindsight experience replay. In NIPS, 2017. 2, 11   
+Brenna D Argall, Sonia Chernova, Manuela Veloso, and Brett Browning. A survey of robot learning from demonstration. Robotics and autonomous systems, 2009. 1, 10   
+Albert Bandura and Richard H Walters. Social learning theory, volume 1. Prentice-hall Englewood Cliffs, NJ, 1977. 1   
+Cynthia Breazeal and Brian Scassellati. Robots that imitate humans. Trends in cognitive sciences, 2002. 1   
+Guillaume Caron, Eric Marchand, and El Mustapha Mouaddib. Photometric visual servoing for omnidirectional cameras. Autonomous Robots, 35(2-3):177–193, 2013. 11   
+Haili Chui and Anand Rangarajan. A new point matching algorithm for non-rigid registration. CVIU, 2003. 7   
+Andrew J Davison and David W Murray. Mobile robot localisation using active vision. In ECCV, 1998. 6   
+Rudiger Dillmann. Teaching and learning of robot tasks via observation of human performance. ¨ Robotics and Autonomous Systems, 2004. 1   
+Yan Duan, Marcin Andrychowicz, Bradly Stadie, OpenAI Jonathan Ho, Jonas Schneider, Ilya Sutskever, Pieter Abbeel, and Wojciech Zaremba. One-shot imitation learning. In NIPS, 2017. 2, 10   
+Frederik Ebert, Chelsea Finn, Alex X Lee, and Sergey Levine. Self-supervised visual planning with temporal skip connections. arXiv preprint arXiv:1710.05268, 2017. 11   
+Chelsea Finn, Tianhe Yu, Tianhao Zhang, Pieter Abbeel, and Sergey Levine. One-shot visual imitation learning via meta-learning. CoRL, 2017. 2, 10   
+David Foster and Peter Dayan. Structure in the space of value functions. Machine Learning, 2002. 3   
+Saurabh Gupta, James Davidson, Sergey Levine, Rahul Sukthankar, and Jitendra Malik. Cognitive mapping and planning for visual navigation. CVPR, 2017. 10   
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, 2016. 15   
+Jonathan Ho and Stefano Ermon. Generative adversarial imitation learning. In NIPS, 2016. 10   
+Katsushi Ikeuchi and Takashi Suehiro. Toward an assembly plan from observation. i. task recognition with polyhedral objects. IEEE Transactions on Robotics and Automation, 1994. 1
+
+Michael I Jordan and David E Rumelhart. Forward models: Supervised learning with a distal teacher. Cognitive science, 1992. 3, 11
+
+Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. ICLR, 2015. 15
+
+Diederik $\mathrm { \bf P }$ Kingma and Max Welling. Auto-encoding variational bayes. arXiv preprint arXiv:1312.6114, 2013. 4
+
+Hashimoto Koichi and Husband Tom. Visual servoing: real-time control of robot manipulators based on visual sensory feedback, volume 7. World scientific, 1993. 11
+
+Yasuo Kuniyoshi, Masayuki Inaba, and Hirockika Inoue. Teaching by showing: Generating robot programs by visual observation of human performance. In International Symposium on Industrial Robots, 1989. 1
+
+Yasuo Kuniyoshi, Masayuki Inaba, and Hirochika Inoue. Learning by watching: Extracting reusable task knowledge from visual observation of human performance. IEEE Transactions on Robotics and Automation, 1994. 1
+
+Thomas Lampe and Martin Riedmiller. Acquiring visual servoing reaching and grasping skills using neural reinforcement learning. In Neural Networks (IJCNN), The 2013 International Joint Conference on, pp. 1–8. IEEE, 2013. 11
+
+Alex X Lee, Sergey Levine, and Pieter Abbeel. Learning visual servoing with deep features and fitted q-iteration. arXiv preprint arXiv:1703.11000, 2017. 11
+
+Sergey Levine, Peter Pastor, Alex Krizhevsky, and Deirdre Quillen. Learning hand-eye coordination for robotic grasping with large-scale data collection. In ISER, 2016. 2, 10
+
+YuXuan Liu, Abhishek Gupta, Pieter Abbeel, and Sergey Levine. Imitation from observation: Learning to imitate behaviors from raw video via context translation. ICRA, 2018. 11
+
+Mapillary. Open source structure from motion pipeline. https://github.com/mapillary/ OpenSfM, 2016. 6
+
+Raul Mur-Artal and Juan D Tardos. Orb-slam2: An open-source slam system for monocular, stereo, ´ and rgb-d cameras. IEEE Transactions on Robotics, 2017. 6, 9
+
+Ashvin Nair, Dian Chen, Pulkit Agrawal, Phillip Isola, Pieter Abbeel, Jitendra Malik, and Sergey Levine. Combining self-supervised learning and imitation for vision-based rope manipulation. ICRA, 2017. 2, 6, 7, 11, 15
+
+Andrew $\mathrm { ~ Y ~ N ~ g ~ }$ and Stuart J Russell. Algorithms for inverse reinforcement learning. In ICML, pp. 663–670, 2000. 1, 10
+
+Junhyuk Oh, Xiaoxiao Guo, Honglak Lee, Richard L Lewis, and Satinder Singh. Action-conditional video prediction using deep networks in atari games. In NIPS, 2015. 11
+
+Pierre-Yves Oudeyer, Frdric Kaplan, and Verena V Hafner. Intrinsic motivation systems for autonomous mental development. Evolutionary Computation, 2007. 3
+
+Deepak Pathak, Pulkit Agrawal, Alexei A. Efros, and Trevor Darrell. Curiosity-driven exploration by self-supervised prediction. In ICML, 2017. 3, 4, 10, 11, 16
+
+Lerrel Pinto and Abhinav Gupta. Supersizing self-supervision: Learning to grasp from 50k tries and 700 robot hours. ICRA, 2016. 2
+
+Dean A Pomerleau. ALVINN: An autonomous land vehicle in a neural network. In NIPS, 1989. 1, 10
+
+Danilo Jimenez Rezende, Shakir Mohamed, and Daan Wierstra. Stochastic backpropagation and approximate inference in deep generative models. arXiv preprint arXiv:1401.4082, 2014. 4
+
+Stefan Schaal. Is imitation learning the route to humanoid robots? Trends in cognitive sciences, 1999. 1
+
+Tom Schaul, Daniel Horgan, Karol Gregor, and David Silver. Universal value function approximators. In ICML, 2015. 3, 11
+
+Jurgen Schmidhuber. A possibility for implementing curiosity and boredom in model-building neural controllers. In From animals to animats: Proceedings of the first international conference on simulation of adaptive behavior, 1991. 3
+
+Pierre Sermanet, Kelvin Xu, and Sergey Levine. Unsupervised perceptual rewards for imitation learning. In RSS, 2017. 11
+
+Pierre Sermanet, Corey Lynch, Yevgen Chebotar, Jasmine Hsu, Eric Jang, Stefan Schaal, and Sergey Levine. Time-contrastive networks: Self-supervised learning from video. In ICRA, 2018. 5, 11
+
+Bradly C. Stadie, Pieter Abbeel, and Ilya Sutskever. Third-person imitation learning. In ICLR, 2017. 11
+
+Manuel Watter, Jost Springenberg, Joschka Boedecker, and Martin Riedmiller. Embed to control: A locally linear latent dynamics model for control from raw images. In NIPS, 2015. 11
+
+William J Wilson, CC Williams Hulls, and Graham S Bell. Relative end-effector control using cartesian position based visual servoing. IEEE Transactions on Robotics and Automation, 12(5): 684–696, 1996. 11
+
+Daniel M Wolpert, Zoubin Ghahramani, and Michael I Jordan. An internal model for sensorimotor integration. Science-AAAS-Weekly Paper Edition, 1995. 11
+
+Yezhou Yang, Yi Li, Cornelia Fermuller, and Yiannis Aloimonos. Robot learning manipulation ¨ action plans by ”watching” unconstrained videos from the world wide web. In AAAI, 2015. 1
+
+Billibon H Yoshimi and Peter K Allen. Active, uncalibrated visual servoing. In Robotics and Automation, 1994. Proceedings., 1994 IEEE International Conference on, pp. 156–161. IEEE, 1994. 11
+
+Tinghui Zhou, Philipp Krahenbuhl, Mathieu Aubry, Qixing Huang, and Alexei A. Efros. Learning dense correspondence via 3d-guided cycle consistency. In CVPR, 2016. 11
+
+Jun-Yan Zhu, Taesung Park, Phillip Isola, and Alexei A. Efros. Unpaired image-to-image translation using cycle-consistent adversarial networks. ICCV, 2017. 11
+
+Brian D. Ziebart, Andrew Maas, J Andrew Bagnell, and Anind K Dey. Maximum entropy inverse reinforcement learning. In AAAI, 2008. 10
+
+# A SUPPLEMENTARY MATERIAL
+
+We evaluated our proposed approach across number of environments and tasks. In this section, we provide additional details about the experimental task setup and hyperparameters.
+
+# A.1 ROPE MANIPUATION
+
+Robotic Setup Our setup of Baxter robot for rope manipulation task follows the one described in Nair et al. (2017). We re-use the data that is collected by a Baxter robot interacting with a rope kept on a table in front of it in a self-supervised manner, and consists of approximately 60K interaction pairs.
+
+Implementation Details The base architecture for all the methods consists of a pre-trained AlexNet, whose features are fed into a skill policy network that predicts the location of grasp, direction of displacement, and the magnitude of displacement. For the forward regularizer baseline, a forward model is trained to jointly regularize the AlexNet features along with the skill policy network with loss weight of forward model set to 0.1. For our proposed forward-consistent GSP, a forward consistency loss is then applied to the actions predicted by the skill policy network. The forward consistency loss weight is set to 0.1. Since this is a fully observed setup, we did not use recurrence in any of the skill policy networks. All the models are optimized using Adam (Kingma & Ba, 2015) with a learning rate of $1 e - 4$ . For the first 40K iterations, the AlexNet weights were frozen, and then fine-tuned jointly with the later layers.
+
+# A.2 NAVIGATION IN INDOOR OFFICE ENVIRONMENTS
+
+Robotic Setup We used the TurtleBot2 robot comprising of a wheeled Kobuki base and an Orbbec Astra camera for capturing RGB images for all our experiments. The robot’s action space had four discrete actions: move forward, turn left, turn right, and stand still (i.e., no-op). The forward action is approximately $1 0 \mathrm { c m }$ forward translation and the turning actions are approximately 14-18 degrees of rotation. These numbers vary due to the use of velocity control. A powerful on-board laptop was used to process the images and infer the motor commands. Several modifications were made to the default TurtleBot setup: the base’s batteries were replaced with longer lasting ones, and the default NVIDIA Jetson TK1 embedded board was replaced with a more powerful GigaByte Aero laptop and an accompanying portable charging power bank.
+
+Self-supervised Data Collection We devised an automated self-supervised scheme for data collection which does not require any human supervision. In our scheme, the robot first samples one out of four actions and then the number of times to repeat the selected action (i.e. action repeat). The no-op action is sampled with probability 0.05 and the other three actions are sampled with equal probability. In case the no-op action is chosen, an action repeat of $\{ 1 , 2 \}$ steps is uniformly sampled. In case of other actions, an action repeat of 1-5 steps is randomly and uniformly chosen. The robot autonomously repeated this process and collected 230K interactions from two floors of an academic building. If the robot crashes into an object, it performs a reset maneuver by first moving backwards and then turning right/left by a uniformly sampled angle between 90-270 degrees. A separate floor of the building with substantially different furniture layout and visual textures is then used for testing the learned model.
+
+Implementation Details The data collected by self-supervised exploration is then used to train our recurrent forward-consistent GSP. The base architecture of our model is an ImageNet pre-trained ResNet-50 (He et al., 2016) network. Input are the images and output are the actions of robot. The forward consistency model is first pre-trained and then fine-tuned together end-to-end with the GSP. The loss weight of the forward model is 0.1, and the objective is minimized using Adam (Kingma & Ba, 2015) with learning rate of $5 e - 4$ .
+
+# A.3 3D NAVIGATION IN VIZDOOM
+
+Self-supervised Data Collection Our environment consists of two map. One map is used for training and validation, with different textures for validation. Second map has different textures than training and validation and is used for generalization experiments. For both curiosity and random exploration, we collect a total of 1.5 million frames each with action repeat of 4 collected in the standard DoomMyWayHome map used for training in Pathak et al. (2017). $\sim \textstyle { \frac { 2 } { 3 } }$ of the data comes from random-room resets, and $\sim \frac { 1 } { 3 }$ of the data comes from a fixed-room reset (i.e, room number 10). The curiosity policy was half sampled and half greedy with the exact split being $40 \%$ greedy policy random-room reset, $2 5 \%$ sample policy random-room reset, $2 5 \%$ sample policy fixed-room reset, and $10 \%$ greedy policy fixed-room reset.
+
+Table 4: Quantitative evaluation of TurtleBot’s performance at following visual demonstrations in two conditions: maze and the loop. The fraction denotes how many landmarks it reaches out of the total number of landmarks in the full demonstration. The bracketed number represents the number of actions the agent took to reach its farthest landmark.   
+
+<table><tr><td rowspan="2">Model Name</td><td colspan="3">Maze Runs - Optimal Steps: 100</td><td colspan="3">Loop Runs - Optimal Steps: 85</td></tr><tr><td>Run-1</td><td>Run-2</td><td>Run-3</td><td>Run-1</td><td>Run-2</td><td>Run-3</td></tr><tr><td>SIFT</td><td>2/20 (10)</td><td>1/20 (9)</td><td>3/20 (38)</td><td>一</td><td>1</td><td>1</td></tr><tr><td>GSP-NoPrevAction-NoFwdConst</td><td>12/20 (109)</td><td>14/20 (184)</td><td>20/20 (263)</td><td></td><td></td><td></td></tr><tr><td>GSP-NoFwdConst</td><td>13/20 (147)</td><td>18/20 (325)</td><td>20/20 (166)</td><td>0/17 (0)</td><td>0/17 (0)</td><td>0/17 (0)</td></tr><tr><td>GSP (ours)</td><td>20/20 (353)</td><td>12/20 (194)</td><td>20/20 (168)</td><td>0/17 (0)</td><td>17/17 (243)</td><td>17/17 (165)</td></tr></table>
+
+Table 5: Quantitative evaluation of our proposed GSP and the baseline models at following visual demonstrations in VizDoom 3D Navigation. Means and standard errors are reported for demonstration completion and efficiency over 50 seeds and 5 human paths per environment type.   
+
+<table><tr><td>Model Name</td><td>Same Map,Same Texture Mean %</td><td>Efficiency %</td><td>Same Map,Diff Texture Mean %</td><td>Efficiency %</td><td>Diff Map,Diff Texture Mean %</td><td>Efficiency %</td></tr><tr><td colspan="7">Random Exploration for Data Collection:</td></tr><tr><td>GSP-NoFwdConst</td><td>61.8 ± 0.9</td><td>60.4 ± 2.1</td><td>37.6 ± 0.7</td><td>68.6 ± 2.5</td><td>42.2 ± 0.8</td><td>50.6 ± 1.9</td></tr><tr><td>GSP (ours pixels)</td><td>61.0 ± 1.0</td><td>68.0± 2.2</td><td>38.1 ± 0.7</td><td>69.1 ± 2.5</td><td>40.3 ± 0.9</td><td>64.2 ± 2.3</td></tr><tr><td>GSP (ours features)</td><td>62.0 ± 1.0</td><td>75.8 ± 2.5</td><td>37.0 ± 0.7</td><td>87.1 ± 2.8</td><td>48.7 ± 0.9</td><td>52.5 ± 1.8</td></tr><tr><td colspan="7">Curiosity-driven Exploration for Data Collection:</td></tr><tr><td>GSP-NoFwdConst</td><td>70.7 ± 0.9</td><td>66.9 ± 1.4</td><td>49.8 ± 0.8</td><td>55.8 ± 2.2</td><td>51.2 ±1.0</td><td>39.5 ± 1.3</td></tr><tr><td>GSP-FwdRegularizer</td><td>70.6 ± 0.9</td><td>67.9 ± 1.6</td><td>51.9 ± 0.8</td><td>49.3 ± 1.6</td><td>48.3 ± 1.0</td><td>49.3 ± 1.8</td></tr><tr><td>GSP (ours pixels)</td><td>71.0 ± 0.9</td><td>73.1 ± 2.7</td><td>53.3 ± 0.9</td><td>53.4 ± 2.0</td><td>52.2 ± 1.0</td><td>44.0 ± 1.5</td></tr><tr><td>GSP (ours features)</td><td>68.8 ±1.0</td><td>72.0 ± 1.7</td><td>53.2 ±0.8</td><td>53.0 ± 2.3</td><td>52.8 ± 0.9</td><td>37.7 ± 1.3</td></tr></table>
+
+For each scenario, we collect 5 human demonstrations each and give every 10th frame as input to the agent for the task of visual imitation. For each human path, we evaluate on 50 different seeds where the agent starts with a uniformly sampled orientation. We then get the median across 250 (50x5) total runs for each type of environment and report median of the percentage of the human path reached by the agent and how soon it got to that point relative to the human.
+
+In the main paper, we report median accuracy and the confidence interval for median 2. Since the initial position of the agent is randomized in orientation compared to the one in visual demonstration, the mean results suffer from high variance due to outliers. Hence, median accuracy results in a more reliable metric. However, we report mean results in Table 5 for the completion.
+
+Implementation Details All models were trained with batch size 64, Adam Solver with 1e-4 learning rate, and landmark slices uniformly sampled between 5 to 15 action steps for each batch. The observations are $4 2 \mathbf { x } 4 2$ resolution, grayscale images with only one-time channel both for goal and current state. All models used the same goal recognizer that was trained on the curiosity data. For selecting the hyper-parameters in forward regularizer, pixel-based forward consistency, and featurebased forward consistency models, we selected the best loss coefficient among $\{ 0 . 0 1 , 0 . 0 5 , 0 . 1 \}$ that achieved the highest median completion on our validation environment which consisted of the training maps with novel textures.

parse/train/BkisuzWRW/BkisuzWRW_content_list.json

@@ -0,0 +1,1624 @@
+[
+    {
+        "type": "text",
+        "text": "ZERO-SHOT VISUAL IMITATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            557,
+            121
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deepak Pathak∗, Parsa Mahmoudieh∗, Guanghao Luo∗, Pulkit Agrawal∗, Dian Chen, Yide Shentu, Evan Shelhamer, Jitendra Malik, Alexei A. Efros, Trevor Darrell ",
+        "bbox": [
+            184,
+            143,
+            795,
+            178
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "UC Berkeley ",
+        "bbox": [
+            184,
+            190,
+            269,
+            204
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "{pathak,parsa.m,michaelluo,pulkitag,dianchen, fredshentu,shelhamer,malik,efros,trevor}@cs.berkeley.edu ",
+        "bbox": [
+            186,
+            208,
+            568,
+            231
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            268,
+            544,
+            284
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The current dominant paradigm for imitation learning relies on strong supervision of expert actions to learn both what and how to imitate. We pursue an alternative paradigm wherein an agent first explores the world without any expert supervision and then distills its experience into a goal-conditioned skill policy with a novel forward consistency loss. In our framework, the role of the expert is only to communicate the goals (i.e., what to imitate) during inference. The learned policy is then employed to mimic the expert (i.e., how to imitate) after seeing just a sequence of images demonstrating the desired task. Our method is “zero-shot” in the sense that the agent never has access to expert actions during training or for the task demonstration at inference. We evaluate our zero-shot imitator in two real-world settings: complex rope manipulation with a Baxter robot and navigation in previously unseen office environments with a TurtleBot. Through further experiments in VizDoom simulation, we provide evidence that better mechanisms for exploration lead to learning a more capable policy which in turn improves end task performance. Videos, models, and more details are available at https://pathak22.github.io/zeroshot-imitation/. ",
+        "bbox": [
+            233,
+            303,
+            764,
+            523
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            556,
+            336,
+            571
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Imitating expert demonstration is a powerful mechanism for learning to perform tasks from raw sensory observations. The current dominant paradigm in learning from demonstration (LfD) (Argall et al., 2009; $\\mathrm { N g }$ & Russell, 2000; Pomerleau, 1989; Schaal, 1999) requires the expert to either manually move the robot joints (i.e., kinesthetic teaching) or teleoperate the robot to execute the desired task. The expert typically provides multiple demonstrations of a task at training time, and this generates data in the form of observation-action pairs from the agent’s point of view. The agent then distills this data into a policy for performing the task of interest. Such a heavily supervised approach, where it is necessary to provide demonstrations by controlling the robot, is incredibly tedious for the human expert. Moreover, for every new task that the robot needs to execute, the expert is required to provide a new set of demonstrations. ",
+        "bbox": [
+            174,
+            589,
+            825,
+            728
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Instead of communicating how to perform a task via observation-action pairs, a more general formulation allows the expert to communicate only what needs to be done by providing the observations of the desired world states via a video or a sparse sequence of images. This way, the agent is required to infer how to perform the task (i.e., actions) by itself. In psychology, this is known as observational learning (Bandura & Walters, 1977). While this is a harder learning problem, it is a more interesting setting, because the expert can demonstrate multiple tasks quickly and easily. ",
+        "bbox": [
+            174,
+            736,
+            823,
+            819
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "An agent without any prior knowledge will find it extremely hard to imitate a task by simply watching a visual demonstration in all but the simplest of cases. Thus, the natural question is: in order to imitate, what form of prior knowledge must the agent possess? A large body of work (Breazeal & Scassellati, 2002; Dillmann, 2004; Ikeuchi & Suehiro, 1994; Kuniyoshi et al., 1989; 1994; Yang et al., 2015) has sought to capture prior knowledge by manually pre-defining the state that must be inferred from the observations. The agent then infers how to perform the task (i.e., plan for imitation) using this state. Unfortunately, computer vision systems are often unable to estimate the state variables accurately and it has proven non-trivial for downstream planning systems to be robust to such errors. ",
+        "bbox": [
+            174,
+            825,
+            823,
+            896
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/434a373c7a71373e1b8cff5cbcc2f991d2bed131753c2fa08b2da192ece06e28.jpg",
+        "image_caption": [
+            "Figure 1: The goal-conditioned skill policy (GSP) takes as input the current and goal observations and outputs an action sequence that would lead to that goal. We compare the performance of the following GSP models: (a) Simple inverse model; (b) Mutli-step GSP with previous action history; (c) Mutli-step GSP with previous action history and a forward model as regularizer, but no forward consistency; (d) Mutli-step GSP with forward consistency loss proposed in this work. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            209,
+            71,
+            790,
+            300
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            429,
+            825,
+            486
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we follow (Agrawal et al., 2016; Levine et al., 2016; Pinto & Gupta, 2016) in pursuing an alternative paradigm, where an agent explores the environment without any expert supervision and distills this exploration data into goal-directed skills. These skills can then be used to imitate the visual demonstration provided by the expert (Nair et al., 2017). Here, by skill we mean a function that predicts the sequence of actions to take the agent from the current observation to the goal. We call this function a goal-conditioned skill policy (GSP). The GSP is learned in a self-supervised way by re-labeling the states visited during the agent’s exploration of the environment as goals and the actions executed by the agent as the prediction targets, similar to (Agrawal et al., 2016; Andrychowicz et al., 2017). During inference, given goal observations from a demonstration, the GSP can infer how to reach these goals in turn from the current observation, and thereby imitate the task step-by-step. ",
+        "bbox": [
+            174,
+            492,
+            825,
+            646
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "One critical challenge in learning the GSP is that, in general, there are multiple possible ways of going from one state to another: that is, the distribution of trajectories between states is multimodal. We address this issue with our novel forward consistency loss based on the intuition that, for most tasks, reaching the goal is more important than how it is reached. To operationalize this, we first learn a forward model that predicts the next observation given an action and a current observation. We use the difference in the output of the forward model for the GSP-selected action and the ground truth next state to train the GSP. This loss has the effect of making the GSP-predicted action consistent with the ground-truth action instead of exactly matching the actions themselves, thus ensuring that actions that are different from the ground-truth—but lead to the same next state— are not inadvertently penalized. To account for varying number of steps required to reach different goals, we propose to jointly optimize the GSP with a goal recognizer that determines if the current goal has been satisfied. See Figure 1 for a schematic illustration of the GSP architecture. ",
+        "bbox": [
+            173,
+            652,
+            825,
+            819
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We call our method zero-shot because the agent never has access to expert actions, neither during training of the GSP nor for task demonstration at inference. In contrast, most recent work on oneshot imitation learning requires full knowledge of actions and a wealth of expert demonstrations during training (Duan et al., 2017; Finn et al., 2017). In summary, we propose a method that (1) does not require any extrinsic reward or expert supervision during learning, (2) only needs demonstrations during inference, and (3) restricts demonstrations to visual observations alone rather than full stateactions. Instead of learning by imitation, our agent learns to imitate. ",
+        "bbox": [
+            174,
+            827,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We evaluate our zero-shot imitator on real-world robots for rope manipulation tasks using a Baxter and office navigation using a TurtleBot. We show that the proposed forward consistency loss improves the performance on the complex task of knot tying from $3 \\hat { 6 } \\%$ to $6 0 \\%$ accuracy. In navigation experiments, we steer a simple wheeled robot around partially-observable office environments and show that the learned GSP generalizes to unseen environments. Furthermore, using navigation experiments in VizDoom environment, we show that (GSP) learned using curiosity-driven exploration (Oudeyer et al., 2007; Pathak et al., 2017; Schmidhuber, 1991) can more accurately follow demonstrations as compared to using random exploration data for learning the GSP. Overall our experiments show that the forward-consistent GSP can be used to imitate a variety of tasks without making environment or task-specific assumptions. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            242
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 LEARNING TO IMITATE WITHOUT EXPERT SUPERVISION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            263,
+            671,
+            281
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Let $\\boldsymbol { S } : \\{ x _ { 1 } , a _ { 1 } , x _ { 2 } , a _ { 2 } , . . . , x _ { T } \\}$ be the sequence of observations and actions generated by the agent as it explores its environment using the policy $a = \\pi _ { E } ( s )$ . This exploration data is used to learn the goal-conditioned skill policy (GSP) $\\pi$ takes as input a pair of observations $( x _ { i } , x _ { g } )$ and outputs sequence of actions $( \\vec { a } _ { \\tau } : a _ { 1 } , a _ { 2 } . . . a _ { K } )$ required to reach the goal observation $( x _ { g } )$ from the current observation $( x _ { i } )$ . ",
+        "bbox": [
+            174,
+            296,
+            825,
+            366
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b6032d7d1c7505b241c06336a57e65ecdc8290c76a33d7eedd27f43da0cac7f0.jpg",
+        "text": "$$\n\\vec { a } _ { \\tau } = \\pi ( x _ { i } , x _ { g } ; \\theta _ { \\pi } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            436,
+            375,
+            562,
+            392
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where states $x _ { i } , x _ { g }$ are sampled from the $s$ . The number of actions, $K$ , is also inferred by the model. We represent $\\pi$ by a deep network with parameters $\\theta _ { \\pi }$ in order to capture complex mappings from visual observations $( x )$ to actions. $\\pi$ can be thought of as a variable-step generalization of the inverse dynamics model (Jordan & Rumelhart, 1992), or as the policy corresponding to a universal value function (Foster & Dayan, 2002; Schaul et al., 2015), with the difference that $x _ { g }$ need not be the end goal of a task but can also be an intermediate sub-goal. ",
+        "bbox": [
+            174,
+            398,
+            825,
+            484
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Let the task to be imitated be provided as a sequence of images $\\mathcal { D } : \\{ x _ { 1 } ^ { d } , x _ { 2 } ^ { d } , . . . , x _ { N } ^ { d } \\}$ captured when the expert demonstrates the task. This sequence of images $\\mathcal { D }$ could either be temporally dense or sparse. Our agent uses the learned $\\mathrm { G S P } \\pi$ to imitate the sequence of visual observations $\\mathcal { D }$ starting from its initial state $x _ { 0 }$ by following actions predicted by $\\bar { \\pi } ( x _ { 0 } , x _ { 1 } ^ { d } ; \\theta _ { \\pi } )$ . Let the observation after executing the predicted action be $x _ { 0 } ^ { \\bar { \\prime } }$ . Since multiple actions might be required to reach close to $x _ { 1 } ^ { d }$ , the agent queries a separate goal recognizer network to ascertain if the current observation is close to the goal or not. If the answer is negative, the agent executes the action $a = \\pi ( x _ { 0 } ^ { \\prime } , x _ { 1 } ^ { d } ; \\theta _ { \\pi } )$ . This process is repeated iteratively until the goal recognizer outputs that agent is near the goal, or a maximum number of steps are reached. Let the observation of the agent at this point be ${ \\hat { x } } _ { 1 }$ . After reaching close to the first observation $( x _ { 1 } ^ { d } )$ in the demonstration, the agent sets its goal as $( x _ { 2 } ^ { d } )$ and repeats the process. The agent stops when all observations in the demonstrations are processed. ",
+        "bbox": [
+            174,
+            489,
+            825,
+            643
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Note that in the method of imitation described above, the expert is never required to convey to the agent what actions it performed. In the following subsections we describe how we learn the GSP, forward consistency loss, goal recognizer network and various baseline methods. ",
+        "bbox": [
+            173,
+            650,
+            825,
+            693
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.1 LEARNING THE GOAL-CONDITIONED SKILL POLICY (GSP)",
+        "text_level": 1,
+        "bbox": [
+            174,
+            709,
+            625,
+            724
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We first describe the one-step version of GSP and then extend it to variable length multi-step skills. One-step trajectories take the form of $( x _ { t } , a _ { t } , x _ { t + 1 } )$ and GSP, $\\hat { a _ { t } } = \\pi ( x _ { t } , x _ { t + 1 } ; \\theta _ { \\pi } )$ , is trained by minimizing the standard cross-entropy loss $\\mathcal { L } ( a _ { t } , \\hat { a } _ { t } )$ , ",
+        "bbox": [
+            174,
+            737,
+            825,
+            780
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8bbc8898b74e8d972d59486c8c99f1df5878e09b5c0998228e9cd5b8bc23b5a0.jpg",
+        "text": "$$\n\\mathcal { L } ( a _ { t } , \\hat { a } _ { t } ) = p ( a _ { t } | x _ { t } , x _ { t + 1 } ) \\log ( \\hat { a _ { t } } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            383,
+            787,
+            614,
+            804
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "with respect to parameters $\\theta _ { \\pi }$ , where $p$ and $\\hat { a _ { t } }$ are the ground-truth and predicted action distributions. While we do not have access to true $p$ , we empirically approximate it using samples from the distribution, $a _ { t }$ , that are executed by the agent during exploration. For minimizing the crossentropy loss, it is common to assume $p$ as a delta function at $a _ { t }$ . However, this assumption is notably violated if $p$ is inherently multi-modal and high-dimensional. If we optimize say a deep neural network assuming $p$ to be a delta function, the same inputs will be presented with different targets (due to multi-modality) leading to high-variance in gradients which in turn would make learning challenging. ",
+        "bbox": [
+            174,
+            811,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In our setup, such multi-modality can occur because multiple actions can lead the agent to the same future observation from the initial observation. For instance, in navigation, if the agent is stuck against a corner, turning or moving forward all collapse to the same effect. The issue of multimodality becomes more critical as the length of trajectories grow, because more and more paths may take the agent from the initial observation to the goal observation given more time. Furthermore, it would require many samples to even obtain a good empirical estimate of a high-dimensional multimodal action distribution $p$ . ",
+        "bbox": [
+            174,
+            103,
+            825,
+            202
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.2 FORWARD CONSISTENCY LOSS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            217,
+            429,
+            231
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "One way to account for multi-modality is by employing the likes of variational autoencoders (Kingma & Welling, 2013; Rezende et al., 2014). However, in many practical situations it is not feasible to obtain ample data for each mode. In this work, we propose an alternative based on the insight that in many scenarios, we only care about whether the agent reached the final state or not and the exact trajectory is of lesser interest. Instead of penalizing the actions predicted by the GSP to match the ground truth, we propose to learn the parameters of GSP by minimizing the distance between observation $\\hat { x } _ { t + 1 }$ resulting by executing the predicted action $\\hat { a } _ { t } = \\pi ( x _ { t } , x _ { t + 1 } ; \\theta _ { \\pi } )$ and the observation $x _ { t + 1 }$ , which is the result of executing the ground truth action $a _ { t }$ being used to train the GSP. In this formulation, even if the predicted and ground-truth action are different, the predicted action will not be penalized if it leads to the same next state as the ground-truth action. While this formulation will not explicitly maintain all modes of the action distribution, it will reduce the variance in gradients and thus help learning. We call this penalty the forward consistency loss. ",
+        "bbox": [
+            173,
+            243,
+            825,
+            410
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Note that it is not immediately obvious as to how to operationalize forward consistency loss for two reasons: (a) we need the access to a good forward dynamics model that can reliably predict the effect of an action (i.e., the next observation state) given the current observation state, and (b) such a dynamics model should be differentiable in order to train the GSP using the state prediction error. Both of these issues could be resolved if an analytic formulation of forward dynamics is known. ",
+        "bbox": [
+            174,
+            416,
+            825,
+            486
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In many scenarios of interest, especially if states are represented as images, an analytic forward model is not available. In this work, we learn the forward dynamics $f$ model from the data, and is defined as $\\tilde { x } _ { t + 1 } = f ( x _ { t } , a _ { t } ; \\theta _ { f } )$ . Let $\\hat { x } _ { t + 1 } = f ( x _ { t } , \\hat { a } _ { t } ; \\theta _ { f } )$ be the state prediction for the action predicted by $\\pi$ . Because the forward model is not analytic and learned from data, in general, there is no guarantee that $\\tilde { x } _ { t + 1 } = \\widehat { x } _ { t + 1 }$ , even though executing these two actions, $a _ { t } , { \\hat { a } } _ { t }$ , in the real-world will have the same effect. In order to make the outcome of action predicted by the GSP and the ground-truth action to be consistent with each other, we include an additional term, $\\lVert x _ { t + 1 } - \\hat { x } _ { t + 1 } \\rVert _ { 2 } ^ { 2 }$ in our loss function and infer the parameters $\\theta _ { f }$ by minimizing $\\begin{array} { r l r } { \\| x _ { t + 1 } - \\tilde { x } _ { t + 1 } \\| _ { 2 } ^ { 2 } } & { { } + } & { \\lambda \\| x _ { t + 1 } - } \\end{array}$ $\\hat { x } _ { t + 1 } \\| _ { 2 } ^ { 2 }$ , where $\\lambda$ is a scalar hyper-parameter. The first term ensures that the learned forward model explains ground truth transitions $( x _ { t } , a _ { t } , x _ { t + 1 } )$ collected by the agent and the second term ensures consistency. The joint objective for training GSP with forward model consistency is: ",
+        "bbox": [
+            173,
+            492,
+            826,
+            647
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a56811f00ff5fb2e5b428f9bee9e0c13aa5cd9a0f50f697f6d77d5db3e1722b4.jpg",
+        "text": "$$\n\\begin{array} { r l } { \\underset { \\theta _ { \\pi } , \\theta _ { f } } { \\operatorname* { m i n } } } & { \\| x _ { t + 1 } - \\tilde { x } _ { t + 1 } \\| _ { 2 } ^ { \\overline { { 2 } } } + \\lambda \\| x _ { t + 1 } - \\hat { x } _ { t + 1 } \\| _ { 2 } ^ { 2 } + \\mathcal { L } ( a _ { t } , \\hat { a } _ { t } ) } \\\\ { \\mathrm { s . t . } } & { \\tilde { x } _ { t + 1 } = f ( x _ { t } , a _ { t } ; \\theta _ { f } ) } \\\\ & { \\hat { x } _ { t + 1 } = f ( x _ { t } , \\hat { a } _ { t } ; \\theta _ { f } ) } \\\\ & { \\hat { a } _ { t } = \\pi ( x _ { t } , x _ { t + 1 } ; \\theta _ { \\pi } ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            308,
+            646,
+            689,
+            728
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Note that learning $\\theta _ { \\pi } , \\theta _ { f }$ jointly from scratch is precarious, because the forward model $f$ might not be good in the beginning, and hence could make the gradient updates noisier for $\\pi$ . To address this issue, we first pre-train the forward model with only the first term and GSP separately by blocking the gradient flow and then fine-tune jointly. ",
+        "bbox": [
+            174,
+            728,
+            820,
+            785
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Generalization to feature space dynamics Past work has shown that learning forward dynamics in the feature space as opposed to raw observation space is more robust and leads to better generalization (Agrawal et al., 2016; Pathak et al., 2017). Following these works, we extend the GSP to make predictions in feature representation $\\phi ( x _ { t } ) , \\phi ( x _ { t + 1 } )$ of the observations $x _ { t } , x _ { t + 1 }$ respectively learned through the self-supervised task of action prediction. The forward consistency loss is then computed by making predictions in this feature space $\\phi$ instead of raw observations. The optimization objective for feature space generalization with mutli-step objective is shown in Equation (4). ",
+        "bbox": [
+            173,
+            790,
+            825,
+            890
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Generalization to multi-step GSP We extend our one-step optimization to variable length sequence of actions in a straightforward manner by having a multi-step GSP $\\pi _ { m }$ model with a stepwise forward consistency loss. The GSP $\\pi _ { m }$ maintains an internal recurrent memory of the system and outputs actions conditioned on current observation $x _ { t }$ , starting from $x _ { i }$ to reach goal observation $x _ { T }$ . The forward consistency loss is computed at each time step, and jointly optimized with the action prediction loss over the whole trajectory. The final multi-step objective with feature space dynamics is as follows: ",
+        "bbox": [
+            173,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            172
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9bf4f050941243c6f6951ba26f4a6fec7f3900f9f95afec146082f70e8dd8b4d.jpg",
+        "text": "$$\n\\begin{array} { r l } { \\underset { \\theta _ { \\pi } , \\theta _ { f } , \\theta _ { \\phi } } { \\operatorname* { m i n } } } & { \\displaystyle \\sum _ { t = i } ^ { t = T } \\Big ( \\| \\phi ( x _ { t + 1 } ) - \\tilde { \\phi } ( x _ { t + 1 } ) \\| _ { 2 } ^ { 2 } + \\lambda \\| \\phi ( x _ { t + 1 } ) - \\hat { \\phi } ( x _ { t + 1 } ) \\| _ { 2 } ^ { 2 } + \\mathcal L ( a _ { t } , \\hat { a } _ { t } ) \\Big ) } \\\\ { \\mathrm { s . t . } } & { \\tilde { \\phi } ( x _ { t + 1 } ) = f ( \\phi ( x _ { t } ) , a _ { t } ; \\theta _ { f } ) } \\\\ & { \\hat { \\phi } ( x _ { t + 1 } ) = f ( \\phi ( x _ { t } ) , \\hat { a } _ { t } ; \\theta _ { f } ) } \\\\ & { \\hat { a } _ { t } = \\pi ( \\phi ( x _ { t } ) , \\phi ( x _ { T } ) ; \\theta _ { \\pi } ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            223,
+            176,
+            772,
+            280
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\phi ( . )$ is represented by a CNN with parameters $\\theta _ { \\phi }$ . The number of steps taken by the multistep GSP $\\pi _ { m }$ to reach the goal at inference is variable depending on the decision of goal recognizer; described in next subsection. Note that, in this objective, if $\\phi$ is identity then the dynamics simply reduces to modeling in raw observation space. We analyze feature space prediction in VizDoom 3D navigation and stick to observation space in the rope manipulation and the office navigation tasks. ",
+        "bbox": [
+            174,
+            281,
+            825,
+            352
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The multi-step forward-consistent $G S P \\pi _ { m }$ is implemented using a recurrent network which at every step takes as input the feature representation of the current $( \\phi ( x _ { t } ) )$ state, goal $( \\phi ( x _ { T } ) )$ states, action at the previous time step $\\left( a _ { t - 1 } \\right)$ and the internal hidden representation $h _ { t - 1 }$ of the recurrent units and predicts $\\hat { a } _ { t }$ . Note that inputting the previous action to $\\mathrm { G S P } \\pi _ { m }$ at each time step could be redundant given that hidden representation is already maintaining a history of the trajectory. Nonetheless, it is helpful to explicitly model this history. This formulation amounts to building an auto-regressive model of the joint action that estimates probability $P ( a _ { t } | x _ { 1 } , a _ { 1 } , . . . a _ { t - 1 } , x _ { t } , x _ { g } )$ at every time step. It is possible to further extend our forward-consistent GSP $\\pi _ { m }$ to build multi-step forward model, but we leave that direction of future work. ",
+        "bbox": [
+            174,
+            358,
+            825,
+            484
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "2.3 GOAL RECOGNIZER",
+        "text_level": 1,
+        "bbox": [
+            174,
+            501,
+            352,
+            515
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We train a goal recognizer network to figure out if the current goal is reached and therefore allow the agent to take variable numbers of steps between goals. Goal recognition is especially critical when the agent has to transit through a sequence of intermediate goals, as is the case for visual imitation, as otherwise compounding error could quickly lead to divergence from the demonstration. This recognition is simple given knowledge of the true physical state, but difficult when working with visual observations. Aside from the usual challenges of visual recognition, the dependence of observations on the agent’s own dynamics further complicates goal recognition, as the same goal can appear different while moving forward or turning during navigation. ",
+        "bbox": [
+            174,
+            526,
+            825,
+            638
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We pose goal recognition as a binary classification problem that given an observation $x _ { i }$ and the goal $x _ { g }$ infers if $x _ { i }$ is close to $x _ { g }$ or not. Lacking expert supervision of goals, we draw goal observations at random from the agent’s experience during exploration, since they are known to be feasible. For each such pseudo-goal, we consider observations that were only a few actions away to be positives (i.e., close to the goal) and the remaining observations that were more than a fixed number of actions (i.e., a margin) away as negatives. We trained the goal classifier using the standard cross-entropy loss. Like the skill policy, our goal recognizer is conditioned on the goal for generalization across goals. We found that training an independent goal recognition network consistently outperformed the alternative approach that augments the action space with a “stop” action. Making use of temporal proximity as supervision has also been explored for feature learning in the concurrent work of Sermanet et al. (2018). ",
+        "bbox": [
+            173,
+            645,
+            825,
+            797
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "2.4 ABLATIONS AND BASELINES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            814,
+            415,
+            828
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Our proposed formulation of GSP composed of following components: (a) recurrent variable-length skill policy network, (b) explicitly encoding previous action in the recurrence, (c) goal recognizer, (d) forward consistency loss function, and (w) learning forward dynamics in the feature space instead of raw observation space. We systematically ablate these components of forward-consistent GSP, to quantitatively review the importance of each component and then perform comparisons to the prior approaches that could be deployed for the task of visual imitation. ",
+        "bbox": [
+            174,
+            839,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/eae4b6382f956de78ccfb3d61bb1504645c7601322aa79336c4ca70b4e33e508.jpg",
+        "image_caption": [
+            "Figure 2: Qualitative visualization of results for rope manipulation task using Baxter robot. (a) Our robotics system setup. (b) The sequence of human demonstration images provided by the human during inference for the task of knot-tying (top row), and the sequences of observation states reached by the robot while imitating the given demonstration (bottom rows). (c) The sequence of human demonstration images and the ones reached by the robot for the task of manipulating rope into $\\mathbf { \\partial } ^ { \\cdot } \\mathbf { S } ^ { \\prime }$ shape. Our agent is able to successfully imitate the demonstration. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            223,
+            74,
+            772,
+            401
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The following methods will be evaluated and compared to in the subsequent experiments section: (1) Classical methods: In visual navigation, we attempted to compare against the state-of-the-art open source classical methods, namely, ORB-SLAM2 (Davison & Murray, 1998; Mur-Artal & Tardos, ´ 2017) and Open-SFM (Mapillary, 2016). (2) Inverse Model: Nair et al. (2017) leverage vanilla inverse dynamics to follow demonstration in rope manipulation setup. We compare to their method in both visual navigation and manipulation. (3) GSP-NoPrevAction-NoFwdConst is the ablation of our recurrent GSP without previous action history and without forward consistency loss. (4) GSP-NoFwdConst refers to our recurrent GSP with previous action history, but without forward consistency objective. (5) GSP-FwdRegularizer refers to the model where forward prediction is only used to regularize the features of GSP but has no role to play in the loss function of predicted actions. The purpose of this variant is to particularly ablate the benefit of consistency loss function with respect to just having forward model as feature regularizer. (6) GSP refers to our complete method with all the components. We now discuss the experiments and evaluate these baselines. ",
+        "bbox": [
+            174,
+            520,
+            825,
+            700
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            722,
+            326,
+            738
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We evaluate our model by testing its performance on: rope manipulation using Baxter robot, navigation of a wheeled robot in cluttered office environments, and simulated 3D navigation. The key requirements of a good skill policy are that it should generalize to unseen environments and new goals while staying robust to irrelevant distractors in the observations. For rope manipulation, we evaluate generalization by testing the ability of the robot to manipulate the rope into configurations such as knots that were not seen during random exploration. For navigation, both real-world and simulation, we check generalization by testing on a novel building/floor. ",
+        "bbox": [
+            174,
+            753,
+            825,
+            852
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.1 ROPE MANIPULATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            869,
+            367,
+            882
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Manipulation of non-rigid and deformable objects, e.g., rope, is a challenging problem in robotics. Even humans learn complex rope manipulation such as tying knots, either by observing an expert ",
+        "bbox": [
+            176,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/fae6edfc37d3577a3315f693038849eed414e21d7abb39711c71306fd37ceffe.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>Success %</td></tr><tr><td>Inverse Model [Nair et.al. 2017]</td><td>36%± 9.6%</td></tr><tr><td>Forward-regularized GSP</td><td>44%± 9.9%</td></tr><tr><td>Forward-consistent GSP [Ours]</td><td>60% ± 9.8%</td></tr><tr><td></td><td></td></tr></table>",
+        "bbox": [
+            482,
+            156,
+            756,
+            213
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/c118b28d8a83c13253a4b46c69b0cdd73a3ab2269efb886b97d23af45a7c11ed.jpg",
+        "image_caption": [
+            "Manipulation of non-rigid and deformable objects, e.g., rope, is a challenging problem iFigure 3: GSP trained using forward consistency loss significantly outperforms the baselines at the Even huperformtask of (a) manipulating rope into $\\mathbf { \\partial } ^ { 6 } \\mathbf { S } ^ { \\prime }$ s learn complex rope manipulation such as tying knots, either by observingby receiving explicit instructions. To test whether our agent could manipu shape as measured by TPS-RPM error and (b) knot-tying by simply observing a human, we use the dawhere we report success rate with bootstrap standard deviation. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            238,
+            103,
+            462,
+            280
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "60K interaction pairs of the form (xt, at, xt+1) that are used to train the GSP.perform it or by receiving explicit instructions. We test whether our agent could manipulate ropes During inference, our proposed approach is tasked to follow a visual demonstration provby simply observing a human perform it. We use the data collected by Nair et al. (2017), where human expert for manipulating the rope into a complex ‘S’ shape and tying a knot. Our agea Baxter robot manipulated a rope kept on the table in front of it. During exploration, the robot robot, only gets to observe the image sequence of intermediate states, as human manipinteracts with the rope by using a pick and place primitive that chooses a random point on the rope rope, without any access to the corresponding actions. Note that the knot shape is never enand displaces it by a randomly chosen length and direction. This process is repeated a number of generalize to be able to follow thtimes to collect about 60K interaction pairs of the form $( x _ { t } , a _ { t } , x _ { t + 1 } )$ ration. More details follow in the suppthat are used to train the GSP. ",
+        "bbox": [
+            174,
+            364,
+            825,
+            449
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "During inference, our proposed approach is tasked to follow a visual demonstration provided by a Metric The performance of thhuman expert for manipulating the rope into a complex $\\mathbf { \\partial } ^ { \\bullet } \\mathbf { S } ^ { \\bullet }$ odel is evaluated by measuring the non-rigid registr shape and tying a knot. Our agent, Baxter the demonstration. The matching cost is measured using the thin plate spline robust pointrobot, only gets to observe the image sequence of intermediate states, as human manipulates the technique (TPS-RPM) described in (Chui & Rangarajan, 2003). While TPS-RPM providrope, without any access to the corresponding actions. Note that the knot shape is never encountered metric for measuring performance for constructing the ‘S’ shape, it is not an appropriateduring the self-supervised data collection phase and therefore the learned GSP model would have to knots because the configuration of the rope in a knot is 3D due to intertwining of the ropegeneralize to be able to follow the human demonstration. More details follow in the supplementary material, Section A.1. ",
+        "bbox": [
+            174,
+            457,
+            825,
+            554
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Visual Imitation We compare our approach to the previous best method of visual imitMetric The performance of the model is evaluated by measuring the non-rigid registration cost deploys an inverse model which takes as input a pair of current and goal images to between the rope state achieved by the robot and the state demonstrated by the human at every step in for a fair comparison. The comparison is performed apples-to-apples and the only differethe demonstration. The matching cost is measured using the thin plate spline robust point matching we deploy forward-consistency loss for our approach. The results in Figure 2 show that otechnique (TPS-RPM) described in (Chui & Rangarajan, 2003). While TPS-RPM provides a good significantly outperforms the basmetric for measuring performance for constructing the $\\mathbf { \\epsilon } ^ { 6 } \\mathbf { S } ^ { \\prime }$ at task of manipulating the rope in the ‘S’ shape and shape, it is not an appropriate metric for an accuracy of 60% in comparison to 36% achieved by the baseline.knots because the configuration of the rope in a knot is 3D due to intertwining of the rope, and it fails to find the correct point correspondences. We, therefore, use success rate as the metric in knot 3.2 NAV IGAT ION IN INDOOR OFFICE ENVIRONMENTStying where the completion of a successful knot is judged by human verification. ",
+        "bbox": [
+            173,
+            560,
+            825,
+            672
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "A natural way to instruct a robot to move in an indoor office environment is to ask it tVisual Imitation Qualitative examples of our agent trying to manipulate rope are shown in Figure 2. command the robot, in this work, we communicate with the robot by either showing it a sinWe compare our approach to the baseline that deploys an inverse model which takes as input a pair of the goal, or a sequence of images leading to faraway goals. In both scenarios, the robot iof current and goal images to output the desired action to reach the goal (Nair et al., 2017). We reto autonomously determine the motor commands for moving to the goal. We used Turtimplement the baseline and train in our setup for a fair comparison. To further ablate the importance navigation using an onboard camera for sensing RGB images. For learning the GSP, an aof consistency loss, we compare to a baseline that just uses a forward model as a regularizer of features. The results in Figure 3 show that our method significantly outperforms the baseline at task twoof manipulating the rope in the $\\mathbf { \\partial } ^ { \\cdot } \\mathbf { S } ^ { \\prime }$ ors of a academic building in total. We then dep shape and achieves a success rate of $6 0 \\%$ the learned model on ain comparison to $3 6 \\%$ achieved by the baseline. ",
+        "bbox": [
+            174,
+            679,
+            825,
+            790
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.2 NAVIGATION IN INDOOR OFFICE ENVIRONMENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            811,
+            557,
+            827
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "A natural way to instruct a robot to move in an indoor office environment is to ask it to go near a certain location, such as a refrigerator or a someone’s office. Instead of using language to command the robot, in this work, we communicate with the robot by either showing it a single image of the goal, or a sequence of images leading to faraway goals. In both scenarios, the robot is required to autonomously determine the motor commands for moving to the goal. We used TurtleBot2 for navigation using an onboard camera for sensing RGB images. For learning the GSP, an automated ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/a29bde948214b45c66c17edaa9b35cd33f80620e6ae9d7303d434715280bc509.jpg",
+        "image_caption": [
+            "Figure 4: Visualization of the TurtleBot trajectory to reach a goal image (right) from the initial image (top-left). Since the initial and goal image have no overlap, the robot first explores the environment by turning in place. Once it detects overlap between its current image and goal image (i.e. step 42 onward), it moves towards the goal. Note that we did not explicitly train the robot to explore and such exploratory behavior naturally emerged from the self-supervised learning. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            103,
+            818,
+            228
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/7e3457bf79942d614f60545cf6d5b9311c124a1a0bb3d293032d238a8d64fcf2.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model Name</td><td>Run Id-1</td><td>Run Id-2</td><td>Run Id-3</td><td>Run Id-4</td><td>Run Id-5</td><td>Run Id-6</td><td>Run Id-7</td><td>Run Id-8</td><td>Num Success</td></tr><tr><td>Random Search</td><td>Fail</td><td>Fail</td><td>Fail</td><td>Fail</td><td>Fail</td><td>Fail</td><td>Fail</td><td>Fail</td><td>0</td></tr><tr><td>Inverse Model[Nair et.al. 2017]</td><td>Fail</td><td>Fail</td><td>Fail</td><td>Fail</td><td>Fail</td><td>Fail</td><td>Fail</td><td>Fail</td><td>0</td></tr><tr><td>GSP-NoPrevAction-NoFwdConst</td><td>39 steps</td><td>34 steps</td><td>Fail</td><td>Fail</td><td>Fail</td><td>Fail</td><td>Fail</td><td>Fail</td><td>2</td></tr><tr><td>GSP-NoFwdConst</td><td>22 steps</td><td>22 steps</td><td>39 steps</td><td>48 steps</td><td>Fail</td><td>Fail</td><td>Fail</td><td>Fail</td><td>4</td></tr><tr><td>GSP (Ours)</td><td>119 steps</td><td>66 steps</td><td>144 steps</td><td>67 steps</td><td>51 steps</td><td>Fail</td><td>100 steps</td><td>Fail</td><td>6</td></tr></table>",
+        "bbox": [
+            173,
+            325,
+            825,
+            400
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 1: Quantitative evaluation of various methods on the task of navigating using a single image of goal in an unseen environment. Each column represents a different run of our system for a different initial/goal image pair. Our full GSP model takes longer to reach the goal on average given a successful run but reaches the goal successfully at a much higher rate. ",
+        "bbox": [
+            173,
+            410,
+            825,
+            465
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "self-supervised scheme for data collection was devised that doesn’t require human supervision. The robot collected a number of navigation trajectories from two floors of a academic building which in total contain 230K interactions data, i.e. $( x _ { t } , a _ { t } , x _ { t + 1 } )$ . We then deployed the learned model on a separate floor of a building with substantially different textures and furniture layout for performing visual imitation at test time. The details of the robotic setup, data collection, and network architecture of GSP are described in supplementary material, Section A.2. ",
+        "bbox": [
+            174,
+            494,
+            825,
+            578
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "1) Goal Finding We first tested if the GSP learned by the TurtleBot can enable it to find its way to a goal that is within the same room from just a single image of the goal. To test the extrapolative generalization, we keep the Turtlebot approximately 20-30 steps away from the target location in a way that current and goal observations have no overlap as shown in Figure 4. We test the robot in an indoor office environment on a different floor that it has never encountered before. We judge the robot to be successful if it stops close to the goal and failure if it crashed into furniture or does not reach the goal within 200 steps. Since the initial and goal images have no overlap, classical techniques such as structure from motion that rely on feature matching cannot be used to infer the executed action. Therefore, in order to reach the goal, the robot must explore its surroundings. We find that our GSP model outperforms the baseline models in reaching the target location. Our model learns the exploratory behavior of rotating in place until it encounters an overlap between its current and goal image. Results are shown in Table 1 and videos are available at the website 1. ",
+        "bbox": [
+            174,
+            585,
+            825,
+            751
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "2) Visual Imitation In the previous paragraph, we saw that the robot can reach a goal that’s within the same room. However, our agent is unable to reach far away goals such as in other rooms using just a single image. In such scenarios, an expert might communicate instructions like go to the door, turn right, go to the closest chair etc. Instead of language instruction, in our setup we provide a sequence of landmark images to convey the same high-level idea. These landmark images were captured from the robot’s camera as the expert moved the robot from the start to a goal location. However, note that it is not necessary for the expert to control the robot to capture the images because we don’t make use of the expert’s actions, but only the images. Instead of providing the image after every action in the demonstration, we only provided every fifth image. The rationale behind this choice is that we want to sample the demonstration sparsely to minimize the agent’s ",
+        "bbox": [
+            174,
+            758,
+            825,
+            897
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/d73cebcd59f84f7349737b59d7c4d067bdee1cbd515f7bbb88ec98234df23365.jpg",
+        "image_caption": [
+            "Figure 5: The performance of TurtleBot at following a visual demonstration given as a sequence of images (top row). The TurtleBot is positioned in a manner such that the first image in demonstration has no overlap with its current observation. Even under this condition the robot is able to move close to the first demo image (shown as Robot WayPoint-1) and then follow the provided demonstration until the end. This also exemplifies a failure case for classical methods; there are no possible keypoint matches between WayPoint-1 and WayPoint-2, and the initial observation is even farther from WayPoint-1. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            103,
+            821,
+            238
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/e6637016712eb47f00af02c43fdf86e8481b5611502ee7ca82643d6994762216.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"3\">Maze Demonstration</td><td colspan=\"3\">Loop Demonstration</td></tr><tr><td>Model Name</td><td>Run-1</td><td>Run-2</td><td>Run-3</td><td>Run-1</td><td>Run-2</td><td>Run-3</td></tr><tr><td>SIFT</td><td>10%</td><td>5%</td><td>15%</td><td></td><td></td><td></td></tr><tr><td>GSP-NoPrevAction-NoFwdConst</td><td>60%</td><td>70%</td><td>100%</td><td></td><td>一</td><td></td></tr><tr><td>GSP-NoFwdConst</td><td>65%</td><td>90%</td><td>100%</td><td>0%</td><td>0%</td><td>0%</td></tr><tr><td>GSP (ours)</td><td>100%</td><td>60%</td><td>100%</td><td>0%</td><td>100%</td><td>100%</td></tr></table>",
+        "bbox": [
+            204,
+            364,
+            794,
+            467
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Table 2: Quantitative evaluation of TurtleBot’s performance at following visual demonstrations in two scenarios: maze and the loop. We report the $\\%$ of landmarks reached by the agent across three runs of two different demonstrations. Results show that our method outperforms the baselines. Note that 3 more trials of the loop demonstration were tested under significantly different lighting conditions and neither model succeeded. Detailed results are available in the supplementary materials. ",
+        "bbox": [
+            173,
+            477,
+            825,
+            547
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "reliance on the expert. Such sub-sampling (as shown in Figure 5) provides an easy way to vary the complexity of the task. ",
+        "bbox": [
+            174,
+            577,
+            823,
+            604
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We evaluate via multiple runs of two demonstrations, namely, maze demonstration where the robot is supposed to navigate through a maze-like path and perturbed loop demonstration, where the robot is supposed to make a complete loop as instructed by demonstration images. The loop demonstration is longer and more difficult than the maze. We start the agent from different starting locations and orientations with respect to that of demonstration. Each orientation is initialized such that no part of the demonstration’s initial frame is visible. Results are shown in Table 2. When we sample every frame, our method and classical structure from motion can both be used to follow the demonstration. However, at sub-sampling rate of five, SIFT-based feature matching approaches did not work and ORBSLAM2 (Mur-Artal & Tardos, 2017) failed to generate a map, whereas our ´ method was successful. Notice that providing sparse landmark images instead of dense video adds robustness to the visual imitation task. In particular, consider the scenario in which the environment has changed since the time the demonstration was recorded. By not requiring the agent to match every demonstration image frame-by-frame, it becomes less sensitive to changes in the environment. ",
+        "bbox": [
+            173,
+            613,
+            825,
+            792
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "3.3 3D NAVIGATION IN VIZDOOM ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            813,
+            423,
+            827
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We have evaluated our approach on real-robot scenarios thus far. To further analyze the performance and robustness of our approach through large scale experiments, we setup the same navigation task as described in previous subsection in a simulated VizDoom environment. Our goal is to measure: (1) the robustness of each method with proper error bars, (2) the role of initial self-supervised data collection for performance on visual imitation, (3) the quantitative difference in modeling forward consistency loss in feature space in comparison to raw visual space. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/4b21af28d70c143c16b16856c4772d6a723406f7c9874cf0ca5104442fffde88.jpg",
+        "table_caption": [
+            "Table 3: Quantitative evaluation of our proposed GSP and the baseline models at following visual demonstrations in VizDoom 3D Navigation. Medians and $9 5 \\%$ confidence intervals are reported for demonstration completion and efficiency over 50 seeds and 5 human paths per environment type. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model Name</td><td>Same Map, Same Texture Median%</td><td>Efficiency %</td><td>Same Map,Diff Texture Median %</td><td>Efficiency %</td><td>Diff Map,Diff Texture Median %</td><td>Efficiency %</td></tr><tr><td colspan=\"7\">Random Exploration for Data Collection:</td></tr><tr><td>GSP-NoFwdConst</td><td>63.2 ± 5.7</td><td>36.4 ± 3.3</td><td>32.2 ± 0.7</td><td>28.9 ± 4.0</td><td>34.5 ± 0.6</td><td>23.1 ± 2.4</td></tr><tr><td>GSP (ours pixels)</td><td>62.2 ± 5.1</td><td>43.0±2.6</td><td>32.4 ± 0.8</td><td>30.9 ± 2.9</td><td>35.4 ± 1.1</td><td>29.3 ± 3.9</td></tr><tr><td>GSP (ours features)</td><td>68.9 ± 6.9</td><td>53.9 ±4.0</td><td>32.4 ± 0.7</td><td>47.4 ± 7.6</td><td>39.1 ± 2.0</td><td>30.4 ± 2.5</td></tr><tr><td colspan=\"7\">Curiosity-driven Exploration for Data Collection:</td></tr><tr><td>GSP-NoFwdConst</td><td>78.2 ± 2.3</td><td>63.0 ± 4.3</td><td>43.2 ± 2.6</td><td>33.9 ± 3.0</td><td>40.2 ±4.0</td><td>27.3 ±1.9</td></tr><tr><td>GSP-FwdRegularizer</td><td>78.4± 3.4</td><td>59.8 ± 4.1</td><td>50.6 ± 4.7</td><td>30.9 ±3.0</td><td>37.9 ± 1.1</td><td>28.9 ±1.7</td></tr><tr><td>GSP (ours pixels)</td><td>78.2 ± 3.4</td><td>65.2 ± 4.2</td><td>47.1 ± 4.7</td><td>32.4±3.0</td><td>44.8 ± 4.0</td><td>29.5 ± 1.9</td></tr><tr><td>GSP (ours features)</td><td>78.2 ±4.6</td><td>67.0± 3.3</td><td>49.4 ± 4.8</td><td>26.9 ± 1.5</td><td>47.1 ± 3.0</td><td>24.1 ±1.7</td></tr></table>",
+        "bbox": [
+            176,
+            101,
+            825,
+            260
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In VizDoom, we collect data by deploying two types of exploration methods: random exploration and curiosity-driven exploration (Pathak et al., 2017). The hypothesis is that if the initial data collected by the robot is driven by a better strategy than just random, this should eventually help the agent follow long demonstrations better. Our environment consists of 2 maps in total. We train on one map with 5 different starting positions for collecting exploration data. For validation, we collect 5 human demonstrations in a map with the same layout as in training but with different textures. For zero-shot generalization, we collect 5 human demonstrations in a novel map layout with novel textures. Exact details for data collection and training setup are in the supplementary, Section A.3. ",
+        "bbox": [
+            174,
+            340,
+            825,
+            452
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Metric We report the median of maximum distance reached by the robot in following the given sequence of demonstration images. The maximum distance reached is the distance of farthest landmark point that the agent reaches contiguously, i.e., without missing any intermediate landmarks. Measuring the farthest landmark reached does not capture how efficiently it is reached. Hence, we further measure efficiency of the agent as the ratio of number of steps taken by the agent to reach farthest contiguous landmark with respect to the number of steps shown in human demonstrations. ",
+        "bbox": [
+            174,
+            458,
+            825,
+            541
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Visual Imitation The task here is same as the one in real robot navigation where the agent is shown a sparse sequence of images to imitate. The results are in Table 3. We found that the exploration data collected via curiosity significantly improves the final imitation performance across all methods including the baselines with respect to random exploration. Our baseline GSP model with a forward regularizer instead of consistency loss ends up overfitting to the training layout. In contrast, our forward-consistent GSP model outperforms other methods in generalizing to new map with novel textures. This indicates that the forward consistency is possibly doing more than just regularizing the policy features. Training forward consistency loss in feature space further enhances the generalization even when both pixel and feature space models perform similarly on training environment. ",
+        "bbox": [
+            173,
+            549,
+            825,
+            674
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "4 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            695,
+            344,
+            712
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Our work is closely related to imitation learning, but we address a different problem statement that gives less supervision and requires generalization across tasks during inference. ",
+        "bbox": [
+            173,
+            728,
+            823,
+            756
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Imitation Learning The two main threads of imitation learning are behavioral cloning (Argall et al., 2009; Pomerleau, 1989), which directly supervises the mapping of states to actions, and inverse reinforcement learning (Abbeel & Ng, 2004; Ho & Ermon, 2016; Levine et al., 2016; $\\mathrm { N g }$ & Russell, 2000; Ziebart et al., 2008), which recovers a reward function that makes the demonstration optimal (or nearly optimal). Inverse RL is most commonly achieved with state-actions, and is difficult to extend to fitting the reward to observations alone, though in principle state occupancy could be sufficient. Recent work in imitation learning (Duan et al., 2017; Finn et al., 2017; Gupta et al., 2017) can generalize to novel goals, but require a wealth of demonstrations comprised of expert state-actions for learning. Our approach does not require expert actions at all. ",
+        "bbox": [
+            174,
+            762,
+            825,
+            888
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Visual Demonstration The common scenario in LfD is to assume full knowledge of expert states and actions during demonstrations, but several papers have focused on relaxing this supervision to visual observations alone. Nair et al. (2017) observe a sequence of images from the expert demonstration for performing rope manipulations. Sermanet et al. (2017; 2018) imitate humans with robots by self-supervised learning but require expert supervision at training time. Third person imitation learning (Stadie et al., 2017) and the concurrent work of imitation-from-observation (Liu et al., 2018) learn to translate expert observations into agent observations such that they can do policy optimization to minimize the distance between the agent trajectory and the translated demonstration, but they require demonstrations for learning. Visual servoing is a standard problem in robotics (Koichi & Tom, 1993) that seeks to take actions that align the agent’s observation with a target configuration of carefully-designed visual features (Wilson et al., 1996; Yoshimi & Allen, 1994) or raw pixel intensities (Caron et al., 2013). Classical methods rely on fixed features or policies, but more recently end-to-end learning has improved results (Lampe & Riedmiller, 2013; Lee et al., 2017). ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            256
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Forward/Inverse Dynamics and Consistency Numerous prior works, such as Ebert et al. (2017); Oh et al. (2015); Watter et al. (2015), have learned forward dynamics model for planning actions. The works of Agrawal et al. (2016); Jordan & Rumelhart (1992); Pathak et al. (2017); Wolpert et al. (1995) jointly learn forward and inverse dynamics model but do not optimize for consistency between the forward and inverse dynamics. We empirically show that learning models by our forward consistency loss significantly improves task performance. Enforcing consistency as a meta-supervision has also been successful in finding visual correspondences (Zhou et al., 2016) or unpaired image translations (Zhu et al., 2017). ",
+        "bbox": [
+            174,
+            263,
+            825,
+            375
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Goal Conditioning By parameterizing the value or policy function with a goal, an agent can learn and do multiple tasks. The idea of learning goal-conditioned policies has been explored in (Agrawal et al., 2016; Andrychowicz et al., 2017; Nair et al., 2017; Schaul et al., 2015). Similarly to hindsight experience replay (Andrychowicz et al., 2017) we draw goals from experience, but our policy optimization has better sample efficiency through supervised learning and dynamics modeling instead of reinforcement learning. Moreover, we work from high-dimensional visual inputs instead of knowledge of the true states and do not make use of a task reward during training. In our setting, all of the expert goals are followed zero-shot since they are only revealed after learning. ",
+        "bbox": [
+            174,
+            382,
+            823,
+            493
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "5 DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            516,
+            310,
+            532
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "In this work, we presented a method for imitating expert demonstrations from visual observations alone. In contrast to most work in imitation learning, we never require access to expert actions. The key idea is to learn a GSP using data collected by self-supervised exploration. However, this limits the quality of the learned GSP as per the exploration data. For instance, we deploy random exploration on our real-world navigation robot, which means that it would almost never follow trajectories that go between rooms. Consequently, the learned GSP is unable to navigate towards a goal image taken in another room without requiring intermediate sub-goals. Pathak et al. (2017) show that the agent learns to move along corridors and transition between rooms purely driven by curiosity in VizDoom. Training GSP on such a structured data could equip the agent with more interesting search behaviors, e.g., going across rooms to find a goal. In general, using better methods of exploration for training the GSP could be a fruitful direction toward generalizing zeroshot imitation. ",
+        "bbox": [
+            174,
+            547,
+            825,
+            702
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "One limitation of our approach is that we require first-person view demonstrations. Extension to third-person demonstrations (Liu et al., 2018; Stadie et al., 2017) would make the method applicable in more general scenarios. Another limitation is that, in the current framework, it is implicitly assumed that the statistics of visual observations when the expert demonstrates the task and the agent follows it are similar. For e.g., when the expert performs a demonstration in one setting, say in daylight and the agent needs to imitate say in the evening, the change in the lighting conditions might result in worse performance. Making the GSP robust to such nuisance changes or other changes in environment by domain adaptation would be necessary to scale the method to practical problems. Another thing to note is that, in the current framework, we do not learn from expert demonstrations, but simply imitate them. It would be interesting to investigate ways for an agent to learn from the expert to bias its exploration to more useful parts of the environment. ",
+        "bbox": [
+            174,
+            708,
+            825,
+            861
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "While we used a sequence of images to provide a demonstration, our work makes no image-specific assumptions and can be extended to using formal language for communicating goals. For instance, after training the GSP, instead of transforming an image into features $\\phi$ as described in section 2.2, one could possibly learn a mapping to transform language instructions into this feature space. ",
+        "bbox": [
+            176,
+            868,
+            823,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            104,
+            326,
+            117
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We would like to thank members of BAIR for fruitful discussions and comments. This work was supported in part by DARPA; NSF IIS-1212798, IIS-1427425, IIS-1536003, Berkeley DeepDrive, and an equipment grant from NVIDIA and the Valrhona Reinforcement Learning Fellowship. DP is supported by NVIDIA and Snapchat’s graduate fellowships. ",
+        "bbox": [
+            174,
+            128,
+            825,
+            184
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES   \nPieter Abbeel and Andrew Y. Ng. Apprenticeship learning via inverse reinforcement learning. In ICML, 2004. 10   \nPulkit Agrawal, Ashvin Nair, Pieter Abbeel, Jitendra Malik, and Sergey Levine. Learning to poke by poking: Experiential learning of intuitive physics. NIPS, 2016. 2, 4, 11   \nMarcin Andrychowicz, Filip Wolski, Alex Ray, Jonas Schneider, Rachel Fong, Peter Welinder, Bob McGrew, Josh Tobin, Pieter Abbeel, and Wojciech Zaremba. Hindsight experience replay. In NIPS, 2017. 2, 11   \nBrenna D Argall, Sonia Chernova, Manuela Veloso, and Brett Browning. A survey of robot learning from demonstration. Robotics and autonomous systems, 2009. 1, 10   \nAlbert Bandura and Richard H Walters. Social learning theory, volume 1. Prentice-hall Englewood Cliffs, NJ, 1977. 1   \nCynthia Breazeal and Brian Scassellati. Robots that imitate humans. Trends in cognitive sciences, 2002. 1   \nGuillaume Caron, Eric Marchand, and El Mustapha Mouaddib. Photometric visual servoing for omnidirectional cameras. Autonomous Robots, 35(2-3):177–193, 2013. 11   \nHaili Chui and Anand Rangarajan. A new point matching algorithm for non-rigid registration. CVIU, 2003. 7   \nAndrew J Davison and David W Murray. Mobile robot localisation using active vision. In ECCV, 1998. 6   \nRudiger Dillmann. Teaching and learning of robot tasks via observation of human performance. ¨ Robotics and Autonomous Systems, 2004. 1   \nYan Duan, Marcin Andrychowicz, Bradly Stadie, OpenAI Jonathan Ho, Jonas Schneider, Ilya Sutskever, Pieter Abbeel, and Wojciech Zaremba. One-shot imitation learning. In NIPS, 2017. 2, 10   \nFrederik Ebert, Chelsea Finn, Alex X Lee, and Sergey Levine. Self-supervised visual planning with temporal skip connections. arXiv preprint arXiv:1710.05268, 2017. 11   \nChelsea Finn, Tianhe Yu, Tianhao Zhang, Pieter Abbeel, and Sergey Levine. One-shot visual imitation learning via meta-learning. CoRL, 2017. 2, 10   \nDavid Foster and Peter Dayan. Structure in the space of value functions. Machine Learning, 2002. 3   \nSaurabh Gupta, James Davidson, Sergey Levine, Rahul Sukthankar, and Jitendra Malik. Cognitive mapping and planning for visual navigation. CVPR, 2017. 10   \nKaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, 2016. 15   \nJonathan Ho and Stefano Ermon. Generative adversarial imitation learning. In NIPS, 2016. 10   \nKatsushi Ikeuchi and Takashi Suehiro. Toward an assembly plan from observation. i. task recognition with polyhedral objects. IEEE Transactions on Robotics and Automation, 1994. 1 ",
+        "bbox": [
+            171,
+            204,
+            826,
+            917
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            895,
+            825,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Michael I Jordan and David E Rumelhart. Forward models: Supervised learning with a distal teacher. Cognitive science, 1992. 3, 11 ",
+        "bbox": [
+            173,
+            103,
+            821,
+            132
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. ICLR, 2015. 15 ",
+        "bbox": [
+            174,
+            140,
+            805,
+            156
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Diederik $\\mathrm { \\bf P }$ Kingma and Max Welling. Auto-encoding variational bayes. arXiv preprint arXiv:1312.6114, 2013. 4 ",
+        "bbox": [
+            173,
+            165,
+            823,
+            194
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Hashimoto Koichi and Husband Tom. Visual servoing: real-time control of robot manipulators based on visual sensory feedback, volume 7. World scientific, 1993. 11 ",
+        "bbox": [
+            169,
+            202,
+            823,
+            232
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Yasuo Kuniyoshi, Masayuki Inaba, and Hirockika Inoue. Teaching by showing: Generating robot programs by visual observation of human performance. In International Symposium on Industrial Robots, 1989. 1 ",
+        "bbox": [
+            173,
+            239,
+            825,
+            282
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Yasuo Kuniyoshi, Masayuki Inaba, and Hirochika Inoue. Learning by watching: Extracting reusable task knowledge from visual observation of human performance. IEEE Transactions on Robotics and Automation, 1994. 1 ",
+        "bbox": [
+            173,
+            290,
+            825,
+            333
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Thomas Lampe and Martin Riedmiller. Acquiring visual servoing reaching and grasping skills using neural reinforcement learning. In Neural Networks (IJCNN), The 2013 International Joint Conference on, pp. 1–8. IEEE, 2013. 11 ",
+        "bbox": [
+            174,
+            342,
+            825,
+            386
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Alex X Lee, Sergey Levine, and Pieter Abbeel. Learning visual servoing with deep features and fitted q-iteration. arXiv preprint arXiv:1703.11000, 2017. 11 ",
+        "bbox": [
+            169,
+            393,
+            823,
+            422
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Sergey Levine, Peter Pastor, Alex Krizhevsky, and Deirdre Quillen. Learning hand-eye coordination for robotic grasping with large-scale data collection. In ISER, 2016. 2, 10 ",
+        "bbox": [
+            171,
+            430,
+            823,
+            460
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "YuXuan Liu, Abhishek Gupta, Pieter Abbeel, and Sergey Levine. Imitation from observation: Learning to imitate behaviors from raw video via context translation. ICRA, 2018. 11 ",
+        "bbox": [
+            173,
+            468,
+            823,
+            497
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Mapillary. Open source structure from motion pipeline. https://github.com/mapillary/ OpenSfM, 2016. 6 ",
+        "bbox": [
+            173,
+            506,
+            823,
+            535
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Raul Mur-Artal and Juan D Tardos. Orb-slam2: An open-source slam system for monocular, stereo, ´ and rgb-d cameras. IEEE Transactions on Robotics, 2017. 6, 9 ",
+        "bbox": [
+            173,
+            544,
+            823,
+            573
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Ashvin Nair, Dian Chen, Pulkit Agrawal, Phillip Isola, Pieter Abbeel, Jitendra Malik, and Sergey Levine. Combining self-supervised learning and imitation for vision-based rope manipulation. ICRA, 2017. 2, 6, 7, 11, 15 ",
+        "bbox": [
+            176,
+            580,
+            823,
+            625
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Andrew $\\mathrm { ~ Y ~ N ~ g ~ }$ and Stuart J Russell. Algorithms for inverse reinforcement learning. In ICML, pp. 663–670, 2000. 1, 10 ",
+        "bbox": [
+            173,
+            632,
+            821,
+            661
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Junhyuk Oh, Xiaoxiao Guo, Honglak Lee, Richard L Lewis, and Satinder Singh. Action-conditional video prediction using deep networks in atari games. In NIPS, 2015. 11 ",
+        "bbox": [
+            171,
+            670,
+            823,
+            699
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Pierre-Yves Oudeyer, Frdric Kaplan, and Verena V Hafner. Intrinsic motivation systems for autonomous mental development. Evolutionary Computation, 2007. 3 ",
+        "bbox": [
+            173,
+            707,
+            823,
+            737
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Deepak Pathak, Pulkit Agrawal, Alexei A. Efros, and Trevor Darrell. Curiosity-driven exploration by self-supervised prediction. In ICML, 2017. 3, 4, 10, 11, 16 ",
+        "bbox": [
+            174,
+            744,
+            823,
+            775
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Lerrel Pinto and Abhinav Gupta. Supersizing self-supervision: Learning to grasp from 50k tries and 700 robot hours. ICRA, 2016. 2 ",
+        "bbox": [
+            174,
+            782,
+            823,
+            811
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Dean A Pomerleau. ALVINN: An autonomous land vehicle in a neural network. In NIPS, 1989. 1, 10 ",
+        "bbox": [
+            173,
+            820,
+            821,
+            849
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Danilo Jimenez Rezende, Shakir Mohamed, and Daan Wierstra. Stochastic backpropagation and approximate inference in deep generative models. arXiv preprint arXiv:1401.4082, 2014. 4 ",
+        "bbox": [
+            173,
+            857,
+            823,
+            887
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Stefan Schaal. Is imitation learning the route to humanoid robots? Trends in cognitive sciences, 1999. 1 ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Tom Schaul, Daniel Horgan, Karol Gregor, and David Silver. Universal value function approximators. In ICML, 2015. 3, 11 ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Jurgen Schmidhuber. A possibility for implementing curiosity and boredom in model-building neural controllers. In From animals to animats: Proceedings of the first international conference on simulation of adaptive behavior, 1991. 3 ",
+        "bbox": [
+            174,
+            140,
+            821,
+            184
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Pierre Sermanet, Kelvin Xu, and Sergey Levine. Unsupervised perceptual rewards for imitation learning. In RSS, 2017. 11 ",
+        "bbox": [
+            171,
+            193,
+            825,
+            222
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Pierre Sermanet, Corey Lynch, Yevgen Chebotar, Jasmine Hsu, Eric Jang, Stefan Schaal, and Sergey Levine. Time-contrastive networks: Self-supervised learning from video. In ICRA, 2018. 5, 11 ",
+        "bbox": [
+            173,
+            231,
+            823,
+            260
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Bradly C. Stadie, Pieter Abbeel, and Ilya Sutskever. Third-person imitation learning. In ICLR, 2017. 11 ",
+        "bbox": [
+            174,
+            267,
+            823,
+            296
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Manuel Watter, Jost Springenberg, Joschka Boedecker, and Martin Riedmiller. Embed to control: A locally linear latent dynamics model for control from raw images. In NIPS, 2015. 11 ",
+        "bbox": [
+            173,
+            306,
+            823,
+            335
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "William J Wilson, CC Williams Hulls, and Graham S Bell. Relative end-effector control using cartesian position based visual servoing. IEEE Transactions on Robotics and Automation, 12(5): 684–696, 1996. 11 ",
+        "bbox": [
+            173,
+            343,
+            823,
+            386
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Daniel M Wolpert, Zoubin Ghahramani, and Michael I Jordan. An internal model for sensorimotor integration. Science-AAAS-Weekly Paper Edition, 1995. 11 ",
+        "bbox": [
+            173,
+            395,
+            823,
+            424
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Yezhou Yang, Yi Li, Cornelia Fermuller, and Yiannis Aloimonos. Robot learning manipulation ¨ action plans by ”watching” unconstrained videos from the world wide web. In AAAI, 2015. 1 ",
+        "bbox": [
+            171,
+            433,
+            825,
+            462
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Billibon H Yoshimi and Peter K Allen. Active, uncalibrated visual servoing. In Robotics and Automation, 1994. Proceedings., 1994 IEEE International Conference on, pp. 156–161. IEEE, 1994. 11 ",
+        "bbox": [
+            173,
+            469,
+            823,
+            513
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Tinghui Zhou, Philipp Krahenbuhl, Mathieu Aubry, Qixing Huang, and Alexei A. Efros. Learning dense correspondence via 3d-guided cycle consistency. In CVPR, 2016. 11 ",
+        "bbox": [
+            171,
+            522,
+            823,
+            551
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Jun-Yan Zhu, Taesung Park, Phillip Isola, and Alexei A. Efros. Unpaired image-to-image translation using cycle-consistent adversarial networks. ICCV, 2017. 11 ",
+        "bbox": [
+            171,
+            559,
+            821,
+            589
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Brian D. Ziebart, Andrew Maas, J Andrew Bagnell, and Anind K Dey. Maximum entropy inverse reinforcement learning. In AAAI, 2008. 10 ",
+        "bbox": [
+            173,
+            598,
+            823,
+            627
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A SUPPLEMENTARY MATERIAL ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            102,
+            450,
+            117
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "We evaluated our proposed approach across number of environments and tasks. In this section, we provide additional details about the experimental task setup and hyperparameters. ",
+        "bbox": [
+            174,
+            133,
+            823,
+            161
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "A.1 ROPE MANIPUATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            179,
+            362,
+            193
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Robotic Setup Our setup of Baxter robot for rope manipulation task follows the one described in Nair et al. (2017). We re-use the data that is collected by a Baxter robot interacting with a rope kept on a table in front of it in a self-supervised manner, and consists of approximately 60K interaction pairs. ",
+        "bbox": [
+            174,
+            204,
+            825,
+            261
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Implementation Details The base architecture for all the methods consists of a pre-trained AlexNet, whose features are fed into a skill policy network that predicts the location of grasp, direction of displacement, and the magnitude of displacement. For the forward regularizer baseline, a forward model is trained to jointly regularize the AlexNet features along with the skill policy network with loss weight of forward model set to 0.1. For our proposed forward-consistent GSP, a forward consistency loss is then applied to the actions predicted by the skill policy network. The forward consistency loss weight is set to 0.1. Since this is a fully observed setup, we did not use recurrence in any of the skill policy networks. All the models are optimized using Adam (Kingma & Ba, 2015) with a learning rate of $1 e - 4$ . For the first 40K iterations, the AlexNet weights were frozen, and then fine-tuned jointly with the later layers. ",
+        "bbox": [
+            174,
+            267,
+            825,
+            406
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "A.2 NAVIGATION IN INDOOR OFFICE ENVIRONMENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            422,
+            560,
+            438
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Robotic Setup We used the TurtleBot2 robot comprising of a wheeled Kobuki base and an Orbbec Astra camera for capturing RGB images for all our experiments. The robot’s action space had four discrete actions: move forward, turn left, turn right, and stand still (i.e., no-op). The forward action is approximately $1 0 \\mathrm { c m }$ forward translation and the turning actions are approximately 14-18 degrees of rotation. These numbers vary due to the use of velocity control. A powerful on-board laptop was used to process the images and infer the motor commands. Several modifications were made to the default TurtleBot setup: the base’s batteries were replaced with longer lasting ones, and the default NVIDIA Jetson TK1 embedded board was replaced with a more powerful GigaByte Aero laptop and an accompanying portable charging power bank. ",
+        "bbox": [
+            174,
+            449,
+            825,
+            574
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Self-supervised Data Collection We devised an automated self-supervised scheme for data collection which does not require any human supervision. In our scheme, the robot first samples one out of four actions and then the number of times to repeat the selected action (i.e. action repeat). The no-op action is sampled with probability 0.05 and the other three actions are sampled with equal probability. In case the no-op action is chosen, an action repeat of $\\{ 1 , 2 \\}$ steps is uniformly sampled. In case of other actions, an action repeat of 1-5 steps is randomly and uniformly chosen. The robot autonomously repeated this process and collected 230K interactions from two floors of an academic building. If the robot crashes into an object, it performs a reset maneuver by first moving backwards and then turning right/left by a uniformly sampled angle between 90-270 degrees. A separate floor of the building with substantially different furniture layout and visual textures is then used for testing the learned model. ",
+        "bbox": [
+            174,
+            582,
+            825,
+            733
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Implementation Details The data collected by self-supervised exploration is then used to train our recurrent forward-consistent GSP. The base architecture of our model is an ImageNet pre-trained ResNet-50 (He et al., 2016) network. Input are the images and output are the actions of robot. The forward consistency model is first pre-trained and then fine-tuned together end-to-end with the GSP. The loss weight of the forward model is 0.1, and the objective is minimized using Adam (Kingma & Ba, 2015) with learning rate of $5 e - 4$ . ",
+        "bbox": [
+            174,
+            741,
+            825,
+            824
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "A.3 3D NAVIGATION IN VIZDOOM ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            842,
+            428,
+            856
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Self-supervised Data Collection Our environment consists of two map. One map is used for training and validation, with different textures for validation. Second map has different textures than training and validation and is used for generalization experiments. For both curiosity and random exploration, we collect a total of 1.5 million frames each with action repeat of 4 collected in the standard DoomMyWayHome map used for training in Pathak et al. (2017). $\\sim \\textstyle { \\frac { 2 } { 3 } }$ of the data comes from random-room resets, and $\\sim \\frac { 1 } { 3 }$ of the data comes from a fixed-room reset (i.e, room number 10). The curiosity policy was half sampled and half greedy with the exact split being $40 \\%$ greedy policy random-room reset, $2 5 \\%$ sample policy random-room reset, $2 5 \\%$ sample policy fixed-room reset, and $10 \\%$ greedy policy fixed-room reset. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            922
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/13c8a8a5e5a57f8b98178c209c9fe8410c5e949ef7a24dbeb3a43da4e0808836.jpg",
+        "table_caption": [
+            "Table 4: Quantitative evaluation of TurtleBot’s performance at following visual demonstrations in two conditions: maze and the loop. The fraction denotes how many landmarks it reaches out of the total number of landmarks in the full demonstration. The bracketed number represents the number of actions the agent took to reach its farthest landmark. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Model Name</td><td colspan=\"3\">Maze Runs - Optimal Steps: 100</td><td colspan=\"3\">Loop Runs - Optimal Steps: 85</td></tr><tr><td>Run-1</td><td>Run-2</td><td>Run-3</td><td>Run-1</td><td>Run-2</td><td>Run-3</td></tr><tr><td>SIFT</td><td>2/20 (10)</td><td>1/20 (9)</td><td>3/20 (38)</td><td>一</td><td>1</td><td>1</td></tr><tr><td>GSP-NoPrevAction-NoFwdConst</td><td>12/20 (109)</td><td>14/20 (184)</td><td>20/20 (263)</td><td></td><td></td><td></td></tr><tr><td>GSP-NoFwdConst</td><td>13/20 (147)</td><td>18/20 (325)</td><td>20/20 (166)</td><td>0/17 (0)</td><td>0/17 (0)</td><td>0/17 (0)</td></tr><tr><td>GSP (ours)</td><td>20/20 (353)</td><td>12/20 (194)</td><td>20/20 (168)</td><td>0/17 (0)</td><td>17/17 (243)</td><td>17/17 (165)</td></tr></table>",
+        "bbox": [
+            173,
+            101,
+            825,
+            188
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "table",
+        "img_path": "images/252de2c5ce6451b36efb6827e3a71a283634b337e7664643620d8df4c65e8355.jpg",
+        "table_caption": [
+            "Table 5: Quantitative evaluation of our proposed GSP and the baseline models at following visual demonstrations in VizDoom 3D Navigation. Means and standard errors are reported for demonstration completion and efficiency over 50 seeds and 5 human paths per environment type. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model Name</td><td>Same Map,Same Texture Mean %</td><td>Efficiency %</td><td>Same Map,Diff Texture Mean %</td><td>Efficiency %</td><td>Diff Map,Diff Texture Mean %</td><td>Efficiency %</td></tr><tr><td colspan=\"7\">Random Exploration for Data Collection:</td></tr><tr><td>GSP-NoFwdConst</td><td>61.8 ± 0.9</td><td>60.4 ± 2.1</td><td>37.6 ± 0.7</td><td>68.6 ± 2.5</td><td>42.2 ± 0.8</td><td>50.6 ± 1.9</td></tr><tr><td>GSP (ours pixels)</td><td>61.0 ± 1.0</td><td>68.0± 2.2</td><td>38.1 ± 0.7</td><td>69.1 ± 2.5</td><td>40.3 ± 0.9</td><td>64.2 ± 2.3</td></tr><tr><td>GSP (ours features)</td><td>62.0 ± 1.0</td><td>75.8 ± 2.5</td><td>37.0 ± 0.7</td><td>87.1 ± 2.8</td><td>48.7 ± 0.9</td><td>52.5 ± 1.8</td></tr><tr><td colspan=\"7\">Curiosity-driven Exploration for Data Collection:</td></tr><tr><td>GSP-NoFwdConst</td><td>70.7 ± 0.9</td><td>66.9 ± 1.4</td><td>49.8 ± 0.8</td><td>55.8 ± 2.2</td><td>51.2 ±1.0</td><td>39.5 ± 1.3</td></tr><tr><td>GSP-FwdRegularizer</td><td>70.6 ± 0.9</td><td>67.9 ± 1.6</td><td>51.9 ± 0.8</td><td>49.3 ± 1.6</td><td>48.3 ± 1.0</td><td>49.3 ± 1.8</td></tr><tr><td>GSP (ours pixels)</td><td>71.0 ± 0.9</td><td>73.1 ± 2.7</td><td>53.3 ± 0.9</td><td>53.4 ± 2.0</td><td>52.2 ± 1.0</td><td>44.0 ± 1.5</td></tr><tr><td>GSP (ours features)</td><td>68.8 ±1.0</td><td>72.0 ± 1.7</td><td>53.2 ±0.8</td><td>53.0 ± 2.3</td><td>52.8 ± 0.9</td><td>37.7 ± 1.3</td></tr></table>",
+        "bbox": [
+            174,
+            267,
+            826,
+            428
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            506,
+            825,
+            579
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "For each scenario, we collect 5 human demonstrations each and give every 10th frame as input to the agent for the task of visual imitation. For each human path, we evaluate on 50 different seeds where the agent starts with a uniformly sampled orientation. We then get the median across 250 (50x5) total runs for each type of environment and report median of the percentage of the human path reached by the agent and how soon it got to that point relative to the human. ",
+        "bbox": [
+            174,
+            585,
+            825,
+            656
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "In the main paper, we report median accuracy and the confidence interval for median 2. Since the initial position of the agent is randomized in orientation compared to the one in visual demonstration, the mean results suffer from high variance due to outliers. Hence, median accuracy results in a more reliable metric. However, we report mean results in Table 5 for the completion. ",
+        "bbox": [
+            174,
+            662,
+            825,
+            718
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Implementation Details All models were trained with batch size 64, Adam Solver with 1e-4 learning rate, and landmark slices uniformly sampled between 5 to 15 action steps for each batch. The observations are $4 2 \\mathbf { x } 4 2$ resolution, grayscale images with only one-time channel both for goal and current state. All models used the same goal recognizer that was trained on the curiosity data. For selecting the hyper-parameters in forward regularizer, pixel-based forward consistency, and featurebased forward consistency models, we selected the best loss coefficient among $\\{ 0 . 0 1 , 0 . 0 5 , 0 . 1 \\}$ that achieved the highest median completion on our validation environment which consisted of the training maps with novel textures. ",
+        "bbox": [
+            173,
+            724,
+            825,
+            837
+        ],
+        "page_idx": 15
+    }
+]

parse/train/HyzdRiR9Y7/HyzdRiR9Y7.md

@@ -0,0 +1,444 @@
+# UNIVERSAL TRANSFORMERS
+
+Mostafa Dehghani∗† University of Amsterdam dehghani@uva.nl
+
+Stephan Gouws∗ DeepMind sgouws@google.com
+
+Oriol Vinyals   
+DeepMind   
+vinyals@google.com
+
+Jakob Uszkoreit Google Brain usz@google.com
+
+Łukasz Kaiser   
+Google Brain   
+lukaszkaiser@google.com
+
+# ABSTRACT
+
+Recurrent neural networks (RNNs) sequentially process data by updating their state with each new data point, and have long been the de facto choice for sequence modeling tasks. However, their inherently sequential computation makes them slow to train. Feed-forward and convolutional architectures have recently been shown to achieve superior results on some sequence modeling tasks such as machine translation, with the added advantage that they concurrently process all inputs in the sequence, leading to easy parallelization and faster training times. Despite these successes, however, popular feed-forward sequence models like the Transformer fail to generalize in many simple tasks that recurrent models handle with ease, e.g. copying strings or even simple logical inference when the string or formula lengths exceed those observed at training time. We propose the Universal Transformer (UT), a parallel-in-time self-attentive recurrent sequence model which can be cast as a generalization of the Transformer model and which addresses these issues. UTs combine the parallelizability and global receptive field of feed-forward sequence models like the Transformer with the recurrent inductive bias of RNNs. We also add a dynamic per-position halting mechanism and find that it improves accuracy on several tasks. In contrast to the standard Transformer, under certain assumptions UTs can be shown to be Turing-complete. Our experiments show that UTs outperform standard Transformers on a wide range of algorithmic and language understanding tasks, including the challenging LAMBADA language modeling task where UTs achieve a new state of the art, and machine translation where UTs achieve a 0.9 BLEU improvement over Transformers on the WMT14 En-De dataset.
+
+# 1 INTRODUCTION
+
+Convolutional and fully-attentional feed-forward architectures like the Transformer have recently emerged as viable alternatives to recurrent neural networks (RNNs) for a range of sequence modeling tasks, notably machine translation (Gehring et al., 2017; Vaswani et al., 2017). These parallel-in-time architectures address a significant shortcoming of RNNs, namely their inherently sequential computation which prevents parallelization across elements of the input sequence, whilst still addressing the vanishing gradients problem as the sequence length gets longer (Hochreiter et al., 2003). The Transformer model in particular relies entirely on a self-attention mechanism (Parikh et al., 2016; Lin et al., 2017) to compute a series of context-informed vector-space representations of the symbols in its input and output, which are then used to predict distributions over subsequent symbols as the model predicts the output sequence symbol-by-symbol. Not only is this mechanism straightforward to parallelize, but as each symbol’s representation is also directly informed by all other symbols’ representations, this results in an effectively global receptive field across the whole sequence. This stands in contrast to e.g. convolutional architectures which typically only have a limited receptive field.
+
+Notably, however, the Transformer with its fixed stack of distinct layers foregoes RNNs’ inductive bias towards learning iterative or recursive transformations. Our experiments indicate that this inductive bias may be crucial for several algorithmic and language understanding tasks of varying complexity: in contrast to models such as the Neural Turing Machine (Graves et al., 2014), the Neural GPU (Kaiser & Sutskever, 2016) or Stack RNNs (Joulin & Mikolov, 2015), the Transformer does not generalize well to input lengths not encountered during training.
+
+![](images/507dd2051da74f742d60f292c7b40056ad899fd54839be5a4b69dae12188a93b.jpg)  
+Figure 1: The Universal Transformer repeatedly refines a series of vector representations for each position of the sequence in parallel, by combining information from different positions using self-attention (see Eqn 2) and applying a recurrent transition function (see Eqn 4) across all time steps $1 \leq t \leq T$ . We show this process over two recurrent time-steps. Arrows denote dependencies between operations. Initially, $\hat { h } ^ { 0 }$ is initialized with the embedding for each symbol in the sequence. $h _ { i } ^ { t }$ represents the representation for input symbol $1 \leq i \leq m$ at recurrent time-step $t$ . With dynamic halting, $T$ is dynamically determined for each position (Section 2.2).
+
+In this paper, we introduce the Universal Transformer $( U T )$ , a parallel-in-time recurrent self-attentive sequence model which can be cast as a generalization of the Transformer model, yielding increased theoretical capabilities and improved results on a wide range of challenging sequence-to-sequence tasks. UTs combine the parallelizability and global receptive field of feed-forward sequence models like the Transformer with the recurrent inductive bias of RNNs, which seems to be better suited to a range of algorithmic and natural language understanding sequence-to-sequence problems. As the name implies, and in contrast to the standard Transformer, under certain assumptions UTs can be shown to be Turing-complete (or “computationally universal”, as shown in Section 4).
+
+In each recurrent step, the Universal Transformer iteratively refines its representations for all symbols in the sequence in parallel using a self-attention mechanism (Parikh et al., 2016; Lin et al., 2017), followed by a transformation (shared across all positions and time-steps) consisting of a depth-wise separable convolution (Chollet, 2016; Kaiser et al., 2017) or a position-wise fully-connected layer (see Fig 1). We also add a dynamic per-position halting mechanism (Graves, 2016), allowing the model to choose the required number of refinement steps for each symbol dynamically, and show for the first time that such a conditional computation mechanism can in fact improve accuracy on several smaller, structured algorithmic and linguistic inference tasks (although it marginally degraded results on MT).
+
+Our strong experimental results show that UTs outperform Transformers and LSTMs across a wide range of tasks. The added recurrence yields improved results in machine translation where UTs outperform the standard Transformer. In experiments on several algorithmic tasks and the bAbI language understanding task, UTs also consistently and significantly improve over LSTMs and the standard Transformer. Furthermore, on the challenging LAMBADA text understanding data set UTs with dynamic halting achieve a new state of the art.
+
+# 2 MODEL DESCRIPTION
+
+# 2.1 THE UNIVERSAL TRANSFORMER
+
+The Universal Transformer (UT; see Fig. 2) is based on the popular encoder-decoder architecture commonly used in most neural sequence-to-sequence models (Sutskever et al., 2014; Cho et al., 2014; Vaswani et al., 2017). Both the encoder and decoder of the UT operate by applying a recurrent neural network to the representations of each of the positions of the input and output sequence, respectively. However, in contrast to most applications of recurrent neural networks to sequential data, the UT does not recur over positions in the sequence, but over consecutive revisions of the vector representations of each position (i.e., over “depth”). In other words, the UT is not computationally bound by the number of symbols in the sequence, but only by the number of revisions made to each symbol’s representation.
+
+In each recurrent time-step, the representation of every position is concurrently (in parallel) revised in two sub-steps: first, using a self-attention mechanism to exchange information across all positions in the sequence, thereby generating a vector representation for each position that is informed by the representations of all other positions at the previous time-step. Then, by applying a transition function (shared across position and time) to the outputs of the self-attention mechanism, independently at each position. As the recurrent transition function can be applied any number of times, this implies that UTs can have variable depth (number of per-symbol processing steps). Crucially, this is in contrast to most popular neural sequence models, including the Transformer (Vaswani et al., 2017) or deep RNNs, which have constant depth as a result of applying a fixed stack of layers. We now describe the encoder and decoder in more detail.
+
+ENCODER: Given an input sequence of length $m$ , we start with a matrix whose rows are initialized as the $d$ -dimensional embeddings of the symbols at each position of the sequence $H ^ { 0 } \in \mathbb { R } ^ { m \times d }$ . The UT then iteratively computes representations $H ^ { t }$ at step $t$ for all $m$ positions in parallel by applying the multi-headed dot-product self-attention mechanism from Vaswani et al. (2017), followed by a recurrent transition function. We also add residual connections around each of these function blocks and apply dropout and layer normalization (Srivastava et al., 2014; Ba et al., 2016) (see Fig. 2 for a simplified diagram, and Fig. 4 in the Appendix A for the complete model.).
+
+More specifically, we use the scaled dot-product attention which combines queries $Q$ , keys $K$ and values $V$ as follows
+
+$$
+\mathrm { A T T E N T I O N } ( Q , K , V ) = \mathrm { S O F T M A X } \left( \frac { Q K ^ { T } } { \sqrt { d } } \right) V ,
+$$
+
+where $d$ is the number of columns of $Q$ , $K$ and $V$ . We use the multi-head version with $k$ heads, as introduced in (Vaswani et al., 2017),
+
+$$
+\begin{array} { r l } & { \mathbf { M U L T I H E A D S E L F A T T E N T I O N } ( H ^ { t } ) = \mathbf { C O N C A T ( h e a d _ { 1 } , . . . , h e a d _ { k } ) } W ^ { O } } \\ & { \qquad \mathrm { w h e r e ~ h e a d _ { i } = A T T E N T I O N } ( H ^ { t } W _ { i } ^ { Q } , H ^ { t } W _ { i } ^ { K } , H ^ { t } W _ { i } ^ { V } ) } \end{array}
+$$
+
+and we map the state $H ^ { t }$ to queries, keys and values with affine projections using learned parameter matrices $\bar { W } ^ { Q } \in \mathbb { R } ^ { d \times d / k }$ , $W ^ { \bar { K } } \in \mathbb { R } ^ { d \times d / \bar { k } }$ , $W ^ { V } \in \mathbb { R } ^ { d \times d / k }$ and $W ^ { O } \in \mathbb { R } ^ { d \times d }$ .
+
+At step $t$ , the UT then computes revised representations $H ^ { t } \in \mathbb { R } ^ { m \times d }$ for all $m$ input positions as follows
+
+$$
+\begin{array} { r l } & { \quad H ^ { t } = \mathrm { L A Y E R N O R M } ( A ^ { t } + \mathrm { T R A N S I T I O N } ( A ^ { t } ) ) } \\ & { \mathrm { e } A ^ { t } = \mathrm { L A Y E R N O R M } ( ( H ^ { t - 1 } + P ^ { t } ) + \mathrm { M U L T I H E A D S E L F A T T E N T I O N } ( H ^ { t - 1 } + P ^ { t } ) ) , } \end{array}
+$$
+
+where LAYERNORM() is defined in Ba et al. (2016), and TRANSITION() and $P ^ { t }$ are discussed below.
+
+Depending on the task, we use one of two different transition functions: either a separable convolution (Chollet, 2016) or a fully-connected neural network that consists of a single rectified-linear activation function between two affine transformations, applied position-wise, i.e. individually to each row of $A ^ { t }$ .
+
+$P ^ { t } \in \mathbb { R } ^ { m \times d }$ above are fixed, constant, two-dimensional (position, time) coordinate embeddings, obtained by computing the sinusoidal position embedding vectors as defined in (Vaswani et al., 2017) for the positions $1 \leq i \leq m$ and the time-step $1 \leq t \leq T$ separately for each vector-dimension $1 \leq j \leq d$ and summing:
+
+$$
+\begin{array} { r } { P _ { i , 2 j } ^ { t } = \sin ( i / 1 0 0 0 0 ^ { 2 j / d } ) + \sin ( t / 1 0 0 0 0 ^ { 2 j / d } ) } \\ { P _ { i , 2 j + 1 } ^ { t } = \cos ( i / 1 0 0 0 0 ^ { 2 j / d } ) + \cos ( t / 1 0 0 0 0 ^ { 2 j / d } ) . } \end{array}
+$$
+
+![](images/921913d43679c74453a009ab5038b5a9fb452c9b7a70037826c1dfb32a69f5b9.jpg)  
+Figure 2: The recurrent blocks of the Universal Transformer encoder and decoder. This diagram omits position and time-step encodings as well as dropout, residual connections and layer normalization. A complete version can be found in Appendix A. The Universal Transformer with dynamic halting determines the number of steps $T$ for each position individually using ACT (Graves, 2016).
+
+After $T$ steps (each updating all positions of the input sequence in parallel), the final output of the Universal Transformer encoder is a matrix of $d$ -dimensional vector representations $H ^ { T } \in \mathbf { \bar { \mathbb { R } } } ^ { m \times d }$ for the $m$ symbols of the input sequence.
+
+DECODER: The decoder shares the same basic recurrent structure of the encoder. However, after the self-attention function, the decoder additionally also attends to the final encoder representation $H ^ { T }$ of each position in the input sequence using the same multihead dot-product attention function from Equation 2, but with queries $Q$ obtained from projecting the decoder representations, and keys and values ( $K$ and $V$ ) obtained from projecting the encoder representations (this process is akin to standard attention (Bahdanau et al., 2014)).
+
+Like the Transformer model, the UT is autoregressive (Graves, 2013). Trained using teacher-forcing, at generation time it produces its output one symbol at a time, with the decoder consuming the previously produced output positions. During training, the decoder input is the target output, shifted to the right by one position. The decoder self-attention distributions are further masked so that the model can only attend to positions to the left of any predicted symbol. Finally, the per-symbol target distributions are obtained by applying an affine transformation $O \in \mathbb { R } ^ { d \times V }$ from the final decoder state to the output vocabulary size $V$ , followed by a softmax which yields an $( m \times V )$ -dimensional output matrix normalized over its rows:
+
+$$
+p \big ( y _ { p o s } | y _ { [ 1 : p o s - 1 ] } , H ^ { T } \big ) = \mathrm { s O F T M A X } ( O H ^ { T } ) ^ { 1 }
+$$
+
+To generate from the model, the encoder is run once for the conditioning input sequence. Then the decoder is run repeatedly, consuming all already-generated symbols, while generating one additional distribution over the vocabulary for the symbol at the next output position per iteration. We then typically sample or select the highest probability symbol as the next symbol.
+
+# 2.2 DYNAMIC HALTING
+
+In sequence processing systems, certain symbols (e.g. some words or phonemes) are usually more ambiguous than others. It is therefore reasonable to allocate more processing resources to these more ambiguous symbols. Adaptive Computation Time (ACT) (Graves, 2016) is a mechanism for dynamically modulating the number of computational steps needed to process each input symbol (called the “ponder time”) in standard recurrent neural networks based on a scalar halting probability predicted by the model at each step.
+
+<table><tr><td rowspan="2">Model</td><td colspan="2">10K examples</td><td colspan="2">1K examples</td></tr><tr><td>train single</td><td>train joint</td><td>train single</td><td>train joint</td></tr><tr><td colspan="5">Previous best results:</td></tr><tr><td>QRNet (Seo et al., 2016)</td><td>0.3 (0/20)</td><td></td><td></td><td></td></tr><tr><td>Sparse DNC (Rae et al.,2016)</td><td></td><td>2.9 (1/20)</td><td></td><td></td></tr><tr><td>GA+MAGE Dhingra et al. (2017)</td><td></td><td></td><td>8.7 (5/20)</td><td></td></tr><tr><td>MemN2N Sukhbaatar et al. (2015)</td><td></td><td></td><td></td><td>12.4 (11/20)</td></tr><tr><td colspan="5">Our Results:</td></tr><tr><td>Transformer (Vaswani et al.,2017)</td><td>15.2 (10/20)</td><td>22.1 (12/20)</td><td>21.8 (5/20)</td><td>26.8 (14/20)</td></tr><tr><td>Universal Transformer (this work)</td><td>0.23 (0/20)</td><td>0.47 (0/20)</td><td>5.31 (5/20)</td><td>8.50 (8/20)</td></tr><tr><td>UT w/ dynamic halting (this work)</td><td>0.21 (0/20)</td><td>0.29 (0/20)</td><td>4.55 (3/20)</td><td>7.78 (5/20)</td></tr></table>
+
+Table 1: Average error and number of failed tasks $( > 5 \%$ error) out of 20 (in parentheses; lower is better in both cases) on the bAbI dataset under the different training/evaluation setups. We indicate state-of-the-art where available for each, or ‘-’ otherwise.
+
+Inspired by the interpretation of Universal Transformers as applying self-attentive RNNs in parallel to all positions in the sequence, we also add a dynamic ACT halting mechanism to each position (i.e. to each per-symbol self-attentive RNN; see Appendix C for more details). Once the per-symbol recurrent block halts, its state is simply copied to the next step until all blocks halt, or we reach a maximum number of steps. The final output of the encoder is then the final layer of representations produced in this way.
+
+# 3 EXPERIMENTS AND ANALYSIS
+
+We evaluated the Universal Transformer on a range of algorithmic and language understanding tasks, as well as on machine translation. We describe these tasks and datasets in more detail in Appendix D.
+
+# 3.1 BABI QUESTION-ANSWERING
+
+The bAbi question answering dataset (Weston et al., 2015) consists of 20 different tasks, where the goal is to answer a question given a number of English sentences that encode potentially multiple supporting facts. The goal is to measure various forms of language understanding by requiring a certain type of reasoning over the linguistic facts presented in each story. A standard Transformer does not achieve good results on this task2. However, we have designed a model based on the Universal Transformer which achieves state-of-the-art results on this task.
+
+To encode the input, similar to Henaff et al. (2016), we first encode each fact in the story by applying a learned multiplicative positional mask to each word’s embedding, and summing up all embeddings. We embed the question in the same way, and then feed the (Universal) Transformer with these embeddings of the facts and questions.
+
+As originally proposed, models can either be trained on each task separately (“train single”) or jointly on all tasks (“train joint”). Table 1 summarizes our results. We conducted 10 runs with different initializations and picked the best model based on performance on the validation set, similar to previous work. Both the UT and UT with dynamic halting achieve state-of-the-art results on all tasks in terms of average error and number of failed tasks3, in both the 10K and 1K training regime (see Appendix E for breakdown by task).
+
+To understand the working of the model better, we analyzed both the attention distributions and the average ACT ponder times for this task (see Appendix F for details). First, we observe that the attention distributions start out very uniform, but get progressively sharper in later steps around the correct supporting facts that are required to answer each question, which is indeed very similar to how humans would solve the task. Second, with dynamic halting we observe that the average ponder time (i.e. depth of the per-symbol recurrent processing chain) over all positions in all samples in the test data for tasks requiring three supporting facts is higher $( 3 . 8 { \pm } 2 . 2 ) $ than for tasks requiring only two $( 3 . 1 { \pm } 1 . 1 ) $ , which is in turn higher than for tasks requiring only one supporting fact $( 2 . 3 { \pm } 0 . 8 ) $ . This indicates that the model adjusts the number of processing steps with the number of supporting facts required to answer the questions. Finally, we observe that the histogram of ponder times at different positions is more uniform in tasks requiring only one supporting fact compared to two and three, and likewise for tasks requiring two compared to three. Especially for tasks requiring three supporting facts, many positions halt at step 1 or 2 already and only a few get transformed for more steps (see for example Fig 3). This is particularly interesting as the length of stories is indeed much higher in this setting, with more irrelevant facts which the model seems to successfully learn to ignore in this way.
+
+![](images/79cd643b79ebf6e2857e1b7faa9e0dfee2764a5ad06f0203090a8a37ddf605ac.jpg)  
+Figure 3: Ponder time of UT with dynamic halting for encoding facts in a story and question in a bAbI task requiring three supporting facts.
+
+Similar to dynamic memory networks (Kumar et al., 2016), there is an iterative attention process in UTs that allows the model to condition its attention over memory on the result of previous iterations. Appendix F presents some examples illustrating that there is a notion of temporal states in UT, where the model updates its states (memory) in each step based on the output of previous steps, and this chain of updates can also be viewed as steps in a multi-hop reasoning process.
+
+# 3.2 SUBJECT-VERB AGREEMENT
+
+Next, we consider the task of predicting number-agreement between subjects and verbs in English sentences (Linzen et al., 2016). This task acts as a proxy for measuring the ability of a model to capture hierarchical (dependency) structure in natural language sentences. We use the dataset provided by (Linzen et al., 2016) and follow their experimental protocol of solving the task using a language modeling training setup, i.e. a next word prediction objective, followed by calculating the ranking accuracy of the target verb at test time. We evaluated our model on subsets of the test data with different task difficulty, measured in terms of agreement attractors – the number of intervening nouns with the opposite number from the subject (meant to confuse the model). For example, given the sentence The keys to the cabinet4, the objective during training is to predict the verb are (plural). At test time, we then evaluate the ranking accuracy of the agreement attractors: i.e. the goal is to rank are higher than is in this case.
+
+Our results are summarized in Table 2. The best LSTM with attention from the literature achieves $9 9 . 1 8 \%$ on this task (Yogatama et al., 2018), outperforming a vanilla Transformer (Tran et al., 2018). UTs significantly outperform standard Transformers, and achieve an average result comparable to the current state of the art $( 9 9 . 2 \% )$ . However, we see that UTs (and particularly with dynamic halting) perform progressively better than all other models as the number of attractors increases (see the last row, $\Delta$ ).
+
+# 3.3 LAMBADA LANGUAGE MODELING
+
+The LAMBADA task (Paperno et al., 2016) is a language modeling task consisting of predicting a missing target word given a broader context of 4-5 preceding sentences. The dataset was specifically designed so that humans are able to accurately predict the target word when shown the full context, but not when only shown the target sentence in which it appears. It therefore goes beyond language modeling, and tests the ability of a model to incorporate broader discourse and longer term context when predicting the target word.
+
+<table><tr><td rowspan="2">Model</td><td colspan="7">Number of attractors</td><td rowspan="2">Total</td></tr><tr><td>0</td><td>1</td><td>2</td><td>3</td><td>4</td><td>5</td></tr><tr><td colspan="9">Previous best results (Yogatama et al., 2018):</td></tr><tr><td>Best Stack-RNN</td><td>0.994</td><td>0.979</td><td>0.965</td><td>0.935</td><td>0.916</td><td>0.880</td><td></td><td>0.992</td></tr><tr><td>Best LSTM</td><td>0.993</td><td>0.972</td><td>0.950</td><td></td><td>0.922</td><td>0.900</td><td>0.842</td><td>0.991</td></tr><tr><td>Best Attention</td><td>0.994</td><td>0.977</td><td>0.959</td><td></td><td>0.929</td><td>0.907</td><td>0.842</td><td>0.992</td></tr><tr><td colspan="9">Our results:</td></tr><tr><td>Transformer</td><td>0.973</td><td>0.941</td><td>0.932</td><td></td><td>0.917</td><td>0.901</td><td>0.883</td><td>0.962</td></tr><tr><td>Universal Transformer</td><td>0.993</td><td>0.971</td><td>0.969</td><td></td><td>0.940</td><td>0.921</td><td>0.892</td><td>0.992</td></tr><tr><td>UT w/ ACT</td><td>0.994</td><td>0.969</td><td>0.967</td><td></td><td>0.944</td><td>0.932</td><td>0.907</td><td>0.992</td></tr><tr><td>△(UT w/ACT- Best)</td><td>0</td><td>-0.008</td><td>0.002</td><td></td><td>0.009</td><td>0.016</td><td>0.027</td><td>-</td></tr></table>
+
+Table 2: Accuracy on the subject-verb agreement number prediction task (higher is better).   
+
+<table><tr><td rowspan="2">Model</td><td colspan="3">LM Perplexity &amp; (Accuracy)</td><td colspan="3">RC Accuracy</td></tr><tr><td>control</td><td>dev</td><td>test</td><td>control</td><td>dev</td><td>test</td></tr><tr><td>Neural Cache (Grave et al.,2016) Dhingra et al. Dhingra et al. (2018)</td><td>129 1</td><td>139 1</td><td></td><td></td><td></td><td>- 0.5569</td></tr><tr><td>Transformer</td><td>142 (0.19)</td><td>5122 (0.0)</td><td>7321 (0.0)</td><td>0.4102</td><td>0.4401</td><td>0.3988</td></tr><tr><td>LSTM</td><td>138 (0.23)</td><td>4966 (0.0)</td><td>5174 (0.0)</td><td>0.1103</td><td>0.2316</td><td>0.2007</td></tr><tr><td>UT base,6 steps (fixed)</td><td>131 (0.32)</td><td>279 (0.18)</td><td>319 (0.17)</td><td>0.4801</td><td>0.5422</td><td>0.5216</td></tr><tr><td>UT w/ dynamic halting</td><td>130 (0.32)</td><td>134 (0.22)</td><td>142 (0.19)</td><td>0.4603</td><td>0.5831</td><td>0.5625</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>UT base,8 steps (fixed) UT base,9 steps (fixed)</td><td>129(0.32) 129(0.33)</td><td>192 (0.21) 214 (0.21)</td><td>202 (0.18) 239 (0.17)</td><td></td><td></td><td></td></tr></table>
+
+Table 3: LAMBADA language modeling (LM) perplexity (lower better) with accuracy in parentheses (higher better), and Reading Comprehension (RC) accuracy results (higher better). ‘-’ indicates no reported results in that setting.
+
+The task is evaluated in two settings: as language modeling (the standard setup) and as reading comprehension. In the former (more challenging) case, a model is simply trained for next-word prediction on the training data, and evaluated on the target words at test time (i.e. the model is trained to predict all words, not specifically challenging target words). In the latter setting, introduced by Chu et al. Chu et al. (2017), the target sentence (minus the last word) is used as query for selecting the target word from the context sentences. Note that the target word appears in the context $81 \%$ of the time, making this setup much simpler. However the task is impossible in the remaining $19 \%$ of the cases.
+
+The results are shown in Table 3. Universal Transformer achieves state-of-the-art results in both the language modeling and reading comprehension setup, outperforming both LSTMs and vanilla Transformers. Note that the control set was constructed similar to the LAMBADA development and test sets, but without filtering them in any way, so achieving good results on this set shows a model’s strength in standard language modeling.
+
+Our best fixed UT results used 6 steps. However, the average number of steps that the best UT with dynamic halting took on the test data over all positions and examples was $8 . 2 { \pm } 2 . 1 $ . In order to see if the dynamic model did better simply because it took more steps, we trained two fixed UT models with 8 and 9 steps respectively (see last two rows). Interestingly, these two models achieve better results compared to the model with 6 steps, but do not outperform the UT with dynamic halting. This leads us to believe that dynamic halting may act as a useful regularizer for the model via incentivizing a smaller numbers of steps for some of the input symbols, while allowing more computation for others.
+
+# 3.4 ALGORITHMIC TASKS
+
+We trained UTs on three algorithmic tasks, namely Copy, Reverse, and (integer) Addition, all on strings composed of decimal symbols $( ^ { \cdot } 0 ^ { \cdot } - ^ { \cdot } 9 ^ { \cdot } )$ . In all the experiments, we train the models on sequences of length 40 and evaluated on sequences of length 400 (Kaiser & Sutskever, 2016). We train UTs using positions starting with randomized offsets to further encourage the model to learn position-relative transformations. Results are shown in Table 4. The UT outperforms both LSTM and vanilla Transformer by a wide margin on all three tasks. The Neural GPU reports perfect results on this task (Kaiser & Sutskever, 2016), however we note that this result required a special curriculum-based training protocol which was not used for other models.
+
+Table 4: Accuracy (higher better) on the algorithmic tasks. ∗Note that the Neural GPU was trained with a special curriculum to obtain the perfect result, while other models are trained without any curriculum.   
+
+<table><tr><td rowspan="2">Model</td><td colspan="2">Copy</td><td colspan="2">Reverse</td><td colspan="2">Addition</td></tr><tr><td>char-acc</td><td>seq-acc</td><td>char-acc</td><td>seq-acc</td><td>char-acc</td><td>seq-acc</td></tr><tr><td>LSTM</td><td>0.45</td><td>0.09</td><td>0.66</td><td>0.11</td><td>0.08</td><td>0.0</td></tr><tr><td>Transformer</td><td>0.53</td><td>0.03</td><td>0.13</td><td>0.06</td><td>0.07</td><td>0.0</td></tr><tr><td>Universal Transformer</td><td>0.91</td><td>0.35</td><td>0.96</td><td>0.46</td><td>0.34</td><td>0.02</td></tr><tr><td>Neural GPU*</td><td>1.0</td><td>1.0</td><td>1.0</td><td>1.0</td><td>1.0</td><td>1.0</td></tr></table>
+
+Table 5: Character-level (char-acc) and sequence-level accuracy (seq-acc) results on the Memorization LTE tasks, with maximum length of 55.   
+
+<table><tr><td></td><td colspan="2">Copy</td><td colspan="2">Double</td><td colspan="2">Reverse</td></tr><tr><td>Model</td><td>char-acc</td><td>seq-acc</td><td>char-acc</td><td>seq-acc</td><td>char-acc</td><td>seq-acc</td></tr><tr><td>LSTM</td><td>0.78</td><td>0.11</td><td>0.51</td><td>0.047</td><td>0.91</td><td>0.32</td></tr><tr><td>Transformer</td><td>0.98</td><td>0.63</td><td>0.94</td><td>0.55</td><td>0.81</td><td>0.26</td></tr><tr><td>Universal Transformer</td><td>1.0</td><td>1.0</td><td>1.0</td><td>1.0</td><td>1.0</td><td>1.0</td></tr></table>
+
+<table><tr><td></td><td colspan="2">Program</td><td colspan="2">Control</td><td colspan="2">Addition</td></tr><tr><td>Model</td><td>char-acc</td><td>seq-acc</td><td>char-acc</td><td>seq-acc</td><td>char-acc</td><td>seq-acc</td></tr><tr><td>LSTM</td><td>0.53</td><td>0.12</td><td>0.68</td><td>0.21</td><td>0.83</td><td>0.11</td></tr><tr><td>Transformer</td><td>0.71</td><td>0.29</td><td>0.93</td><td>0.66</td><td>1.0</td><td>1.0</td></tr><tr><td>Universal Transformer</td><td>0.89</td><td>0.63</td><td>1.0</td><td>1.0</td><td>1.0</td><td>1.0</td></tr></table>
+
+Table 6: Character-level (char-acc) and sequence-level accuracy (seq-acc) results on the Program Evaluation LTE tasks with maximum nesting of 2 and length of 5.
+
+# 3.5 LEARNING TO EXECUTE (LTE)
+
+As another class of sequence-to-sequence learning problems, we also evaluate UTs on tasks indicating the ability of a model to learn to execute computer programs, as proposed in (Zaremba & Sutskever, 2015). These tasks include program evaluation tasks (program, control, and addition), and memorization tasks (copy, double, and reverse).
+
+We use the mix-strategy discussed in (Zaremba & Sutskever, 2015) to generate the datasets. Unlike (Zaremba & Sutskever, 2015), we do not use any curriculum learning strategy during training and we make no use of target sequences at test time. Tables 5 and 6 present the performance of an LSTM model, Transformer, and Universal Transformer on the program evaluation and memorization tasks, respectively. UT achieves perfect scores in all the memorization tasks and also outperforms both LSTMs and Transformers in all program evaluation tasks by a wide margin.
+
+# 3.6 MACHINE TRANSLATION
+
+We trained a UT on the WMT 2014 English-German translation task using the same setup as reported in (Vaswani et al., 2017) in order to evaluate its performance on a large-scale sequence-to-sequence task. Results are summarized in Table 7. The UT with a fully-connected recurrent transition function (instead of separable convolution) and without ACT improves by 0.9 BLEU over a Transformer and 0.5 BLEU over a Weighted Transformer with approximately the same number of parameters (Ahmed et al., 2017).
+
+<table><tr><td>Model</td><td>BLEU</td></tr><tr><td>Universal Transformer small</td><td>26.8</td></tr><tr><td>Transformer base (Vaswani et al.,2017)</td><td>28.0</td></tr><tr><td>Weighted Transformer base (Ahmed etal.,2017)</td><td>28.4</td></tr><tr><td>Universal Transformer base</td><td>28.9</td></tr></table>
+
+Table 7: Machine translation results on the WMT14 En-De translation task trained on 8xP100 GPUs in comparable training setups. All base results have the same number of parameters.
+
+# 4 DISCUSSION
+
+When running for a fixed number of steps, the Universal Transformer is equivalent to a multi-layer Transformer with tied parameters across all its layers. This is partly similar to the Recursive Transformer, which ties the weights of its self-attention layers across depth (Gulcehre et al., 2018)5. However, as the per-symbol recurrent transition functions can be applied any number of times, another and possibly more informative way of characterizing the UT is as a block of parallel RNNs (one for each symbol, with shared parameters) evolving per-symbol hidden states concurrently, generated at each step by attending to the sequence of hidden states at the previous step. In this way, it is related to architectures such as the Neural GPU (Kaiser & Sutskever, 2016) and the Neural Turing Machine (Graves et al., 2014). UTs thereby retain the attractive computational efficiency of the original feedforward Transformer model, but with the added recurrent inductive bias of RNNs. Furthermore, using a dynamic halting mechanism, UTs can choose the number of processing steps based on the input data.
+
+The connection between the Universal Transformer and other sequence models is apparent from the architecture: if we limited the recurrent steps to one, it would be a Transformer. But it is more interesting to consider the relationship between the Universal Transformer and RNNs and other networks where recurrence happens over the time dimension. Superficially these models may seem closely related since they are recurrent as well. But there is a crucial difference: time-recurrent models like RNNs cannot access memory in the recurrent steps. This makes them computationally more similar to automata, since the only memory available in the recurrent part is a fixed-size state vector. UTs on the other hand can attend to the whole previous layer, allowing it to access memory in the recurrent step.
+
+Given sufficient memory the Universal Transformer is computationally universal – i.e. it belongs to the class of models that can be used to simulate any Turing machine, thereby addressing a shortcoming of the standard Transformer model 6. In addition to being theoretically appealing, our results show that this added expressivity also leads to improved accuracy on several challenging sequence modeling tasks. This closes the gap between practical sequence models competitive on large-scale tasks such as machine translation, and computationally universal models such as the Neural Turing Machine or the Neural GPU (Graves et al., 2014; Kaiser & Sutskever, 2016), which can be trained using gradient descent to perform algorithmic tasks.
+
+To show this, we can reduce a Neural GPU to a Universal Transformer. Ignoring the decoder and parameterizing the self-attention module, i.e. self-attention with the residual connection, to be the identity function, we assume the transition function to be a convolution. If we now set the total number of recurrent steps $T$ to be equal to the input length, we obtain exactly a Neural GPU. Note that the last step is where the Universal Transformer crucially differs from the vanilla Transformer whose depth cannot scale dynamically with the size of the input. A similar relationship exists between the Universal Transformer and the Neural Turing Machine, whose single read/write operations per step can be expressed by the global, parallel representation revisions of the Universal Transformer. In contrast to these models, however, which only perform well on algorithmic tasks, the Universal Transformer also achieves competitive results on realistic natural language tasks such as LAMBADA and machine translation.
+
+Another related model architecture is that of end-to-end Memory Networks (Sukhbaatar et al., 2015). In contrast to end-to-end memory networks, however, the Universal Transformer uses memory corresponding to states aligned to individual positions of its inputs or outputs. Furthermore, the Universal Transformer follows the encoder-decoder configuration and achieves competitive performance in large-scale sequence-to-sequence tasks.
+
+# 5 CONCLUSION
+
+This paper introduces the Universal Transformer, a generalization of the Transformer model that extends its theoretical capabilities and produces state-of-the-art results on a wide range of challenging sequence modeling tasks, such as language understanding but also a variety of algorithmic tasks, thereby addressing a key shortcoming of the standard Transformer. The Universal Transformer combines the following key properties into one model:
+
+Weight sharing: Following intuitions behind weight sharing found in CNNs and RNNs, we extend the Transformer with a simple form of weight sharing that strikes an effective balance between inductive bias and model expressivity, which we show extensively on both small and large-scale experiments.
+
+Conditional computation: In our goal to build a computationally universal machine, we equipped the Universal Transformer with the ability to halt or continue computation through a recently introduced mechanism, which shows stronger results compared to the fixed-depth Universal Transformer.
+
+We are enthusiastic about the recent developments on parallel-in-time sequence models. By adding computational capacity and recurrence in processing depth, we hope that further improvements beyond the basic Universal Transformer presented here will help us build learning algorithms that are both more powerful, data efficient, and generalize beyond the current state-of-the-art.
+
+The code used to train and evaluate Universal Transformers is available at https: //github.com/tensorflow/tensor2tensor (Vaswani et al., 2018).
+
+Acknowledgements We are grateful to Ashish Vaswani, Douglas Eck, and David Dohan for their fruitful comments and inspiration.
+
+# REFERENCES
+
+Karim Ahmed, Nitish Shirish Keskar, and Richard Socher. Weighted transformer network for machine translation. arXiv preprint arXiv:1711.02132, 2017.   
+Jimmy Lei Ba, Jamie Ryan Kiros, and Geoffrey E Hinton. Layer normalization. arXiv preprint arXiv:1607.06450, 2016. URL http://arxiv.org/abs/1607.06450.   
+Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. CoRR, abs/1409.0473, 2014. URL http://arxiv.org/abs/1409.0473.   
+Kyunghyun Cho, Bart van Merrienboer, Caglar Gulcehre, Fethi Bougares, Holger Schwenk, and Yoshua Bengio. Learning phrase representations using RNN encoder-decoder for statistical machine translation. CoRR, abs/1406.1078, 2014. URL http://arxiv.org/abs/1406.1078.   
+Francois Chollet. Xception: Deep learning with depthwise separable convolutions. arXiv preprint arXiv:1610.02357, 2016.   
+Zewei Chu, Hai Wang, Kevin Gimpel, and David McAllester. Broad context language modeling as reading comprehension. In Proceedings of the 15th Conference of the European Chapter of the Association for Computational Linguistics: Volume 2, Short Papers, volume 2, pp. 52–57, 2017.   
+Bhuwan Dhingra, Zhilin Yang, William W Cohen, and Ruslan Salakhutdinov. Linguistic knowledge as memory for recurrent neural networks. arXiv preprint arXiv:1703.02620, 2017.   
+Bhuwan Dhingra, Qiao Jin, Zhilin Yang, William W Cohen, and Ruslan Salakhutdinov. Neural models for reasoning over multiple mentions using coreference. arXiv preprint arXiv:1804.05922, 2018.   
+Jonas Gehring, Michael Auli, David Grangier, Denis Yarats, and Yann N. Dauphin. Convolutional sequence to sequence learning. CoRR, abs/1705.03122, 2017. URL http://arxiv.org/abs/1705.03122.   
+Edouard Grave, Armand Joulin, and Nicolas Usunier. Improving neural language models with a continuous cache. arXiv preprint arXiv:1612.04426, 2016.   
+Alex Graves. Generating sequences with recurrent neural networks. CoRR, abs/1308.0850, 2013. URL http://arxiv.org/abs/1308.0850.   
+Alex Graves. Adaptive computation time for recurrent neural networks. arXiv preprint arXiv:1603.08983, 2016.   
+Alex Graves, Greg Wayne, and Ivo Danihelka. Neural turing machines. CoRR, abs/1410.5401, 2014. URL http://arxiv.org/abs/1410.5401.   
+Caglar Gulcehre, Misha Denil, Mateusz Malinowski, Ali Razavi, Razvan Pascanu, Karl Moritz Hermann, Peter Battaglia, Victor Bapst, David Raposo, Adam Santoro, et al. Hyperbolic attention networks. arXiv preprint arXiv:1805.09786, 2018.   
+Mikael Henaff, Jason Weston, Arthur Szlam, Antoine Bordes, and Yann LeCun. Tracking the world state with recurrent entity networks. arXiv preprint arXiv:1612.03969, 2016.   
+Sepp Hochreiter, Yoshua Bengio, Paolo Frasconi, and Jürgen Schmidhuber. Gradient flow in recurrent nets: the difficulty of learning long-term dependencies. A Field Guide to Dynamical Recurrent Neural Networks, 2003.   
+A. Joulin and T. Mikolov. Inferring algorithmic patterns with stack-augmented recurrent nets. In Advances in Neural Information Processing Systems, (NIPS), 2015.   
+Łukasz Kaiser and Ilya Sutskever. Neural GPUs learn algorithms. In International Conference on Learning Representations (ICLR), 2016. URL https://arxiv.org/abs/1511.08228.   
+Łukasz Kaiser, Aidan N. Gomez, and Francois Chollet. Depthwise separable convolutions for neural machine translation. CoRR, abs/1706.03059, 2017. URL http://arxiv.org/abs/1706.03059.   
+Ankit Kumar, Ozan Irsoy, Peter Ondruska, Mohit Iyyer, James Bradbury, Ishaan Gulrajani, Victor Zhong, Romain Paulus, and Richard Socher. Ask me anything: Dynamic memory networks for natural language processing. In International Conference on Machine Learning, pp. 1378–1387, 2016.   
+Zhouhan Lin, Minwei Feng, Cicero Nogueira dos Santos, Mo Yu, Bing Xiang, Bowen Zhou, and Yoshua Bengio. A structured self-attentive sentence embedding. arXiv preprint arXiv:1703.03130, 2017.   
+Tal Linzen, Emmanuel Dupoux, and Yoav Goldberg. Assessing the ability of lstms to learn syntax-sensitive dependencies. Transactions of the Association of Computational Linguistics, 4(1):521–535, 2016.   
+Denis Paperno, Germán Kruszewski, Angeliki Lazaridou, Ngoc Quan Pham, Raffaella Bernardi, Sandro Pezzelle, Marco Baroni, Gemma Boleda, and Raquel Fernandez. The lambada dataset: Word prediction requiring a broad discourse context. In Proceedings of the 54th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), volume 1, pp. 1525–1534, 2016.   
+Ankur Parikh, Oscar Täckström, Dipanjan Das, and Jakob Uszkoreit. A decomposable attention model. In Empirical Methods in Natural Language Processing, 2016. URL https: //arxiv.org/pdf/1606.01933.pdf.   
+Jack Rae, Jonathan J Hunt, Ivo Danihelka, Timothy Harley, Andrew W Senior, Gregory Wayne, Alex Graves, and Tim Lillicrap. Scaling memory-augmented neural networks with sparse reads and writes. In Advances in Neural Information Processing Systems, pp. 3621–3629, 2016.   
+Minjoon Seo, Sewon Min, Ali Farhadi, and Hannaneh Hajishirzi. Query-reduction networks for question answering. arXiv preprint arXiv:1606.04582, 2016.   
+Nitish Srivastava, Geoffrey E Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: a simple way to prevent neural networks from overfitting. Journal of Machine Learning Research, 15(1): 1929–1958, 2014.   
+Sainbayar Sukhbaatar, arthur szlam, Jason Weston, and Rob Fergus. End-to-end memory networks. In C. Cortes, N. D. Lawrence, D. D. Lee, M. Sugiyama, and R. Garnett (eds.), Advances in Neural Information Processing Systems 28, pp. 2440–2448. Curran Associates, Inc., 2015. URL http://papers.nips.cc/paper/5846-end-to-end-memory-networks.pdf.   
+Ilya Sutskever, Oriol Vinyals, and Quoc V. Le. Sequence to sequence learning with neural networks. In Advances in Neural Information Processing Systems, pp. 3104–3112, 2014. URL http://arxiv.org/abs/1409.3215.   
+Ke Tran, Arianna Bisazza, and Christof Monz. The importance of being recurrent for modeling hierarchical structure. In Proceedings of NAACL’18, 2018.   
+Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Lukasz Kaiser, and Illia Polosukhin. Attention is all you need. CoRR, 2017. URL http://arxiv.org/abs/1706.03762.   
+Ashish Vaswani, Samy Bengio, Eugene Brevdo, Francois Chollet, Aidan N. Gomez, Stephan Gouws, Llion Jones, Łukasz Kaiser, Nal Kalchbrenner, Niki Parmar, Ryan Sepassi, Noam Shazeer, and Jakob Uszkoreit. Tensor2tensor for neural machine translation. CoRR, abs/1803.07416, 2018.
+
+Jason Weston, Antoine Bordes, Sumit Chopra, Alexander M Rush, Bart van Merriënboer, Armand Joulin, and Tomas Mikolov. Towards ai-complete question answering: A set of prerequisite toy tasks. arXiv preprint arXiv:1502.05698, 2015.
+
+Dani Yogatama, Yishu Miao, Gabor Melis, Wang Ling, Adhiguna Kuncoro, Chris Dyer, and Phil Blunsom. Memory architectures in recurrent neural network language models. In International Conference on Learning Representations, 2018. URL https://openreview.net/forum?id $\underline { { \underline { { \mathbf { \Pi } } } } } =$ SkFqf0lAZ.
+
+Wojciech Zaremba and Ilya Sutskever. Learning to execute. CoRR, abs/1410.4615, 2015. URL http://arxiv.org/abs/1410.4615.
+
+![](images/5f564a4ed338c4ad846f158feb7380a4bf03826b912138eb324e8a3f5e31016b.jpg)  
+Figure 4: The Universal Transformer with position and step embeddings as well as dropout and layer normalization.
+
+# APPENDIX B ON THE COMPUTATIONAL POWER OF UT VS TRANSFORMER
+
+With respect to their computational power, the key difference between the Transformer and the Universal Transformer lies in the number of sequential steps of computation (i.e. in depth). While a standard Transformer executes a total number of operations that scales with the input size, the number of sequential operations is constant, independent of the input size and determined solely by the number of layers. Assuming finite precision, this property implies that the standard Transformer cannot be computationally universal. When choosing a number of steps as a function of the input length, however, the Universal Transformer does not suffer from this limitation. Note that this holds independently of whether or not adaptive computation time is employed but does assume a non-constant, even if possibly deterministic, number of steps. Varying the number of steps dynamically after training is enabled by sharing weights across sequential computation steps in the Universal Transformer.
+
+An intuitive example are functions whose execution requires the sequential processing of each input element. In this case, for any given choice of depth $T$ , one can construct an input sequence of length $N > T$ that cannot be processed correctly by a standard Transformer. With an appropriate, input-length dependent choice of sequential steps, however, a Universal Transformer, RNNs or Neural GPUs can execute such a function.
+
+![](images/97c3cbbe9fcf8d4d7ee8b9d381cd5a87ee67d792e9d0b1b91f1288ddc76c6b98.jpg)
+
+# APPENDIX C UT WITH DYNAMIC HALTING
+
+We implement the dynamic halting based on ACT (Graves, 2016) as follows in TensorFlow. In each step of the UT with dynamic halting, we are given the halting probabilities, remainders, number of updates up to that point, and the previous state (all initialized as zeros), as well as a scalar threshold between 0 and 1 (a hyper-parameter). We then compute the new state for each position and calculate the new per-position halting probabilities based on the state for each position. The UT then decides to halt for some positions that crossed the threshold, and updates the state of other positions until the model halts for all positions or reaches a predefined maximum number of steps:
+
+# W h i l e−l o o p s t o p s when t h i s p r e d i c a t e i s FALSE   
+2 # i . e . a l l ( ( p r o b a b i l i t y $<$ t h r e s h o l d ) & ( c o u n t e r $<$ m a x _ s t e p s ) ) a r e f a l s e d e f s h o u l d _ c o n t i n u e ( u0 , u1 , h a l t i n g _ p r o b a b i l i t y , u2 , n _ u p d a t e s , u 3 ) : r e t u r n t f . r e d u c e _ a n y (   
+5 t f . l o g i c a l _ a n d (   
+6 t f . l e s s ( h a l t i n g _ p r o b a b i l i t y , t h r e s h o l d ) ,   
+7 t f . l e s s ( n _ u p d a t e s , m a x _ s t e p s ) ) )   
+8 # Do w h i l e l o o p i t e r a t i o n s u n t i l p r e d i c a t e a b o v e i s f a l s e   
+9 _ , _ , r e m a i n d e r , n _ u p d a t e s , n e w _ s t a t e ) $=$ t f . w h i l e _ l o o p (   
+10 s h o u l d _ c o n t i n u e , u t _ w i t h _ d y n a m i c _ h a l t i n g , ( s t a t e ,   
+11 s t e p , h a l t i n g _ p r o b a b i l i t y , r e m a i n d e r s , n _ u p d a t e s , p r e v i o u s _ s t a t e ) )
+
+The following shows the computations in each step:
+
+d e f u t _ w i t h _ d y n a m i c _ h a l t i n g ( s t a t e , s t e p , h a l t i n g _ p r o b a b i l i t y ,   
+2 r e m a i n d e r s , n _ u p d a t e s , p r e v i o u s _ s t a t e ) :   
+3 # C a l c u l a t e t h e p r o b a b i l i t i e s b a s e d o n t h e s t a t e   
+4 $\mathrm { ~ \bf ~ p ~ } =$ c o m m o n _ l a y e r s . d e n s e ( s t a t e , 1 , a c t i v a t i o $\mathbf { n } = 1$ t f . n n . s i g m o i d ,   
+5 u s e _ b i a ${ \bf { S } } =$ T r u e )   
+6 # Mask f o r i n p u t s w h i c h h a v e n o t h a l t e d y e t   
+7 s t i l l _ r u n n i n g $=$ t f . c a s t (   
+9 8 # Mask o f i n p u t s w h i c h h a l t e d a t t h i s s t e p t f . l e s s ( h a l t i n g _ p r o b a b i l i t y , 1 . 0 ) , t f . f l o a t 3 2 )   
+10 n e w _ h a l t e d $=$ t f . c a s t (   
+11 t f . g r e a t e r ( h a l t i n g _ p r o b a b i l i t y $^ +$ p $^ *$ s t i l l _ r u n n i n g , t h r e s h o l d ) ,   
+12 t f . f l o a t 3 2 ) $^ *$ s t i l l _ r u n n i n g   
+13 # Mask o f i n p u t s w h i c h h a v e n ’ t h a l t e d , a n d d i d n ’ t h a l t t h i s s t e p   
+14 s t i l l _ r u n n i n g $=$ t f . c a s t (   
+15 t f . l e s s _ e q u a l ( h a l t i n g _ p r o b a b i l i t y + p ∗ s t i l l _ r u n n i n g ,   
+16 t h r e s h o l d ) , t f . f l o a t 3 2 ) $^ *$ s t i l l _ r u n n i n g   
+17 # Add t h e h a l t i n g p r o b a b i l i t y f o r t h i s s t e p t o t h e h a l t i n g   
+18 # p r o b a b i l i t i e s f o r t h o s e i n p u t s w h i c h h a v e n ’ t h a l t e d y e t   
+19 h a l t i n g _ p r o b a b i l i t y $+ = \texttt { p } *$ s t i l l _ r u n n i n g   
+20 # Compute r e m a i n d e r s f o r t h e i n p u t s w h i c h h a l t e d a t t h i s s t e p   
+21 r e m a i n d e r s $+ =$ n e w _ h a l t e d $^ *$ ( 1 − h a l t i n g _ p r o b a b i l i t y )   
+22 # Add t h e r e m a i n d e r s t o t h o s e i n p u t s w h i c h h a l t e d a t t h i s s t e p   
+23 h a l t i n g _ p r o b a b i l i t y $+ =$ n e w _ h a l t e d $^ *$ r e m a i n d e r s   
+24 # I n c r e m e n t n _ u p d a t e s f o r a l l i n p u t s w h i c h a r e s t i l l r u n n i n g   
+25 n _ u p d a t e s $+ =$ s t i l l _ r u n n i n g $^ +$ n e w _ h a l t e d   
+26 # Compute t h e w e i g h t t o b e a p p l i e d t o t h e new s t a t e a n d o u t p u t :   
+27 # 0 when t h e i n p u t h a s a l r e a d y h a l t e d ,   
+28 # p when t h e i n p u t h a s n ’ t h a l t e d y e t ,   
+29 # t h e r e m a i n d e r s when i t h a l t e d t h i s s t e p .   
+30 u p d a t e _ w e i g h t s $=$ t f . e x p a n d _ d i m s ( p $^ *$ s t i l l _ r u n n i n g +   
+31 n e w _ h a l t e d $^ *$ r e m a i n d e r s , −1)   
+32 $\#$ A p p l y t r a n s f o r m a t i o n t o t h e s t a t e   
+33 t r a n s f o r m e d _ s t a t e $=$ t r a n s i t i o n _ f u n c t i o n ( s e l f _ a t t e n t i o n ( s t a t e ) )   
+34 # I n t e r p o l a t e t r a n s f o r m e d a n d p r e v i o u s s t a t e s f o r non−h a l t e d i n p u t s   
+35 n e w _ s t a t e $=$ ( ( t r a n s f o r m e d _ s t a t e $^ *$ u p d a t e _ w e i g h t s ) $^ +$   
+36 ( p r e v i o u s _ s t a t e $^ *$ ( 1 − u p d a t e _ w e i g h t s ) ) )   
+37 s t e p $+ = ~ 1$   
+38 r e t u r n ( t r a n s f o r m e d _ s t a t e , s t e p , h a l t i n g _ p r o b a b i l i t y ,   
+39 r e m a i n d e r s , n _ u p d a t e s , n e w _ s t a t e )
+
+Listing 2: Computations in each step of the UT with dynamic halting.
+
+# APPENDIX D DESCRIPTION OF SOME OF THE TASKS/DATASETS
+
+Here, we provide some additional details on the bAbI, subject-verb agreement, LAMBADA language modeling, and learning to execute (LTE) tasks.
+
+# D.1 BABI QUESTION-ANSWERING
+
+The bAbi question answering dataset (Weston et al., 2015) consists of 20 different synthetic tasks7. The aim is that each task tests a unique aspect of language understanding and reasoning, including the ability of: reasoning from supporting facts in a story, answering true/false type questions, counting, understanding negation and indefinite knowledge, understanding coreferences, time reasoning, positional and size reasoning, path-finding, and understanding motivations (to see examples for each of these tasks, please refer to Table 1 in (Weston et al., 2015)).
+
+There are two versions of the dataset, one with 1k training examples and the other with 10k examples. It is important for a model to be data-efficient to achieve good results using only the 1k training examples. Moreover, the original idea is that a single model should be evaluated across all the tasks (not tuning per task), which is the train joint setup in Table 1, and the tables presented in Appendix E.
+
+# D.2 SUBJECT-VERB AGREEMENT
+
+Subject-verb agreement is the task of predicting number agreement between subject and verb in English sentences. Succeeding in this task is a strong indicator that a model can learn to approximate syntactic structure and therefore it was proposed by Linzen et al. (2016) as proxy for assessing the ability of different models to capture hierarchical structure in natural language.
+
+Two experimental setups were proposed by Linzen et al. (2016) for training a model on this task: 1) training with a language modeling objective, i.e., next word prediction, and 2) as binary classification, i.e. predicting the number of the verb given the sentence. In this paper, we use the language modeling objective, meaning that we provide the model with an implicit supervision and evaluate based on the ranking accuracy of the correct form of the verb compared to the incorrect form of the verb.
+
+In this task, in order to have different levels of difficulty, “agreement attractors” are used, i.e. one or more intervening nouns with the opposite number from the subject with the goal of confusing the model. In this case, the model needs to correctly identify the head of the syntactic subject that corresponds to a given verb and ignore the intervening attractors in order to predict the correct form of that verb. Here are some examples for this task in which subjects and the corresponding verbs are in boldface and agreement attractors are underlined:
+
+No attractor: The boy smiles.   
+One attractor: The number of men is not clear.   
+Two attractors: The ratio of men to women is not clear.   
+Three attractors: The ratio of men to women and children is not clear.
+
+# D.3 LAMBADA LANGUAGE MODELING
+
+The LAMBADA task (Paperno et al., 2016) is a broad context language modeling task. In this task, given a narrative passage, the goal is to predict the last word (target word) of the last sentence (target sentence) in the passage. These passages are specifically selected in a way that human subjects are easily able to guess their last word if they are exposed to a long passage, but not if they only see the target sentence preceding the target word8. Here is a sample from the dataset:
+
+# Context:
+
+“Yes, I thought I was going to lose the baby.” “I was scared too,” he stated, sincerity flooding his eyes. “You were?” “Yes, of course. Why do you even ask?” “This baby wasn’t exactly planned for.”   
+Target sentence: “Do you honestly think that I would want you to have a _?”   
+Target word: miscarriage
+
+The LAMBADA task consists in predicting the target word given the whole passage (i.e., the context plus the target sentence). A “control set” is also provided which was constructed by randomly sampling passages of the same shape and size as the ones used to build LAMBADA, but without filtering them in any way. The control set is used to evaluate the models at standard language modeling before testing on the LAMBADA task, and therefore to ensure that low performance on the latter cannot be attributed simply to poor language modeling.
+
+The task is evaluated in two settings: as language modeling (the standard setup) and as reading comprehension. In the former (more challenging) case, a model is simply trained for the next word prediction on the training data, and evaluated on the target words at test time (i.e. the model is trained to predict all words, not specifically challenging target words). In this paper, we report the results of the Universal Transformer in both setups.
+
+# D.4 LEARNING TO EXECUTE (LTE)
+
+LTE is a set of tasks indicating the ability of a model to learn to execute computer programs and was proposed by Zaremba & Sutskever (2015). These tasks include two subsets: 1) program evaluation tasks (program, control, and addition) that are designed to assess the ability of models for understanding numerical operations, if-statements, variable assignments, the compositionality of operations, and more, as well as 2) memorization tasks (copy, double, and reverse).
+
+The difficulty of the program evaluation tasks is parameterized by their length and nesting. The length parameter is the number of digits in the integers that appear in the programs (so the integers are chosen uniformly from [1, length]), and the nesting parameter is the number of times we are allowed to combine the operations with each other. Higher values of nesting yield programs with deeper parse trees. For instance, here is a program that is generated with length $= 4$ and nesting $= 3$ .
+
+Input: $\dot { ] } = 8 5 8 4$ for x in range(8): $y + = 9 2 0$ $b = ( 1 5 0 0 + \mathrm { j }$ ) print((b+7567))   
+Target: 25011
+
+APPENDIX E BABI DETAILED RESULTS   
+
+<table><tr><td colspan="5">Best seed run for each task (out of 1O runs)</td></tr><tr><td rowspan="2">Task id</td><td colspan="2">10K</td><td colspan="2">1K</td></tr><tr><td> train single</td><td>train joint</td><td> train single</td><td>train joint</td></tr><tr><td>1</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td></tr><tr><td>2</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.5</td></tr><tr><td>3</td><td>0.4</td><td>1.2</td><td>3.7</td><td>5.4</td></tr><tr><td>4</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td></tr><tr><td>5</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.5</td></tr><tr><td>6</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.5</td></tr><tr><td>7</td><td>0.0</td><td>0.0</td><td>0.0</td><td>3.2</td></tr><tr><td>8</td><td>0.0</td><td>0.0</td><td>0.0</td><td>1.6</td></tr><tr><td>9</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.2</td></tr><tr><td>10</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.4</td></tr><tr><td>11</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.1</td></tr><tr><td>12</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td></tr><tr><td>13</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.6</td></tr><tr><td>14</td><td>0.0</td><td>0.0</td><td>0.0</td><td>3.8</td></tr><tr><td>15</td><td>0.0</td><td>0.0</td><td>0.0</td><td>5.9</td></tr><tr><td>16</td><td>0.4</td><td>1.2</td><td>5.8</td><td>15.4</td></tr><tr><td>17</td><td>0.6</td><td>0.2</td><td>32.0</td><td>42.9</td></tr><tr><td>18</td><td>0.0</td><td>0.0</td><td>0.0</td><td>4.1</td></tr><tr><td>19</td><td>2.8</td><td>3.1</td><td>47.1</td><td>68.2</td></tr><tr><td>20</td><td>0.0</td><td>0.0</td><td>2.4</td><td>2.4</td></tr><tr><td>avg err</td><td>0.21</td><td>0.29</td><td>4.55</td><td>7.78</td></tr><tr><td>failed</td><td>0</td><td>0</td><td>3</td><td>5</td></tr></table>
+
+<table><tr><td colspan="5">Average (±var) over all seeds (for 1O runs)</td></tr><tr><td rowspan="2">Task id</td><td colspan="2">10K</td><td colspan="2">1K</td></tr><tr><td>train single</td><td>train joint</td><td>train single</td><td>train joint</td></tr><tr><td>1</td><td>0.0±0.0</td><td>0.0±0.0</td><td>0.2 ±0.3</td><td>0.1±0.2</td></tr><tr><td>2</td><td>0.2 ±0.4</td><td>1.7 ±2.6</td><td>3.2 ±4.1</td><td>4.3 ±11.6</td></tr><tr><td>3</td><td>1.8 ±1.8</td><td>4.6 ±7.3</td><td>9.1 ±12.7</td><td>14.3 ±18.1</td></tr><tr><td>4</td><td>0.1 ±0.1</td><td>0.2 ±0.1</td><td>0.3 ±0.3</td><td>0.4±0.6</td></tr><tr><td>5</td><td>0.2 ±0.3</td><td>0.8 ±0.5</td><td>1.1 ±1.3</td><td>4.3 ±5.6</td></tr><tr><td>6</td><td>0.1 ±0.2</td><td>0.1±0.2</td><td>1.2 ±2.1</td><td>0.8 ±0.4</td></tr><tr><td>7</td><td>0.3 ±0.5</td><td>1.1 ±1.5</td><td>0.0 ±0.0</td><td>4.1 ±2.9</td></tr><tr><td>8</td><td>0.3 ±0.2</td><td>0.5 ±1.1</td><td>0.1±0.2</td><td>3.9 ±4.2</td></tr><tr><td>9</td><td>0.0±0.0</td><td>0.0±0.0</td><td>0.1 ±0.1</td><td>0.3 ±0.3</td></tr><tr><td>10</td><td>0.1 ±0.2</td><td>0.5 ±0.4</td><td>0.7 ±0.8</td><td>1.3 ±1.6</td></tr><tr><td>11</td><td>0.0±0.0</td><td>0.1 ±0.1</td><td>0.4±0.8</td><td>0.3 ±0.9</td></tr><tr><td>12</td><td>0.2 ±0.1</td><td>0.4±0.4</td><td>0.6 ±0.9</td><td>0.3 ±0.4</td></tr><tr><td>13</td><td>0.2 ±0.5</td><td>0.3 ±0.4</td><td>0.8 ±0.9</td><td>1.1 ±0.9</td></tr><tr><td>14</td><td>1.8 ±2.6</td><td>1.3 ±1.6</td><td>0.1 ±0.2</td><td>4.7 ±5.2</td></tr><tr><td>15</td><td>2.1 ±3.4</td><td>1.6 ±2.8</td><td>0.3 ±0.5</td><td>10.3 ±8.6</td></tr><tr><td>16</td><td>1.9 ±2.2</td><td>0.9 ±1.3</td><td>9.1 ±8.1</td><td>34.1 ±22.8</td></tr><tr><td>17</td><td>1.6 ±0.8</td><td>1.4 ±3.4</td><td>43.7 ±18.6</td><td>51.1 ±12.9</td></tr><tr><td>18</td><td>0.3 ±0.4</td><td>0.7 ±1.4</td><td>2.3 ±3.6</td><td>12.8 ±9.0</td></tr><tr><td>19</td><td>3.4 ±4.0</td><td>6.1 ±7.3</td><td>50.2 ±8.4</td><td>73.1 ±23.9</td></tr><tr><td>20</td><td>0.0±0.0</td><td>0.0±0.0</td><td>3.2 ±2.5</td><td>2.6 ±2.8</td></tr><tr><td>avg</td><td>0.73 ±0.89</td><td>1.12 ±1.62</td><td>6.34 ±3.32</td><td>11.21 ±6.65</td></tr></table>
+
+# APPENDIX F BABI ATTENTION VISUALIZATION
+
+We present a visualization of the attention distributions on bAbI tasks for a couple of examples. The visualization of attention weights is over different time steps based on different heads over all the facts in the story and a question. Different color bars on the left side indicate attention weights based on different heads (4 heads in total).
+
+![](images/f3a8b180baa16b5f9ca5ac95879283ae0e32e4a8ef49f091fa354a9fde3e930f.jpg)  
+Figure 5: Visualization of the attention distributions, when encoding the question: “Where is Mary?”.
+
+![](images/633232030ca5d5b1aa8ec04cd5838358dadf985ee0d80a2f625cf4954a6e4396.jpg)  
+Figure 6: Visualization of the attention distributions, when encoding the question: “Where is the apple?”.
+
+# An example from tasks 2:
+
+# (requiring two supportive facts to solve)
+
+Story:
+
+John went to the hallway.   
+John went back to the bathroom.   
+John grabbed the milk there.   
+Sandra went back to the office.   
+Sandra journeyed to the kitchen.   
+Sandra got the apple there.   
+Sandra dropped the apple there.   
+John dropped the milk.
+
+# Question:
+
+Model’s output:
+
+![](images/e1033d6c9551721f801f303de488b01d8481d1a4c75f090a3c4b7004f0a66c0b.jpg)  
+Figure 7: Visualization of the attention distributions, when encoding the question: “Where is the milk?”.
+
+# Story:
+
+Mary got the milk.
+
+John moved to the bedroom.   
+Daniel journeyed to the office.   
+John grabbed the apple there.   
+John got the football.   
+John journeyed to the garden.   
+Mary left the milk.   
+John left the football.   
+Daniel moved to the garden.   
+Daniel grabbed the football.   
+Mary moved to the hallway.   
+Mary went to the kitchen.   
+John put down the apple there.   
+John picked up the apple.   
+Sandra moved to the hallway.   
+Daniel left the football there.   
+Daniel took the football.   
+John travelled to the kitchen.   
+Daniel dropped the football.   
+John dropped the apple.   
+John grabbed the apple.   
+John went to the office.   
+Sandra went back to the bedroom.   
+Sandra took the milk.   
+John journeyed to the bathroom.   
+John travelled to the office.   
+Sandra left the milk.   
+Mary went to the bedroom.   
+Mary moved to the office.   
+John travelled to the hallway.   
+Sandra moved to the garden.   
+Mary moved to the kitchen.   
+Daniel took the football.   
+Mary journeyed to the bedroom.   
+Mary grabbed the milk there.   
+Mary discarded the milk.   
+John went to the garden.   
+John discarded the apple there.
+
+# Question:
+
+Where was the apple before the bathroom?
+
+![](images/b072cbbf76149611a54d835b355af8121aa707b153136394fa096a079be84ab8.jpg)
+
+![](images/b8ba124e3521a9107c4162d947a1456357f1f27d682af41ebbed2927c36d6c8c.jpg)  
+Figure 7: Visualization of the attention distributions, when encoding the question: “Where was the apple before the bathroom?”.
+
+(h) Step 4

parse/train/HyzdRiR9Y7/HyzdRiR9Y7_content_list.json

@@ -0,0 +1,1749 @@
+[
+    {
+        "type": "text",
+        "text": "UNIVERSAL TRANSFORMERS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            99,
+            524,
+            121
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Mostafa Dehghani∗† University of Amsterdam dehghani@uva.nl ",
+        "bbox": [
+            191,
+            141,
+            356,
+            186
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Stephan Gouws∗ DeepMind sgouws@google.com ",
+        "bbox": [
+            374,
+            141,
+            542,
+            186
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Oriol Vinyals   \nDeepMind   \nvinyals@google.com ",
+        "bbox": [
+            562,
+            141,
+            743,
+            188
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Jakob Uszkoreit Google Brain usz@google.com ",
+        "bbox": [
+            191,
+            204,
+            331,
+            250
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Łukasz Kaiser   \nGoogle Brain   \nlukaszkaiser@google.com ",
+        "bbox": [
+            372,
+            204,
+            602,
+            250
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            286,
+            544,
+            301
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recurrent neural networks (RNNs) sequentially process data by updating their state with each new data point, and have long been the de facto choice for sequence modeling tasks. However, their inherently sequential computation makes them slow to train. Feed-forward and convolutional architectures have recently been shown to achieve superior results on some sequence modeling tasks such as machine translation, with the added advantage that they concurrently process all inputs in the sequence, leading to easy parallelization and faster training times. Despite these successes, however, popular feed-forward sequence models like the Transformer fail to generalize in many simple tasks that recurrent models handle with ease, e.g. copying strings or even simple logical inference when the string or formula lengths exceed those observed at training time. We propose the Universal Transformer (UT), a parallel-in-time self-attentive recurrent sequence model which can be cast as a generalization of the Transformer model and which addresses these issues. UTs combine the parallelizability and global receptive field of feed-forward sequence models like the Transformer with the recurrent inductive bias of RNNs. We also add a dynamic per-position halting mechanism and find that it improves accuracy on several tasks. In contrast to the standard Transformer, under certain assumptions UTs can be shown to be Turing-complete. Our experiments show that UTs outperform standard Transformers on a wide range of algorithmic and language understanding tasks, including the challenging LAMBADA language modeling task where UTs achieve a new state of the art, and machine translation where UTs achieve a 0.9 BLEU improvement over Transformers on the WMT14 En-De dataset. ",
+        "bbox": [
+            232,
+            319,
+            766,
+            618
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            646,
+            336,
+            662
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Convolutional and fully-attentional feed-forward architectures like the Transformer have recently emerged as viable alternatives to recurrent neural networks (RNNs) for a range of sequence modeling tasks, notably machine translation (Gehring et al., 2017; Vaswani et al., 2017). These parallel-in-time architectures address a significant shortcoming of RNNs, namely their inherently sequential computation which prevents parallelization across elements of the input sequence, whilst still addressing the vanishing gradients problem as the sequence length gets longer (Hochreiter et al., 2003). The Transformer model in particular relies entirely on a self-attention mechanism (Parikh et al., 2016; Lin et al., 2017) to compute a series of context-informed vector-space representations of the symbols in its input and output, which are then used to predict distributions over subsequent symbols as the model predicts the output sequence symbol-by-symbol. Not only is this mechanism straightforward to parallelize, but as each symbol’s representation is also directly informed by all other symbols’ representations, this results in an effectively global receptive field across the whole sequence. This stands in contrast to e.g. convolutional architectures which typically only have a limited receptive field. ",
+        "bbox": [
+            174,
+            676,
+            825,
+            853
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Notably, however, the Transformer with its fixed stack of distinct layers foregoes RNNs’ inductive bias towards learning iterative or recursive transformations. Our experiments indicate that this inductive bias may be crucial for several algorithmic and language understanding tasks of varying complexity: in contrast to models such as the Neural Turing Machine (Graves et al., 2014), the Neural GPU (Kaiser & Sutskever, 2016) or Stack RNNs (Joulin & Mikolov, 2015), the Transformer does not generalize well to input lengths not encountered during training. ",
+        "bbox": [
+            176,
+            861,
+            823,
+            888
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/507dd2051da74f742d60f292c7b40056ad899fd54839be5a4b69dae12188a93b.jpg",
+        "image_caption": [
+            "Figure 1: The Universal Transformer repeatedly refines a series of vector representations for each position of the sequence in parallel, by combining information from different positions using self-attention (see Eqn 2) and applying a recurrent transition function (see Eqn 4) across all time steps $1 \\leq t \\leq T$ . We show this process over two recurrent time-steps. Arrows denote dependencies between operations. Initially, $\\hat { h } ^ { 0 }$ is initialized with the embedding for each symbol in the sequence. $h _ { i } ^ { t }$ represents the representation for input symbol $1 \\leq i \\leq m$ at recurrent time-step $t$ . With dynamic halting, $T$ is dynamically determined for each position (Section 2.2). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            104,
+            818,
+            234
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            361,
+            825,
+            416
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we introduce the Universal Transformer $( U T )$ , a parallel-in-time recurrent self-attentive sequence model which can be cast as a generalization of the Transformer model, yielding increased theoretical capabilities and improved results on a wide range of challenging sequence-to-sequence tasks. UTs combine the parallelizability and global receptive field of feed-forward sequence models like the Transformer with the recurrent inductive bias of RNNs, which seems to be better suited to a range of algorithmic and natural language understanding sequence-to-sequence problems. As the name implies, and in contrast to the standard Transformer, under certain assumptions UTs can be shown to be Turing-complete (or “computationally universal”, as shown in Section 4). ",
+        "bbox": [
+            174,
+            422,
+            825,
+            532
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In each recurrent step, the Universal Transformer iteratively refines its representations for all symbols in the sequence in parallel using a self-attention mechanism (Parikh et al., 2016; Lin et al., 2017), followed by a transformation (shared across all positions and time-steps) consisting of a depth-wise separable convolution (Chollet, 2016; Kaiser et al., 2017) or a position-wise fully-connected layer (see Fig 1). We also add a dynamic per-position halting mechanism (Graves, 2016), allowing the model to choose the required number of refinement steps for each symbol dynamically, and show for the first time that such a conditional computation mechanism can in fact improve accuracy on several smaller, structured algorithmic and linguistic inference tasks (although it marginally degraded results on MT). ",
+        "bbox": [
+            174,
+            539,
+            825,
+            648
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our strong experimental results show that UTs outperform Transformers and LSTMs across a wide range of tasks. The added recurrence yields improved results in machine translation where UTs outperform the standard Transformer. In experiments on several algorithmic tasks and the bAbI language understanding task, UTs also consistently and significantly improve over LSTMs and the standard Transformer. Furthermore, on the challenging LAMBADA text understanding data set UTs with dynamic halting achieve a new state of the art. ",
+        "bbox": [
+            174,
+            655,
+            825,
+            737
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 MODEL DESCRIPTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            757,
+            388,
+            773
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 THE UNIVERSAL TRANSFORMER ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            787,
+            441,
+            803
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The Universal Transformer (UT; see Fig. 2) is based on the popular encoder-decoder architecture commonly used in most neural sequence-to-sequence models (Sutskever et al., 2014; Cho et al., 2014; Vaswani et al., 2017). Both the encoder and decoder of the UT operate by applying a recurrent neural network to the representations of each of the positions of the input and output sequence, respectively. However, in contrast to most applications of recurrent neural networks to sequential data, the UT does not recur over positions in the sequence, but over consecutive revisions of the vector representations of each position (i.e., over “depth”). In other words, the UT is not computationally bound by the number of symbols in the sequence, but only by the number of revisions made to each symbol’s representation. ",
+        "bbox": [
+            174,
+            814,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In each recurrent time-step, the representation of every position is concurrently (in parallel) revised in two sub-steps: first, using a self-attention mechanism to exchange information across all positions in the sequence, thereby generating a vector representation for each position that is informed by the representations of all other positions at the previous time-step. Then, by applying a transition function (shared across position and time) to the outputs of the self-attention mechanism, independently at each position. As the recurrent transition function can be applied any number of times, this implies that UTs can have variable depth (number of per-symbol processing steps). Crucially, this is in contrast to most popular neural sequence models, including the Transformer (Vaswani et al., 2017) or deep RNNs, which have constant depth as a result of applying a fixed stack of layers. We now describe the encoder and decoder in more detail. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            241
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "ENCODER: Given an input sequence of length $m$ , we start with a matrix whose rows are initialized as the $d$ -dimensional embeddings of the symbols at each position of the sequence $H ^ { 0 } \\in \\mathbb { R } ^ { m \\times d }$ . The UT then iteratively computes representations $H ^ { t }$ at step $t$ for all $m$ positions in parallel by applying the multi-headed dot-product self-attention mechanism from Vaswani et al. (2017), followed by a recurrent transition function. We also add residual connections around each of these function blocks and apply dropout and layer normalization (Srivastava et al., 2014; Ba et al., 2016) (see Fig. 2 for a simplified diagram, and Fig. 4 in the Appendix A for the complete model.). ",
+        "bbox": [
+            174,
+            246,
+            825,
+            343
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "More specifically, we use the scaled dot-product attention which combines queries $Q$ , keys $K$ and values $V$ as follows ",
+        "bbox": [
+            174,
+            348,
+            825,
+            377
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/888aa0eec78961625a960f340e13c1f9bdff20285e2b5c5720857ed775e4a0d7.jpg",
+        "text": "$$\n\\mathrm { A T T E N T I O N } ( Q , K , V ) = \\mathrm { S O F T M A X } \\left( \\frac { Q K ^ { T } } { \\sqrt { d } } \\right) V ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            343,
+            393,
+            655,
+            429
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $d$ is the number of columns of $Q$ , $K$ and $V$ . We use the multi-head version with $k$ heads, as introduced in (Vaswani et al., 2017), ",
+        "bbox": [
+            171,
+            440,
+            823,
+            469
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/269c9f8d387fd4dad449842455048f9976ce81ad7df0f1290d780a15abff4882.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\mathbf { M U L T I H E A D S E L F A T T E N T I O N } ( H ^ { t } ) = \\mathbf { C O N C A T ( h e a d _ { 1 } , . . . , h e a d _ { k } ) } W ^ { O } } \\\\ & { \\qquad \\mathrm { w h e r e ~ h e a d _ { i } = A T T E N T I O N } ( H ^ { t } W _ { i } ^ { Q } , H ^ { t } W _ { i } ^ { K } , H ^ { t } W _ { i } ^ { V } ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            241,
+            497,
+            754,
+            541
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "and we map the state $H ^ { t }$ to queries, keys and values with affine projections using learned parameter matrices $\\bar { W } ^ { Q } \\in \\mathbb { R } ^ { d \\times d / k }$ , $W ^ { \\bar { K } } \\in \\mathbb { R } ^ { d \\times d / \\bar { k } }$ , $W ^ { V } \\in \\mathbb { R } ^ { d \\times d / k }$ and $W ^ { O } \\in \\mathbb { R } ^ { d \\times d }$ . ",
+        "bbox": [
+            174,
+            558,
+            823,
+            587
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "At step $t$ , the UT then computes revised representations $H ^ { t } \\in \\mathbb { R } ^ { m \\times d }$ for all $m$ input positions as follows ",
+        "bbox": [
+            174,
+            593,
+            823,
+            609
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/09127e6b29f44c8f653b3dae19d6e10ae5e1ddbe85932f198a65b0b9c1ac3b98.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\quad H ^ { t } = \\mathrm { L A Y E R N O R M } ( A ^ { t } + \\mathrm { T R A N S I T I O N } ( A ^ { t } ) ) } \\\\ & { \\mathrm { e } A ^ { t } = \\mathrm { L A Y E R N O R M } ( ( H ^ { t - 1 } + P ^ { t } ) + \\mathrm { M U L T I H E A D S E L F A T T E N T I O N } ( H ^ { t - 1 } + P ^ { t } ) ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            236,
+            637,
+            779,
+            679
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where LAYERNORM() is defined in Ba et al. (2016), and TRANSITION() and $P ^ { t }$ are discussed below. ",
+        "bbox": [
+            178,
+            688,
+            823,
+            704
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Depending on the task, we use one of two different transition functions: either a separable convolution (Chollet, 2016) or a fully-connected neural network that consists of a single rectified-linear activation function between two affine transformations, applied position-wise, i.e. individually to each row of $A ^ { t }$ . ",
+        "bbox": [
+            174,
+            709,
+            825,
+            765
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "$P ^ { t } \\in \\mathbb { R } ^ { m \\times d }$ above are fixed, constant, two-dimensional (position, time) coordinate embeddings, obtained by computing the sinusoidal position embedding vectors as defined in (Vaswani et al., 2017) for the positions $1 \\leq i \\leq m$ and the time-step $1 \\leq t \\leq T$ separately for each vector-dimension $1 \\leq j \\leq d$ and summing: ",
+        "bbox": [
+            174,
+            771,
+            825,
+            828
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/24a86bbbf6ddc41ba3b4ed24932adf74f0fb07bce354bfc6645e2f402980ef1c.jpg",
+        "text": "$$\n\\begin{array} { r } { P _ { i , 2 j } ^ { t } = \\sin ( i / 1 0 0 0 0 ^ { 2 j / d } ) + \\sin ( t / 1 0 0 0 0 ^ { 2 j / d } ) } \\\\ { P _ { i , 2 j + 1 } ^ { t } = \\cos ( i / 1 0 0 0 0 ^ { 2 j / d } ) + \\cos ( t / 1 0 0 0 0 ^ { 2 j / d } ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            338,
+            835,
+            658,
+            881
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/921913d43679c74453a009ab5038b5a9fb452c9b7a70037826c1dfb32a69f5b9.jpg",
+        "image_caption": [
+            "Figure 2: The recurrent blocks of the Universal Transformer encoder and decoder. This diagram omits position and time-step encodings as well as dropout, residual connections and layer normalization. A complete version can be found in Appendix A. The Universal Transformer with dynamic halting determines the number of steps $T$ for each position individually using ACT (Graves, 2016). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            103,
+            820,
+            353
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "After $T$ steps (each updating all positions of the input sequence in parallel), the final output of the Universal Transformer encoder is a matrix of $d$ -dimensional vector representations $H ^ { T } \\in \\mathbf { \\bar { \\mathbb { R } } } ^ { m \\times d }$ for the $m$ symbols of the input sequence. ",
+        "bbox": [
+            174,
+            443,
+            823,
+            484
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "DECODER: The decoder shares the same basic recurrent structure of the encoder. However, after the self-attention function, the decoder additionally also attends to the final encoder representation $H ^ { T }$ of each position in the input sequence using the same multihead dot-product attention function from Equation 2, but with queries $Q$ obtained from projecting the decoder representations, and keys and values ( $K$ and $V$ ) obtained from projecting the encoder representations (this process is akin to standard attention (Bahdanau et al., 2014)). ",
+        "bbox": [
+            173,
+            491,
+            825,
+            571
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Like the Transformer model, the UT is autoregressive (Graves, 2013). Trained using teacher-forcing, at generation time it produces its output one symbol at a time, with the decoder consuming the previously produced output positions. During training, the decoder input is the target output, shifted to the right by one position. The decoder self-attention distributions are further masked so that the model can only attend to positions to the left of any predicted symbol. Finally, the per-symbol target distributions are obtained by applying an affine transformation $O \\in \\mathbb { R } ^ { d \\times V }$ from the final decoder state to the output vocabulary size $V$ , followed by a softmax which yields an $( m \\times V )$ -dimensional output matrix normalized over its rows: ",
+        "bbox": [
+            173,
+            579,
+            825,
+            689
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5ef8d84574282abdaa8eb989e0bda667e840e3aa2aecb5e6820feb3fbb48f2b5.jpg",
+        "text": "$$\np \\big ( y _ { p o s } | y _ { [ 1 : p o s - 1 ] } , H ^ { T } \\big ) = \\mathrm { s O F T M A X } ( O H ^ { T } ) ^ { 1 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            352,
+            705,
+            645,
+            727
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To generate from the model, the encoder is run once for the conditioning input sequence. Then the decoder is run repeatedly, consuming all already-generated symbols, while generating one additional distribution over the vocabulary for the symbol at the next output position per iteration. We then typically sample or select the highest probability symbol as the next symbol. ",
+        "bbox": [
+            174,
+            738,
+            825,
+            792
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.2 DYNAMIC HALTING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            813,
+            351,
+            827
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In sequence processing systems, certain symbols (e.g. some words or phonemes) are usually more ambiguous than others. It is therefore reasonable to allocate more processing resources to these more ambiguous symbols. Adaptive Computation Time (ACT) (Graves, 2016) is a mechanism for dynamically modulating the number of computational steps needed to process each input symbol (called the “ponder time”) in standard recurrent neural networks based on a scalar halting probability predicted by the model at each step. ",
+        "bbox": [
+            174,
+            839,
+            825,
+            895
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/51d5d56e4f78e3a0a071084a9b43d582a43ffb2712e6a44a55c8f815f626b836.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Table 1: Average error and number of failed tasks $( > 5 \\%$ error) out of 20 (in parentheses; lower is better in both cases) on the bAbI dataset under the different training/evaluation setups. We indicate state-of-the-art where available for each, or ‘-’ otherwise. "
+        ],
+        "table_body": "<table><tr><td rowspan=\"2\">Model</td><td colspan=\"2\">10K examples</td><td colspan=\"2\">1K examples</td></tr><tr><td>train single</td><td>train joint</td><td>train single</td><td>train joint</td></tr><tr><td colspan=\"5\">Previous best results:</td></tr><tr><td>QRNet (Seo et al., 2016)</td><td>0.3 (0/20)</td><td></td><td></td><td></td></tr><tr><td>Sparse DNC (Rae et al.,2016)</td><td></td><td>2.9 (1/20)</td><td></td><td></td></tr><tr><td>GA+MAGE Dhingra et al. (2017)</td><td></td><td></td><td>8.7 (5/20)</td><td></td></tr><tr><td>MemN2N Sukhbaatar et al. (2015)</td><td></td><td></td><td></td><td>12.4 (11/20)</td></tr><tr><td colspan=\"5\">Our Results:</td></tr><tr><td>Transformer (Vaswani et al.,2017)</td><td>15.2 (10/20)</td><td>22.1 (12/20)</td><td>21.8 (5/20)</td><td>26.8 (14/20)</td></tr><tr><td>Universal Transformer (this work)</td><td>0.23 (0/20)</td><td>0.47 (0/20)</td><td>5.31 (5/20)</td><td>8.50 (8/20)</td></tr><tr><td>UT w/ dynamic halting (this work)</td><td>0.21 (0/20)</td><td>0.29 (0/20)</td><td>4.55 (3/20)</td><td>7.78 (5/20)</td></tr></table>",
+        "bbox": [
+            205,
+            113,
+            790,
+            292
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            353,
+            823,
+            381
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Inspired by the interpretation of Universal Transformers as applying self-attentive RNNs in parallel to all positions in the sequence, we also add a dynamic ACT halting mechanism to each position (i.e. to each per-symbol self-attentive RNN; see Appendix C for more details). Once the per-symbol recurrent block halts, its state is simply copied to the next step until all blocks halt, or we reach a maximum number of steps. The final output of the encoder is then the final layer of representations produced in this way. ",
+        "bbox": [
+            174,
+            387,
+            825,
+            457
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3 EXPERIMENTS AND ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            477,
+            457,
+            492
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We evaluated the Universal Transformer on a range of algorithmic and language understanding tasks, as well as on machine translation. We describe these tasks and datasets in more detail in Appendix D. ",
+        "bbox": [
+            174,
+            507,
+            823,
+            535
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.1 BABI QUESTION-ANSWERING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            551,
+            423,
+            566
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The bAbi question answering dataset (Weston et al., 2015) consists of 20 different tasks, where the goal is to answer a question given a number of English sentences that encode potentially multiple supporting facts. The goal is to measure various forms of language understanding by requiring a certain type of reasoning over the linguistic facts presented in each story. A standard Transformer does not achieve good results on this task2. However, we have designed a model based on the Universal Transformer which achieves state-of-the-art results on this task. ",
+        "bbox": [
+            174,
+            578,
+            825,
+            660
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To encode the input, similar to Henaff et al. (2016), we first encode each fact in the story by applying a learned multiplicative positional mask to each word’s embedding, and summing up all embeddings. We embed the question in the same way, and then feed the (Universal) Transformer with these embeddings of the facts and questions. ",
+        "bbox": [
+            174,
+            666,
+            825,
+            722
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "As originally proposed, models can either be trained on each task separately (“train single”) or jointly on all tasks (“train joint”). Table 1 summarizes our results. We conducted 10 runs with different initializations and picked the best model based on performance on the validation set, similar to previous work. Both the UT and UT with dynamic halting achieve state-of-the-art results on all tasks in terms of average error and number of failed tasks3, in both the 10K and 1K training regime (see Appendix E for breakdown by task). ",
+        "bbox": [
+            174,
+            728,
+            825,
+            810
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To understand the working of the model better, we analyzed both the attention distributions and the average ACT ponder times for this task (see Appendix F for details). First, we observe that the attention distributions start out very uniform, but get progressively sharper in later steps around the correct supporting facts that are required to answer each question, which is indeed very similar to how humans would solve the task. Second, with dynamic halting we observe that the average ponder time (i.e. depth of the per-symbol recurrent processing chain) over all positions in all samples in the test data for tasks requiring three supporting facts is higher $( 3 . 8 { \\pm } 2 . 2 ) $ than for tasks requiring only two $( 3 . 1 { \\pm } 1 . 1 ) $ , which is in turn higher than for tasks requiring only one supporting fact $( 2 . 3 { \\pm } 0 . 8 ) $ . This indicates that the model adjusts the number of processing steps with the number of supporting facts required to answer the questions. Finally, we observe that the histogram of ponder times at different positions is more uniform in tasks requiring only one supporting fact compared to two and three, and likewise for tasks requiring two compared to three. Especially for tasks requiring three supporting facts, many positions halt at step 1 or 2 already and only a few get transformed for more steps (see for example Fig 3). This is particularly interesting as the length of stories is indeed much higher in this setting, with more irrelevant facts which the model seems to successfully learn to ignore in this way. ",
+        "bbox": [
+            174,
+            818,
+            823,
+            886
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/79cd643b79ebf6e2857e1b7faa9e0dfee2764a5ad06f0203090a8a37ddf605ac.jpg",
+        "image_caption": [
+            "Figure 3: Ponder time of UT with dynamic halting for encoding facts in a story and question in a bAbI task requiring three supporting facts. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            99,
+            821,
+            252
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            318,
+            825,
+            454
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Similar to dynamic memory networks (Kumar et al., 2016), there is an iterative attention process in UTs that allows the model to condition its attention over memory on the result of previous iterations. Appendix F presents some examples illustrating that there is a notion of temporal states in UT, where the model updates its states (memory) in each step based on the output of previous steps, and this chain of updates can also be viewed as steps in a multi-hop reasoning process. ",
+        "bbox": [
+            174,
+            460,
+            825,
+            530
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.2 SUBJECT-VERB AGREEMENT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            550,
+            415,
+            564
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Next, we consider the task of predicting number-agreement between subjects and verbs in English sentences (Linzen et al., 2016). This task acts as a proxy for measuring the ability of a model to capture hierarchical (dependency) structure in natural language sentences. We use the dataset provided by (Linzen et al., 2016) and follow their experimental protocol of solving the task using a language modeling training setup, i.e. a next word prediction objective, followed by calculating the ranking accuracy of the target verb at test time. We evaluated our model on subsets of the test data with different task difficulty, measured in terms of agreement attractors – the number of intervening nouns with the opposite number from the subject (meant to confuse the model). For example, given the sentence The keys to the cabinet4, the objective during training is to predict the verb are (plural). At test time, we then evaluate the ranking accuracy of the agreement attractors: i.e. the goal is to rank are higher than is in this case. ",
+        "bbox": [
+            174,
+            578,
+            825,
+            714
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Our results are summarized in Table 2. The best LSTM with attention from the literature achieves $9 9 . 1 8 \\%$ on this task (Yogatama et al., 2018), outperforming a vanilla Transformer (Tran et al., 2018). UTs significantly outperform standard Transformers, and achieve an average result comparable to the current state of the art $( 9 9 . 2 \\% )$ . However, we see that UTs (and particularly with dynamic halting) perform progressively better than all other models as the number of attractors increases (see the last row, $\\Delta$ ). ",
+        "bbox": [
+            174,
+            720,
+            826,
+            789
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.3 LAMBADA LANGUAGE MODELING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            810,
+            465,
+            824
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The LAMBADA task (Paperno et al., 2016) is a language modeling task consisting of predicting a missing target word given a broader context of 4-5 preceding sentences. The dataset was specifically designed so that humans are able to accurately predict the target word when shown the full context, but not when only shown the target sentence in which it appears. It therefore goes beyond language modeling, and tests the ability of a model to incorporate broader discourse and longer term context when predicting the target word. ",
+        "bbox": [
+            174,
+            837,
+            825,
+            892
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/ef2169d8f79cc987440d2e099ea821c1b11a62b71bd69ca2bb5f46b9ca991864.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Model</td><td colspan=\"7\">Number of attractors</td><td rowspan=\"2\">Total</td></tr><tr><td>0</td><td>1</td><td>2</td><td>3</td><td>4</td><td>5</td></tr><tr><td colspan=\"9\">Previous best results (Yogatama et al., 2018):</td></tr><tr><td>Best Stack-RNN</td><td>0.994</td><td>0.979</td><td>0.965</td><td>0.935</td><td>0.916</td><td>0.880</td><td></td><td>0.992</td></tr><tr><td>Best LSTM</td><td>0.993</td><td>0.972</td><td>0.950</td><td></td><td>0.922</td><td>0.900</td><td>0.842</td><td>0.991</td></tr><tr><td>Best Attention</td><td>0.994</td><td>0.977</td><td>0.959</td><td></td><td>0.929</td><td>0.907</td><td>0.842</td><td>0.992</td></tr><tr><td colspan=\"9\">Our results:</td></tr><tr><td>Transformer</td><td>0.973</td><td>0.941</td><td>0.932</td><td></td><td>0.917</td><td>0.901</td><td>0.883</td><td>0.962</td></tr><tr><td>Universal Transformer</td><td>0.993</td><td>0.971</td><td>0.969</td><td></td><td>0.940</td><td>0.921</td><td>0.892</td><td>0.992</td></tr><tr><td>UT w/ ACT</td><td>0.994</td><td>0.969</td><td>0.967</td><td></td><td>0.944</td><td>0.932</td><td>0.907</td><td>0.992</td></tr><tr><td>△(UT w/ACT- Best)</td><td>0</td><td>-0.008</td><td>0.002</td><td></td><td>0.009</td><td>0.016</td><td>0.027</td><td>-</td></tr></table>",
+        "bbox": [
+            232,
+            101,
+            763,
+            286
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/fc194652941c06f78321d40d184cd47b108acfc256136d7f68721c88ae32c443.jpg",
+        "table_caption": [
+            "Table 2: Accuracy on the subject-verb agreement number prediction task (higher is better). "
+        ],
+        "table_footnote": [
+            "Table 3: LAMBADA language modeling (LM) perplexity (lower better) with accuracy in parentheses (higher better), and Reading Comprehension (RC) accuracy results (higher better). ‘-’ indicates no reported results in that setting. "
+        ],
+        "table_body": "<table><tr><td rowspan=\"2\">Model</td><td colspan=\"3\">LM Perplexity &amp; (Accuracy)</td><td colspan=\"3\">RC Accuracy</td></tr><tr><td>control</td><td>dev</td><td>test</td><td>control</td><td>dev</td><td>test</td></tr><tr><td>Neural Cache (Grave et al.,2016) Dhingra et al. Dhingra et al. (2018)</td><td>129 1</td><td>139 1</td><td></td><td></td><td></td><td>- 0.5569</td></tr><tr><td>Transformer</td><td>142 (0.19)</td><td>5122 (0.0)</td><td>7321 (0.0)</td><td>0.4102</td><td>0.4401</td><td>0.3988</td></tr><tr><td>LSTM</td><td>138 (0.23)</td><td>4966 (0.0)</td><td>5174 (0.0)</td><td>0.1103</td><td>0.2316</td><td>0.2007</td></tr><tr><td>UT base,6 steps (fixed)</td><td>131 (0.32)</td><td>279 (0.18)</td><td>319 (0.17)</td><td>0.4801</td><td>0.5422</td><td>0.5216</td></tr><tr><td>UT w/ dynamic halting</td><td>130 (0.32)</td><td>134 (0.22)</td><td>142 (0.19)</td><td>0.4603</td><td>0.5831</td><td>0.5625</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>UT base,8 steps (fixed) UT base,9 steps (fixed)</td><td>129(0.32) 129(0.33)</td><td>192 (0.21) 214 (0.21)</td><td>202 (0.18) 239 (0.17)</td><td></td><td></td><td></td></tr></table>",
+        "bbox": [
+            176,
+            308,
+            821,
+            468
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            531,
+            821,
+            559
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The task is evaluated in two settings: as language modeling (the standard setup) and as reading comprehension. In the former (more challenging) case, a model is simply trained for next-word prediction on the training data, and evaluated on the target words at test time (i.e. the model is trained to predict all words, not specifically challenging target words). In the latter setting, introduced by Chu et al. Chu et al. (2017), the target sentence (minus the last word) is used as query for selecting the target word from the context sentences. Note that the target word appears in the context $81 \\%$ of the time, making this setup much simpler. However the task is impossible in the remaining $19 \\%$ of the cases. ",
+        "bbox": [
+            174,
+            565,
+            825,
+            661
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The results are shown in Table 3. Universal Transformer achieves state-of-the-art results in both the language modeling and reading comprehension setup, outperforming both LSTMs and vanilla Transformers. Note that the control set was constructed similar to the LAMBADA development and test sets, but without filtering them in any way, so achieving good results on this set shows a model’s strength in standard language modeling. ",
+        "bbox": [
+            174,
+            667,
+            825,
+            737
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Our best fixed UT results used 6 steps. However, the average number of steps that the best UT with dynamic halting took on the test data over all positions and examples was $8 . 2 { \\pm } 2 . 1 $ . In order to see if the dynamic model did better simply because it took more steps, we trained two fixed UT models with 8 and 9 steps respectively (see last two rows). Interestingly, these two models achieve better results compared to the model with 6 steps, but do not outperform the UT with dynamic halting. This leads us to believe that dynamic halting may act as a useful regularizer for the model via incentivizing a smaller numbers of steps for some of the input symbols, while allowing more computation for others. ",
+        "bbox": [
+            174,
+            743,
+            825,
+            839
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.4 ALGORITHMIC TASKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            856,
+            366,
+            871
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We trained UTs on three algorithmic tasks, namely Copy, Reverse, and (integer) Addition, all on strings composed of decimal symbols $( ^ { \\cdot } 0 ^ { \\cdot } - ^ { \\cdot } 9 ^ { \\cdot } )$ . In all the experiments, we train the models on sequences of length 40 and evaluated on sequences of length 400 (Kaiser & Sutskever, 2016). We train UTs using positions starting with randomized offsets to further encourage the model to learn position-relative transformations. Results are shown in Table 4. The UT outperforms both LSTM and vanilla Transformer by a wide margin on all three tasks. The Neural GPU reports perfect results on this task (Kaiser & Sutskever, 2016), however we note that this result required a special curriculum-based training protocol which was not used for other models. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/1b90b1185b2b903c67a138af3fdf579dd033a1a95c134a476af8db094a1dc2ec.jpg",
+        "table_caption": [
+            "Table 4: Accuracy (higher better) on the algorithmic tasks. ∗Note that the Neural GPU was trained with a special curriculum to obtain the perfect result, while other models are trained without any curriculum. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Model</td><td colspan=\"2\">Copy</td><td colspan=\"2\">Reverse</td><td colspan=\"2\">Addition</td></tr><tr><td>char-acc</td><td>seq-acc</td><td>char-acc</td><td>seq-acc</td><td>char-acc</td><td>seq-acc</td></tr><tr><td>LSTM</td><td>0.45</td><td>0.09</td><td>0.66</td><td>0.11</td><td>0.08</td><td>0.0</td></tr><tr><td>Transformer</td><td>0.53</td><td>0.03</td><td>0.13</td><td>0.06</td><td>0.07</td><td>0.0</td></tr><tr><td>Universal Transformer</td><td>0.91</td><td>0.35</td><td>0.96</td><td>0.46</td><td>0.34</td><td>0.02</td></tr><tr><td>Neural GPU*</td><td>1.0</td><td>1.0</td><td>1.0</td><td>1.0</td><td>1.0</td><td>1.0</td></tr></table>",
+        "bbox": [
+            222,
+            113,
+            774,
+            212
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/9e15d01bff4909a1ef6f53289ff3213927179cb682f47427d472066da438451d.jpg",
+        "table_caption": [
+            "Table 5: Character-level (char-acc) and sequence-level accuracy (seq-acc) results on the Memorization LTE tasks, with maximum length of 55. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"2\">Copy</td><td colspan=\"2\">Double</td><td colspan=\"2\">Reverse</td></tr><tr><td>Model</td><td>char-acc</td><td>seq-acc</td><td>char-acc</td><td>seq-acc</td><td>char-acc</td><td>seq-acc</td></tr><tr><td>LSTM</td><td>0.78</td><td>0.11</td><td>0.51</td><td>0.047</td><td>0.91</td><td>0.32</td></tr><tr><td>Transformer</td><td>0.98</td><td>0.63</td><td>0.94</td><td>0.55</td><td>0.81</td><td>0.26</td></tr><tr><td>Universal Transformer</td><td>1.0</td><td>1.0</td><td>1.0</td><td>1.0</td><td>1.0</td><td>1.0</td></tr></table>",
+        "bbox": [
+            222,
+            255,
+            774,
+            340
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/f2b1e076b1f694afa1e69b3a016ec625a26ae2aca583a35f363bad271f7e367c.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Table 6: Character-level (char-acc) and sequence-level accuracy (seq-acc) results on the Program Evaluation LTE tasks with maximum nesting of 2 and length of 5. "
+        ],
+        "table_body": "<table><tr><td></td><td colspan=\"2\">Program</td><td colspan=\"2\">Control</td><td colspan=\"2\">Addition</td></tr><tr><td>Model</td><td>char-acc</td><td>seq-acc</td><td>char-acc</td><td>seq-acc</td><td>char-acc</td><td>seq-acc</td></tr><tr><td>LSTM</td><td>0.53</td><td>0.12</td><td>0.68</td><td>0.21</td><td>0.83</td><td>0.11</td></tr><tr><td>Transformer</td><td>0.71</td><td>0.29</td><td>0.93</td><td>0.66</td><td>1.0</td><td>1.0</td></tr><tr><td>Universal Transformer</td><td>0.89</td><td>0.63</td><td>1.0</td><td>1.0</td><td>1.0</td><td>1.0</td></tr></table>",
+        "bbox": [
+            220,
+            383,
+            774,
+            470
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            526,
+            825,
+            594
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "3.5 LEARNING TO EXECUTE (LTE) ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            622,
+            428,
+            637
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "As another class of sequence-to-sequence learning problems, we also evaluate UTs on tasks indicating the ability of a model to learn to execute computer programs, as proposed in (Zaremba & Sutskever, 2015). These tasks include program evaluation tasks (program, control, and addition), and memorization tasks (copy, double, and reverse). ",
+        "bbox": [
+            174,
+            652,
+            825,
+            708
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We use the mix-strategy discussed in (Zaremba & Sutskever, 2015) to generate the datasets. Unlike (Zaremba & Sutskever, 2015), we do not use any curriculum learning strategy during training and we make no use of target sequences at test time. Tables 5 and 6 present the performance of an LSTM model, Transformer, and Universal Transformer on the program evaluation and memorization tasks, respectively. UT achieves perfect scores in all the memorization tasks and also outperforms both LSTMs and Transformers in all program evaluation tasks by a wide margin. ",
+        "bbox": [
+            174,
+            714,
+            825,
+            797
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "3.6 MACHINE TRANSLATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            825,
+            387,
+            839
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We trained a UT on the WMT 2014 English-German translation task using the same setup as reported in (Vaswani et al., 2017) in order to evaluate its performance on a large-scale sequence-to-sequence task. Results are summarized in Table 7. The UT with a fully-connected recurrent transition function (instead of separable convolution) and without ACT improves by 0.9 BLEU over a Transformer and 0.5 BLEU over a Weighted Transformer with approximately the same number of parameters (Ahmed et al., 2017). ",
+        "bbox": [
+            174,
+            854,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/52b057d5336a0a53077ac512df32473f843ec58180d0f5b31ad97a1c477cd211.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Table 7: Machine translation results on the WMT14 En-De translation task trained on 8xP100 GPUs in comparable training setups. All base results have the same number of parameters. "
+        ],
+        "table_body": "<table><tr><td>Model</td><td>BLEU</td></tr><tr><td>Universal Transformer small</td><td>26.8</td></tr><tr><td>Transformer base (Vaswani et al.,2017)</td><td>28.0</td></tr><tr><td>Weighted Transformer base (Ahmed etal.,2017)</td><td>28.4</td></tr><tr><td>Universal Transformer base</td><td>28.9</td></tr></table>",
+        "bbox": [
+            313,
+            101,
+            681,
+            181
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4 DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            233,
+            310,
+            250
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "When running for a fixed number of steps, the Universal Transformer is equivalent to a multi-layer Transformer with tied parameters across all its layers. This is partly similar to the Recursive Transformer, which ties the weights of its self-attention layers across depth (Gulcehre et al., 2018)5. However, as the per-symbol recurrent transition functions can be applied any number of times, another and possibly more informative way of characterizing the UT is as a block of parallel RNNs (one for each symbol, with shared parameters) evolving per-symbol hidden states concurrently, generated at each step by attending to the sequence of hidden states at the previous step. In this way, it is related to architectures such as the Neural GPU (Kaiser & Sutskever, 2016) and the Neural Turing Machine (Graves et al., 2014). UTs thereby retain the attractive computational efficiency of the original feedforward Transformer model, but with the added recurrent inductive bias of RNNs. Furthermore, using a dynamic halting mechanism, UTs can choose the number of processing steps based on the input data. ",
+        "bbox": [
+            174,
+            270,
+            825,
+            420
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The connection between the Universal Transformer and other sequence models is apparent from the architecture: if we limited the recurrent steps to one, it would be a Transformer. But it is more interesting to consider the relationship between the Universal Transformer and RNNs and other networks where recurrence happens over the time dimension. Superficially these models may seem closely related since they are recurrent as well. But there is a crucial difference: time-recurrent models like RNNs cannot access memory in the recurrent steps. This makes them computationally more similar to automata, since the only memory available in the recurrent part is a fixed-size state vector. UTs on the other hand can attend to the whole previous layer, allowing it to access memory in the recurrent step. ",
+        "bbox": [
+            174,
+            426,
+            825,
+            536
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Given sufficient memory the Universal Transformer is computationally universal – i.e. it belongs to the class of models that can be used to simulate any Turing machine, thereby addressing a shortcoming of the standard Transformer model 6. In addition to being theoretically appealing, our results show that this added expressivity also leads to improved accuracy on several challenging sequence modeling tasks. This closes the gap between practical sequence models competitive on large-scale tasks such as machine translation, and computationally universal models such as the Neural Turing Machine or the Neural GPU (Graves et al., 2014; Kaiser & Sutskever, 2016), which can be trained using gradient descent to perform algorithmic tasks. ",
+        "bbox": [
+            173,
+            542,
+            825,
+            651
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "To show this, we can reduce a Neural GPU to a Universal Transformer. Ignoring the decoder and parameterizing the self-attention module, i.e. self-attention with the residual connection, to be the identity function, we assume the transition function to be a convolution. If we now set the total number of recurrent steps $T$ to be equal to the input length, we obtain exactly a Neural GPU. Note that the last step is where the Universal Transformer crucially differs from the vanilla Transformer whose depth cannot scale dynamically with the size of the input. A similar relationship exists between the Universal Transformer and the Neural Turing Machine, whose single read/write operations per step can be expressed by the global, parallel representation revisions of the Universal Transformer. In contrast to these models, however, which only perform well on algorithmic tasks, the Universal Transformer also achieves competitive results on realistic natural language tasks such as LAMBADA and machine translation. ",
+        "bbox": [
+            174,
+            659,
+            825,
+            795
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Another related model architecture is that of end-to-end Memory Networks (Sukhbaatar et al., 2015). In contrast to end-to-end memory networks, however, the Universal Transformer uses memory corresponding to states aligned to individual positions of its inputs or outputs. Furthermore, the Universal Transformer follows the encoder-decoder configuration and achieves competitive performance in large-scale sequence-to-sequence tasks. ",
+        "bbox": [
+            174,
+            801,
+            825,
+            869
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            318,
+            118
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "This paper introduces the Universal Transformer, a generalization of the Transformer model that extends its theoretical capabilities and produces state-of-the-art results on a wide range of challenging sequence modeling tasks, such as language understanding but also a variety of algorithmic tasks, thereby addressing a key shortcoming of the standard Transformer. The Universal Transformer combines the following key properties into one model: ",
+        "bbox": [
+            174,
+            133,
+            825,
+            202
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Weight sharing: Following intuitions behind weight sharing found in CNNs and RNNs, we extend the Transformer with a simple form of weight sharing that strikes an effective balance between inductive bias and model expressivity, which we show extensively on both small and large-scale experiments. ",
+        "bbox": [
+            174,
+            208,
+            825,
+            251
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Conditional computation: In our goal to build a computationally universal machine, we equipped the Universal Transformer with the ability to halt or continue computation through a recently introduced mechanism, which shows stronger results compared to the fixed-depth Universal Transformer. ",
+        "bbox": [
+            176,
+            257,
+            825,
+            297
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We are enthusiastic about the recent developments on parallel-in-time sequence models. By adding computational capacity and recurrence in processing depth, we hope that further improvements beyond the basic Universal Transformer presented here will help us build learning algorithms that are both more powerful, data efficient, and generalize beyond the current state-of-the-art. ",
+        "bbox": [
+            174,
+            305,
+            825,
+            359
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The code used to train and evaluate Universal Transformers is available at https: //github.com/tensorflow/tensor2tensor (Vaswani et al., 2018). ",
+        "bbox": [
+            174,
+            375,
+            821,
+            402
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgements We are grateful to Ashish Vaswani, Douglas Eck, and David Dohan for their fruitful comments and inspiration. ",
+        "bbox": [
+            173,
+            426,
+            825,
+            454
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            474,
+            285,
+            489
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Karim Ahmed, Nitish Shirish Keskar, and Richard Socher. Weighted transformer network for machine translation. arXiv preprint arXiv:1711.02132, 2017.   \nJimmy Lei Ba, Jamie Ryan Kiros, and Geoffrey E Hinton. Layer normalization. arXiv preprint arXiv:1607.06450, 2016. URL http://arxiv.org/abs/1607.06450.   \nDzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. CoRR, abs/1409.0473, 2014. URL http://arxiv.org/abs/1409.0473.   \nKyunghyun Cho, Bart van Merrienboer, Caglar Gulcehre, Fethi Bougares, Holger Schwenk, and Yoshua Bengio. Learning phrase representations using RNN encoder-decoder for statistical machine translation. CoRR, abs/1406.1078, 2014. URL http://arxiv.org/abs/1406.1078.   \nFrancois Chollet. Xception: Deep learning with depthwise separable convolutions. arXiv preprint arXiv:1610.02357, 2016.   \nZewei Chu, Hai Wang, Kevin Gimpel, and David McAllester. Broad context language modeling as reading comprehension. In Proceedings of the 15th Conference of the European Chapter of the Association for Computational Linguistics: Volume 2, Short Papers, volume 2, pp. 52–57, 2017.   \nBhuwan Dhingra, Zhilin Yang, William W Cohen, and Ruslan Salakhutdinov. Linguistic knowledge as memory for recurrent neural networks. arXiv preprint arXiv:1703.02620, 2017.   \nBhuwan Dhingra, Qiao Jin, Zhilin Yang, William W Cohen, and Ruslan Salakhutdinov. Neural models for reasoning over multiple mentions using coreference. arXiv preprint arXiv:1804.05922, 2018.   \nJonas Gehring, Michael Auli, David Grangier, Denis Yarats, and Yann N. Dauphin. Convolutional sequence to sequence learning. CoRR, abs/1705.03122, 2017. URL http://arxiv.org/abs/1705.03122.   \nEdouard Grave, Armand Joulin, and Nicolas Usunier. Improving neural language models with a continuous cache. arXiv preprint arXiv:1612.04426, 2016.   \nAlex Graves. Generating sequences with recurrent neural networks. CoRR, abs/1308.0850, 2013. URL http://arxiv.org/abs/1308.0850.   \nAlex Graves. Adaptive computation time for recurrent neural networks. arXiv preprint arXiv:1603.08983, 2016.   \nAlex Graves, Greg Wayne, and Ivo Danihelka. Neural turing machines. CoRR, abs/1410.5401, 2014. URL http://arxiv.org/abs/1410.5401.   \nCaglar Gulcehre, Misha Denil, Mateusz Malinowski, Ali Razavi, Razvan Pascanu, Karl Moritz Hermann, Peter Battaglia, Victor Bapst, David Raposo, Adam Santoro, et al. Hyperbolic attention networks. arXiv preprint arXiv:1805.09786, 2018.   \nMikael Henaff, Jason Weston, Arthur Szlam, Antoine Bordes, and Yann LeCun. Tracking the world state with recurrent entity networks. arXiv preprint arXiv:1612.03969, 2016.   \nSepp Hochreiter, Yoshua Bengio, Paolo Frasconi, and Jürgen Schmidhuber. Gradient flow in recurrent nets: the difficulty of learning long-term dependencies. A Field Guide to Dynamical Recurrent Neural Networks, 2003.   \nA. Joulin and T. Mikolov. Inferring algorithmic patterns with stack-augmented recurrent nets. In Advances in Neural Information Processing Systems, (NIPS), 2015.   \nŁukasz Kaiser and Ilya Sutskever. Neural GPUs learn algorithms. In International Conference on Learning Representations (ICLR), 2016. URL https://arxiv.org/abs/1511.08228.   \nŁukasz Kaiser, Aidan N. Gomez, and Francois Chollet. Depthwise separable convolutions for neural machine translation. CoRR, abs/1706.03059, 2017. URL http://arxiv.org/abs/1706.03059.   \nAnkit Kumar, Ozan Irsoy, Peter Ondruska, Mohit Iyyer, James Bradbury, Ishaan Gulrajani, Victor Zhong, Romain Paulus, and Richard Socher. Ask me anything: Dynamic memory networks for natural language processing. In International Conference on Machine Learning, pp. 1378–1387, 2016.   \nZhouhan Lin, Minwei Feng, Cicero Nogueira dos Santos, Mo Yu, Bing Xiang, Bowen Zhou, and Yoshua Bengio. A structured self-attentive sentence embedding. arXiv preprint arXiv:1703.03130, 2017.   \nTal Linzen, Emmanuel Dupoux, and Yoav Goldberg. Assessing the ability of lstms to learn syntax-sensitive dependencies. Transactions of the Association of Computational Linguistics, 4(1):521–535, 2016.   \nDenis Paperno, Germán Kruszewski, Angeliki Lazaridou, Ngoc Quan Pham, Raffaella Bernardi, Sandro Pezzelle, Marco Baroni, Gemma Boleda, and Raquel Fernandez. The lambada dataset: Word prediction requiring a broad discourse context. In Proceedings of the 54th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), volume 1, pp. 1525–1534, 2016.   \nAnkur Parikh, Oscar Täckström, Dipanjan Das, and Jakob Uszkoreit. A decomposable attention model. In Empirical Methods in Natural Language Processing, 2016. URL https: //arxiv.org/pdf/1606.01933.pdf.   \nJack Rae, Jonathan J Hunt, Ivo Danihelka, Timothy Harley, Andrew W Senior, Gregory Wayne, Alex Graves, and Tim Lillicrap. Scaling memory-augmented neural networks with sparse reads and writes. In Advances in Neural Information Processing Systems, pp. 3621–3629, 2016.   \nMinjoon Seo, Sewon Min, Ali Farhadi, and Hannaneh Hajishirzi. Query-reduction networks for question answering. arXiv preprint arXiv:1606.04582, 2016.   \nNitish Srivastava, Geoffrey E Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: a simple way to prevent neural networks from overfitting. Journal of Machine Learning Research, 15(1): 1929–1958, 2014.   \nSainbayar Sukhbaatar, arthur szlam, Jason Weston, and Rob Fergus. End-to-end memory networks. In C. Cortes, N. D. Lawrence, D. D. Lee, M. Sugiyama, and R. Garnett (eds.), Advances in Neural Information Processing Systems 28, pp. 2440–2448. Curran Associates, Inc., 2015. URL http://papers.nips.cc/paper/5846-end-to-end-memory-networks.pdf.   \nIlya Sutskever, Oriol Vinyals, and Quoc V. Le. Sequence to sequence learning with neural networks. In Advances in Neural Information Processing Systems, pp. 3104–3112, 2014. URL http://arxiv.org/abs/1409.3215.   \nKe Tran, Arianna Bisazza, and Christof Monz. The importance of being recurrent for modeling hierarchical structure. In Proceedings of NAACL’18, 2018.   \nAshish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Lukasz Kaiser, and Illia Polosukhin. Attention is all you need. CoRR, 2017. URL http://arxiv.org/abs/1706.03762.   \nAshish Vaswani, Samy Bengio, Eugene Brevdo, Francois Chollet, Aidan N. Gomez, Stephan Gouws, Llion Jones, Łukasz Kaiser, Nal Kalchbrenner, Niki Parmar, Ryan Sepassi, Noam Shazeer, and Jakob Uszkoreit. Tensor2tensor for neural machine translation. CoRR, abs/1803.07416, 2018. ",
+        "bbox": [
+            171,
+            497,
+            826,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            63,
+            828,
+            928
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jason Weston, Antoine Bordes, Sumit Chopra, Alexander M Rush, Bart van Merriënboer, Armand Joulin, and Tomas Mikolov. Towards ai-complete question answering: A set of prerequisite toy tasks. arXiv preprint arXiv:1502.05698, 2015. ",
+        "bbox": [
+            173,
+            104,
+            825,
+            142
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Dani Yogatama, Yishu Miao, Gabor Melis, Wang Ling, Adhiguna Kuncoro, Chris Dyer, and Phil Blunsom. Memory architectures in recurrent neural network language models. In International Conference on Learning Representations, 2018. URL https://openreview.net/forum?id $\\underline { { \\underline { { \\mathbf { \\Pi } } } } } =$ SkFqf0lAZ. ",
+        "bbox": [
+            176,
+            151,
+            821,
+            190
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Wojciech Zaremba and Ilya Sutskever. Learning to execute. CoRR, abs/1410.4615, 2015. URL http://arxiv.org/abs/1410.4615. ",
+        "bbox": [
+            174,
+            199,
+            825,
+            224
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/5f564a4ed338c4ad846f158feb7380a4bf03826b912138eb324e8a3f5e31016b.jpg",
+        "image_caption": [
+            "Figure 4: The Universal Transformer with position and step embeddings as well as dropout and layer normalization. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            187,
+            140,
+            808,
+            622
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX B ON THE COMPUTATIONAL POWER OF UT VS TRANSFORMER ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            690,
+            795,
+            708
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "With respect to their computational power, the key difference between the Transformer and the Universal Transformer lies in the number of sequential steps of computation (i.e. in depth). While a standard Transformer executes a total number of operations that scales with the input size, the number of sequential operations is constant, independent of the input size and determined solely by the number of layers. Assuming finite precision, this property implies that the standard Transformer cannot be computationally universal. When choosing a number of steps as a function of the input length, however, the Universal Transformer does not suffer from this limitation. Note that this holds independently of whether or not adaptive computation time is employed but does assume a non-constant, even if possibly deterministic, number of steps. Varying the number of steps dynamically after training is enabled by sharing weights across sequential computation steps in the Universal Transformer. ",
+        "bbox": [
+            173,
+            723,
+            826,
+            837
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "An intuitive example are functions whose execution requires the sequential processing of each input element. In this case, for any given choice of depth $T$ , one can construct an input sequence of length $N > T$ that cannot be processed correctly by a standard Transformer. With an appropriate, input-length dependent choice of sequential steps, however, a Universal Transformer, RNNs or Neural GPUs can execute such a function. ",
+        "bbox": [
+            174,
+            843,
+            565,
+            929
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/97c3cbbe9fcf8d4d7ee8b9d381cd5a87ee67d792e9d0b1b91f1288ddc76c6b98.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            604,
+            842,
+            777,
+            945
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX C UT WITH DYNAMIC HALTING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            547,
+            118
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We implement the dynamic halting based on ACT (Graves, 2016) as follows in TensorFlow. In each step of the UT with dynamic halting, we are given the halting probabilities, remainders, number of updates up to that point, and the previous state (all initialized as zeros), as well as a scalar threshold between 0 and 1 (a hyper-parameter). We then compute the new state for each position and calculate the new per-position halting probabilities based on the state for each position. The UT then decides to halt for some positions that crossed the threshold, and updates the state of other positions until the model halts for all positions or reaches a predefined maximum number of steps: ",
+        "bbox": [
+            173,
+            132,
+            825,
+            208
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "# W h i l e−l o o p s t o p s when t h i s p r e d i c a t e i s FALSE   \n2 # i . e . a l l ( ( p r o b a b i l i t y $<$ t h r e s h o l d ) & ( c o u n t e r $<$ m a x _ s t e p s ) ) a r e f a l s e d e f s h o u l d _ c o n t i n u e ( u0 , u1 , h a l t i n g _ p r o b a b i l i t y , u2 , n _ u p d a t e s , u 3 ) : r e t u r n t f . r e d u c e _ a n y (   \n5 t f . l o g i c a l _ a n d (   \n6 t f . l e s s ( h a l t i n g _ p r o b a b i l i t y , t h r e s h o l d ) ,   \n7 t f . l e s s ( n _ u p d a t e s , m a x _ s t e p s ) ) )   \n8 # Do w h i l e l o o p i t e r a t i o n s u n t i l p r e d i c a t e a b o v e i s f a l s e   \n9 _ , _ , r e m a i n d e r , n _ u p d a t e s , n e w _ s t a t e ) $=$ t f . w h i l e _ l o o p (   \n10 s h o u l d _ c o n t i n u e , u t _ w i t h _ d y n a m i c _ h a l t i n g , ( s t a t e ,   \n11 s t e p , h a l t i n g _ p r o b a b i l i t y , r e m a i n d e r s , n _ u p d a t e s , p r e v i o u s _ s t a t e ) ) ",
+        "bbox": [
+            158,
+            215,
+            815,
+            353
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "The following shows the computations in each step: ",
+        "bbox": [
+            174,
+            387,
+            473,
+            401
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "d e f u t _ w i t h _ d y n a m i c _ h a l t i n g ( s t a t e , s t e p , h a l t i n g _ p r o b a b i l i t y ,   \n2 r e m a i n d e r s , n _ u p d a t e s , p r e v i o u s _ s t a t e ) :   \n3 # C a l c u l a t e t h e p r o b a b i l i t i e s b a s e d o n t h e s t a t e   \n4 $\\mathrm { ~ \\bf ~ p ~ } =$ c o m m o n _ l a y e r s . d e n s e ( s t a t e , 1 , a c t i v a t i o $\\mathbf { n } = 1$ t f . n n . s i g m o i d ,   \n5 u s e _ b i a ${ \\bf { S } } =$ T r u e )   \n6 # Mask f o r i n p u t s w h i c h h a v e n o t h a l t e d y e t   \n7 s t i l l _ r u n n i n g $=$ t f . c a s t (   \n9 8 # Mask o f i n p u t s w h i c h h a l t e d a t t h i s s t e p t f . l e s s ( h a l t i n g _ p r o b a b i l i t y , 1 . 0 ) , t f . f l o a t 3 2 )   \n10 n e w _ h a l t e d $=$ t f . c a s t (   \n11 t f . g r e a t e r ( h a l t i n g _ p r o b a b i l i t y $^ +$ p $^ *$ s t i l l _ r u n n i n g , t h r e s h o l d ) ,   \n12 t f . f l o a t 3 2 ) $^ *$ s t i l l _ r u n n i n g   \n13 # Mask o f i n p u t s w h i c h h a v e n ’ t h a l t e d , a n d d i d n ’ t h a l t t h i s s t e p   \n14 s t i l l _ r u n n i n g $=$ t f . c a s t (   \n15 t f . l e s s _ e q u a l ( h a l t i n g _ p r o b a b i l i t y + p ∗ s t i l l _ r u n n i n g ,   \n16 t h r e s h o l d ) , t f . f l o a t 3 2 ) $^ *$ s t i l l _ r u n n i n g   \n17 # Add t h e h a l t i n g p r o b a b i l i t y f o r t h i s s t e p t o t h e h a l t i n g   \n18 # p r o b a b i l i t i e s f o r t h o s e i n p u t s w h i c h h a v e n ’ t h a l t e d y e t   \n19 h a l t i n g _ p r o b a b i l i t y $+ = \\texttt { p } *$ s t i l l _ r u n n i n g   \n20 # Compute r e m a i n d e r s f o r t h e i n p u t s w h i c h h a l t e d a t t h i s s t e p   \n21 r e m a i n d e r s $+ =$ n e w _ h a l t e d $^ *$ ( 1 − h a l t i n g _ p r o b a b i l i t y )   \n22 # Add t h e r e m a i n d e r s t o t h o s e i n p u t s w h i c h h a l t e d a t t h i s s t e p   \n23 h a l t i n g _ p r o b a b i l i t y $+ =$ n e w _ h a l t e d $^ *$ r e m a i n d e r s   \n24 # I n c r e m e n t n _ u p d a t e s f o r a l l i n p u t s w h i c h a r e s t i l l r u n n i n g   \n25 n _ u p d a t e s $+ =$ s t i l l _ r u n n i n g $^ +$ n e w _ h a l t e d   \n26 # Compute t h e w e i g h t t o b e a p p l i e d t o t h e new s t a t e a n d o u t p u t :   \n27 # 0 when t h e i n p u t h a s a l r e a d y h a l t e d ,   \n28 # p when t h e i n p u t h a s n ’ t h a l t e d y e t ,   \n29 # t h e r e m a i n d e r s when i t h a l t e d t h i s s t e p .   \n30 u p d a t e _ w e i g h t s $=$ t f . e x p a n d _ d i m s ( p $^ *$ s t i l l _ r u n n i n g +   \n31 n e w _ h a l t e d $^ *$ r e m a i n d e r s , −1)   \n32 $\\#$ A p p l y t r a n s f o r m a t i o n t o t h e s t a t e   \n33 t r a n s f o r m e d _ s t a t e $=$ t r a n s i t i o n _ f u n c t i o n ( s e l f _ a t t e n t i o n ( s t a t e ) )   \n34 # I n t e r p o l a t e t r a n s f o r m e d a n d p r e v i o u s s t a t e s f o r non−h a l t e d i n p u t s   \n35 n e w _ s t a t e $=$ ( ( t r a n s f o r m e d _ s t a t e $^ *$ u p d a t e _ w e i g h t s ) $^ +$   \n36 ( p r e v i o u s _ s t a t e $^ *$ ( 1 − u p d a t e _ w e i g h t s ) ) )   \n37 s t e p $+ = ~ 1$   \n38 r e t u r n ( t r a n s f o r m e d _ s t a t e , s t e p , h a l t i n g _ p r o b a b i l i t y ,   \n39 r e m a i n d e r s , n _ u p d a t e s , n e w _ s t a t e ) ",
+        "bbox": [
+            151,
+            404,
+            816,
+            893
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Listing 2: Computations in each step of the UT with dynamic halting. ",
+        "bbox": [
+            272,
+            893,
+            722,
+            909
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX D DESCRIPTION OF SOME OF THE TASKS/DATASETS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            709,
+            118
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Here, we provide some additional details on the bAbI, subject-verb agreement, LAMBADA language modeling, and learning to execute (LTE) tasks. ",
+        "bbox": [
+            173,
+            132,
+            825,
+            157
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "D.1 BABI QUESTION-ANSWERING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            174,
+            426,
+            189
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "The bAbi question answering dataset (Weston et al., 2015) consists of 20 different synthetic tasks7. The aim is that each task tests a unique aspect of language understanding and reasoning, including the ability of: reasoning from supporting facts in a story, answering true/false type questions, counting, understanding negation and indefinite knowledge, understanding coreferences, time reasoning, positional and size reasoning, path-finding, and understanding motivations (to see examples for each of these tasks, please refer to Table 1 in (Weston et al., 2015)). ",
+        "bbox": [
+            174,
+            199,
+            825,
+            262
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "There are two versions of the dataset, one with 1k training examples and the other with 10k examples. It is important for a model to be data-efficient to achieve good results using only the 1k training examples. Moreover, the original idea is that a single model should be evaluated across all the tasks (not tuning per task), which is the train joint setup in Table 1, and the tables presented in Appendix E. ",
+        "bbox": [
+            174,
+            268,
+            825,
+            319
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "D.2 SUBJECT-VERB AGREEMENT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            335,
+            418,
+            349
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Subject-verb agreement is the task of predicting number agreement between subject and verb in English sentences. Succeeding in this task is a strong indicator that a model can learn to approximate syntactic structure and therefore it was proposed by Linzen et al. (2016) as proxy for assessing the ability of different models to capture hierarchical structure in natural language. ",
+        "bbox": [
+            176,
+            361,
+            825,
+            411
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Two experimental setups were proposed by Linzen et al. (2016) for training a model on this task: 1) training with a language modeling objective, i.e., next word prediction, and 2) as binary classification, i.e. predicting the number of the verb given the sentence. In this paper, we use the language modeling objective, meaning that we provide the model with an implicit supervision and evaluate based on the ranking accuracy of the correct form of the verb compared to the incorrect form of the verb. ",
+        "bbox": [
+            174,
+            417,
+            825,
+            479
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "In this task, in order to have different levels of difficulty, “agreement attractors” are used, i.e. one or more intervening nouns with the opposite number from the subject with the goal of confusing the model. In this case, the model needs to correctly identify the head of the syntactic subject that corresponds to a given verb and ignore the intervening attractors in order to predict the correct form of that verb. Here are some examples for this task in which subjects and the corresponding verbs are in boldface and agreement attractors are underlined: ",
+        "bbox": [
+            174,
+            487,
+            821,
+            549
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "No attractor: The boy smiles.   \nOne attractor: The number of men is not clear.   \nTwo attractors: The ratio of men to women is not clear.   \nThree attractors: The ratio of men to women and children is not clear. ",
+        "bbox": [
+            183,
+            563,
+            725,
+            604
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "D.3 LAMBADA LANGUAGE MODELING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            637,
+            468,
+            651
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "The LAMBADA task (Paperno et al., 2016) is a broad context language modeling task. In this task, given a narrative passage, the goal is to predict the last word (target word) of the last sentence (target sentence) in the passage. These passages are specifically selected in a way that human subjects are easily able to guess their last word if they are exposed to a long passage, but not if they only see the target sentence preceding the target word8. Here is a sample from the dataset: ",
+        "bbox": [
+            174,
+            662,
+            826,
+            727
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Context: ",
+        "text_level": 1,
+        "bbox": [
+            183,
+            741,
+            246,
+            751
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "“Yes, I thought I was going to lose the baby.” “I was scared too,” he stated, sincerity flooding his eyes. “You were?” “Yes, of course. Why do you even ask?” “This baby wasn’t exactly planned for.”   \nTarget sentence: “Do you honestly think that I would want you to have a _?”   \nTarget word: miscarriage ",
+        "bbox": [
+            183,
+            747,
+            816,
+            833
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "The LAMBADA task consists in predicting the target word given the whole passage (i.e., the context plus the target sentence). A “control set” is also provided which was constructed by randomly sampling passages of the same shape and size as the ones used to build LAMBADA, but without filtering them in any way. The control set is used to evaluate the models at standard language modeling before testing on the LAMBADA task, and therefore to ensure that low performance on the latter cannot be attributed simply to poor language modeling. ",
+        "bbox": [
+            176,
+            848,
+            823,
+            886
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            104,
+            823,
+            131
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "The task is evaluated in two settings: as language modeling (the standard setup) and as reading comprehension. In the former (more challenging) case, a model is simply trained for the next word prediction on the training data, and evaluated on the target words at test time (i.e. the model is trained to predict all words, not specifically challenging target words). In this paper, we report the results of the Universal Transformer in both setups. ",
+        "bbox": [
+            174,
+            137,
+            825,
+            186
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "D.4 LEARNING TO EXECUTE (LTE) ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            203,
+            431,
+            217
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "LTE is a set of tasks indicating the ability of a model to learn to execute computer programs and was proposed by Zaremba & Sutskever (2015). These tasks include two subsets: 1) program evaluation tasks (program, control, and addition) that are designed to assess the ability of models for understanding numerical operations, if-statements, variable assignments, the compositionality of operations, and more, as well as 2) memorization tasks (copy, double, and reverse). ",
+        "bbox": [
+            174,
+            228,
+            825,
+            290
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "The difficulty of the program evaluation tasks is parameterized by their length and nesting. The length parameter is the number of digits in the integers that appear in the programs (so the integers are chosen uniformly from [1, length]), and the nesting parameter is the number of times we are allowed to combine the operations with each other. Higher values of nesting yield programs with deeper parse trees. For instance, here is a program that is generated with length $= 4$ and nesting $= 3$ . ",
+        "bbox": [
+            174,
+            297,
+            825,
+            359
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Input: $\\dot { ] } = 8 5 8 4$ for x in range(8): $y + = 9 2 0$ $b = ( 1 5 0 0 + \\mathrm { j }$ ) print((b+7567))   \nTarget: 25011 ",
+        "bbox": [
+            181,
+            373,
+            395,
+            454
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "table",
+        "img_path": "images/4f51958984b0e4ab087723c7f61119ab3025a76fb92070a61db6cd4924c45a24.jpg",
+        "table_caption": [
+            "APPENDIX E BABI DETAILED RESULTS "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"5\">Best seed run for each task (out of 1O runs)</td></tr><tr><td rowspan=\"2\">Task id</td><td colspan=\"2\">10K</td><td colspan=\"2\">1K</td></tr><tr><td> train single</td><td>train joint</td><td> train single</td><td>train joint</td></tr><tr><td>1</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td></tr><tr><td>2</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.5</td></tr><tr><td>3</td><td>0.4</td><td>1.2</td><td>3.7</td><td>5.4</td></tr><tr><td>4</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td></tr><tr><td>5</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.5</td></tr><tr><td>6</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.5</td></tr><tr><td>7</td><td>0.0</td><td>0.0</td><td>0.0</td><td>3.2</td></tr><tr><td>8</td><td>0.0</td><td>0.0</td><td>0.0</td><td>1.6</td></tr><tr><td>9</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.2</td></tr><tr><td>10</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.4</td></tr><tr><td>11</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.1</td></tr><tr><td>12</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td></tr><tr><td>13</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.6</td></tr><tr><td>14</td><td>0.0</td><td>0.0</td><td>0.0</td><td>3.8</td></tr><tr><td>15</td><td>0.0</td><td>0.0</td><td>0.0</td><td>5.9</td></tr><tr><td>16</td><td>0.4</td><td>1.2</td><td>5.8</td><td>15.4</td></tr><tr><td>17</td><td>0.6</td><td>0.2</td><td>32.0</td><td>42.9</td></tr><tr><td>18</td><td>0.0</td><td>0.0</td><td>0.0</td><td>4.1</td></tr><tr><td>19</td><td>2.8</td><td>3.1</td><td>47.1</td><td>68.2</td></tr><tr><td>20</td><td>0.0</td><td>0.0</td><td>2.4</td><td>2.4</td></tr><tr><td>avg err</td><td>0.21</td><td>0.29</td><td>4.55</td><td>7.78</td></tr><tr><td>failed</td><td>0</td><td>0</td><td>3</td><td>5</td></tr></table>",
+        "bbox": [
+            287,
+            125,
+            712,
+            511
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "table",
+        "img_path": "images/707cb91ca7d4a6505bceacec0f78c21dad5887a956d574c135fece37c961afc0.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"5\">Average (±var) over all seeds (for 1O runs)</td></tr><tr><td rowspan=\"2\">Task id</td><td colspan=\"2\">10K</td><td colspan=\"2\">1K</td></tr><tr><td>train single</td><td>train joint</td><td>train single</td><td>train joint</td></tr><tr><td>1</td><td>0.0±0.0</td><td>0.0±0.0</td><td>0.2 ±0.3</td><td>0.1±0.2</td></tr><tr><td>2</td><td>0.2 ±0.4</td><td>1.7 ±2.6</td><td>3.2 ±4.1</td><td>4.3 ±11.6</td></tr><tr><td>3</td><td>1.8 ±1.8</td><td>4.6 ±7.3</td><td>9.1 ±12.7</td><td>14.3 ±18.1</td></tr><tr><td>4</td><td>0.1 ±0.1</td><td>0.2 ±0.1</td><td>0.3 ±0.3</td><td>0.4±0.6</td></tr><tr><td>5</td><td>0.2 ±0.3</td><td>0.8 ±0.5</td><td>1.1 ±1.3</td><td>4.3 ±5.6</td></tr><tr><td>6</td><td>0.1 ±0.2</td><td>0.1±0.2</td><td>1.2 ±2.1</td><td>0.8 ±0.4</td></tr><tr><td>7</td><td>0.3 ±0.5</td><td>1.1 ±1.5</td><td>0.0 ±0.0</td><td>4.1 ±2.9</td></tr><tr><td>8</td><td>0.3 ±0.2</td><td>0.5 ±1.1</td><td>0.1±0.2</td><td>3.9 ±4.2</td></tr><tr><td>9</td><td>0.0±0.0</td><td>0.0±0.0</td><td>0.1 ±0.1</td><td>0.3 ±0.3</td></tr><tr><td>10</td><td>0.1 ±0.2</td><td>0.5 ±0.4</td><td>0.7 ±0.8</td><td>1.3 ±1.6</td></tr><tr><td>11</td><td>0.0±0.0</td><td>0.1 ±0.1</td><td>0.4±0.8</td><td>0.3 ±0.9</td></tr><tr><td>12</td><td>0.2 ±0.1</td><td>0.4±0.4</td><td>0.6 ±0.9</td><td>0.3 ±0.4</td></tr><tr><td>13</td><td>0.2 ±0.5</td><td>0.3 ±0.4</td><td>0.8 ±0.9</td><td>1.1 ±0.9</td></tr><tr><td>14</td><td>1.8 ±2.6</td><td>1.3 ±1.6</td><td>0.1 ±0.2</td><td>4.7 ±5.2</td></tr><tr><td>15</td><td>2.1 ±3.4</td><td>1.6 ±2.8</td><td>0.3 ±0.5</td><td>10.3 ±8.6</td></tr><tr><td>16</td><td>1.9 ±2.2</td><td>0.9 ±1.3</td><td>9.1 ±8.1</td><td>34.1 ±22.8</td></tr><tr><td>17</td><td>1.6 ±0.8</td><td>1.4 ±3.4</td><td>43.7 ±18.6</td><td>51.1 ±12.9</td></tr><tr><td>18</td><td>0.3 ±0.4</td><td>0.7 ±1.4</td><td>2.3 ±3.6</td><td>12.8 ±9.0</td></tr><tr><td>19</td><td>3.4 ±4.0</td><td>6.1 ±7.3</td><td>50.2 ±8.4</td><td>73.1 ±23.9</td></tr><tr><td>20</td><td>0.0±0.0</td><td>0.0±0.0</td><td>3.2 ±2.5</td><td>2.6 ±2.8</td></tr><tr><td>avg</td><td>0.73 ±0.89</td><td>1.12 ±1.62</td><td>6.34 ±3.32</td><td>11.21 ±6.65</td></tr></table>",
+        "bbox": [
+            276,
+            534,
+            725,
+            897
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX F BABI ATTENTION VISUALIZATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            583,
+            118
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "We present a visualization of the attention distributions on bAbI tasks for a couple of examples. The visualization of attention weights is over different time steps based on different heads over all the facts in the story and a question. Different color bars on the left side indicate attention weights based on different heads (4 heads in total). ",
+        "bbox": [
+            173,
+            132,
+            825,
+            170
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "image",
+        "img_path": "images/f3a8b180baa16b5f9ca5ac95879283ae0e32e4a8ef49f091fa354a9fde3e930f.jpg",
+        "image_caption": [
+            "Figure 5: Visualization of the attention distributions, when encoding the question: “Where is Mary?”. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            176,
+            821,
+            715
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "image",
+        "img_path": "images/633232030ca5d5b1aa8ec04cd5838358dadf985ee0d80a2f625cf4954a6e4396.jpg",
+        "image_caption": [
+            "Figure 6: Visualization of the attention distributions, when encoding the question: “Where is the apple?”. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            227,
+            803,
+            756
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "text",
+        "text": "An example from tasks 2: ",
+        "text_level": 1,
+        "bbox": [
+            184,
+            125,
+            364,
+            136
+        ],
+        "page_idx": 19
+    },
+    {
+        "type": "text",
+        "text": "(requiring two supportive facts to solve) ",
+        "text_level": 1,
+        "bbox": [
+            383,
+            123,
+            697,
+            136
+        ],
+        "page_idx": 19
+    },
+    {
+        "type": "text",
+        "text": "Story: ",
+        "bbox": [
+            184,
+            145,
+            230,
+            155
+        ],
+        "page_idx": 19
+    },
+    {
+        "type": "text",
+        "text": "John went to the hallway.   \nJohn went back to the bathroom.   \nJohn grabbed the milk there.   \nSandra went back to the office.   \nSandra journeyed to the kitchen.   \nSandra got the apple there.   \nSandra dropped the apple there.   \nJohn dropped the milk. ",
+        "bbox": [
+            383,
+            154,
+            629,
+            236
+        ],
+        "page_idx": 19
+    },
+    {
+        "type": "text",
+        "text": "Question: ",
+        "text_level": 1,
+        "bbox": [
+            184,
+            244,
+            254,
+            256
+        ],
+        "page_idx": 19
+    },
+    {
+        "type": "text",
+        "text": "Model’s output: ",
+        "bbox": [
+            184,
+            265,
+            299,
+            276
+        ],
+        "page_idx": 19
+    },
+    {
+        "type": "image",
+        "img_path": "images/e1033d6c9551721f801f303de488b01d8481d1a4c75f090a3c4b7004f0a66c0b.jpg",
+        "image_caption": [
+            "Figure 7: Visualization of the attention distributions, when encoding the question: “Where is the milk?”. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            220,
+            296,
+            779,
+            868
+        ],
+        "page_idx": 19
+    },
+    {
+        "type": "text",
+        "text": "Story: ",
+        "text_level": 1,
+        "bbox": [
+            184,
+            299,
+            230,
+            309
+        ],
+        "page_idx": 20
+    },
+    {
+        "type": "text",
+        "text": "Mary got the milk. ",
+        "bbox": [
+            184,
+            310,
+            320,
+            319
+        ],
+        "page_idx": 20
+    },
+    {
+        "type": "text",
+        "text": "John moved to the bedroom.   \nDaniel journeyed to the office.   \nJohn grabbed the apple there.   \nJohn got the football.   \nJohn journeyed to the garden.   \nMary left the milk.   \nJohn left the football.   \nDaniel moved to the garden.   \nDaniel grabbed the football.   \nMary moved to the hallway.   \nMary went to the kitchen.   \nJohn put down the apple there.   \nJohn picked up the apple.   \nSandra moved to the hallway.   \nDaniel left the football there.   \nDaniel took the football.   \nJohn travelled to the kitchen.   \nDaniel dropped the football.   \nJohn dropped the apple.   \nJohn grabbed the apple.   \nJohn went to the office.   \nSandra went back to the bedroom.   \nSandra took the milk.   \nJohn journeyed to the bathroom.   \nJohn travelled to the office.   \nSandra left the milk.   \nMary went to the bedroom.   \nMary moved to the office.   \nJohn travelled to the hallway.   \nSandra moved to the garden.   \nMary moved to the kitchen.   \nDaniel took the football.   \nMary journeyed to the bedroom.   \nMary grabbed the milk there.   \nMary discarded the milk.   \nJohn went to the garden.   \nJohn discarded the apple there. ",
+        "bbox": [
+            383,
+            320,
+            629,
+            693
+        ],
+        "page_idx": 20
+    },
+    {
+        "type": "text",
+        "text": "Question: ",
+        "text_level": 1,
+        "bbox": [
+            184,
+            702,
+            253,
+            712
+        ],
+        "page_idx": 20
+    },
+    {
+        "type": "text",
+        "text": "Where was the apple before the bathroom? ",
+        "bbox": [
+            385,
+            712,
+            689,
+            722
+        ],
+        "page_idx": 20
+    },
+    {
+        "type": "image",
+        "img_path": "images/b072cbbf76149611a54d835b355af8121aa707b153136394fa096a079be84ab8.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            258,
+            108,
+            736,
+            920
+        ],
+        "page_idx": 21
+    },
+    {
+        "type": "image",
+        "img_path": "images/b8ba124e3521a9107c4162d947a1456357f1f27d682af41ebbed2927c36d6c8c.jpg",
+        "image_caption": [
+            "Figure 7: Visualization of the attention distributions, when encoding the question: “Where was the apple before the bathroom?”. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            261,
+            102,
+            735,
+            900
+        ],
+        "page_idx": 22
+    },
+    {
+        "type": "text",
+        "text": "(h) Step 4 ",
+        "bbox": [
+            468,
+            893,
+            527,
+            906
+        ],
+        "page_idx": 22
+    }
+]

parse/train/J64lDCrYGi/J64lDCrYGi.md

@@ -0,0 +1,250 @@
+# Referring Transformer: A One-step Approach to Multi-task Visual Grounding
+
+Muchen Li1,2 muchenli@cs.ubc.ca
+
+Leonid Sigal1,2,3,4 lsigal@cs.ubc.ca
+
+1Department of Computer Science, University of British Columbia   
+2Vector Institute for AI 3CIFAR AI Chair 4NSERC CRC Chair
+
+# Abstract
+
+As an important step towards visual reasoning, visual grounding (e.g., phrase localization, referring expression comprehension / segmentation) has been widely explored. Previous approaches to referring expression comprehension (REC) or segmentation (RES) either suffer from limited performance, due to a two-stage setup, or require the designing of complex task-specific one-stage architectures. In this paper, we propose a simple one-stage multi-task framework for visual grounding tasks. Specifically, we leverage a transformer architecture, where two modalities are fused in a visual-lingual encoder. In the decoder, the model learns to generate contextualized lingual queries which are then decoded and used to directly regress the bounding box and produce a segmentation mask for the corresponding referred regions. With this simple but highly contextualized model, we outperform state-of-the-art methods by a large margin on both REC and RES tasks. We also show that a simple pre-training schedule (on an external dataset) further improves the performance. Extensive experiments and ablations illustrate that our model benefits greatly from contextualized information and multi-task training.
+
+# 1 Introduction
+
+Multi-modal grounding1 tasks (e.g., phrase localization [1, 3, 9, 41, 48], referring expression comprehension [17, 19, 24, 26, 29, 30, 37, 51, 52, 55, 56] and segmentation [6, 18, 20, 21, 29, 38, 53, 56]) aim to generalize traditional object detection and segmentation to localization of regions (rectangular or at a pixel level) in images that correspond to free-form linguistic expressions. These tasks have emerged as core problems in vision and ML due to the breadth of applications that can make use of such techniques, spanning image captioning, visual question answering, visual reasoning and others.
+
+The majority of multi-modal grounding architectures, to date, take the form of two-stage approaches, inspired by Faster RCNN [44] and others, which first generate a set of image region proposals and then associate/ground one, or more, of these regions to a phrase by considering how well the content matches the query phrase. Context among the regions and multiple query phrases, which often come parsed from a single sentence, has also been considered in various ways (e.g., using LSTM stacks [9], graph neural networks [1] and others). More recent variants leverage pre-trained multi-modal Transformers (e.g., ViLBERT [33, 34]) to fine-tune to the grounding tasks. Such models have an added benefit of being able to learn sophisticated cross-modal feature representations from external large-scale data, which further improve the performance. However, a significant limitation of all such two-stage methods is their inability to condition the proposal mechanism on the query phrase itself, which inherently limits the upper bound of performance (see Table 3 in [51]).
+
+To address these limitations, more recently, a number of one-stage approaches have been introduced [22, 36, 51, 52]. Most of these take inspiration from Yolo [43] and the variants, and rely on more integrated visual-linguistic fusion and a dense anchoring mechanism to directly predict the grounding regions. While this alleviates the need for a proposal stage, it instead requires somewhat ad hoc anchor definitions, often obtained by clustering of labeled regions, and also limits ability to contextualize grounding decisions as each query phrase is effectively processed independently. Finally, little attention in the literature has been given to leveraging relationship among the REC and RES tasks.
+
+In this work we propose an end-to-end one-stage architecture, inspired by the recent DETR [2] detection framework, which is capable of simultaneous language grounding at both a boundingbox and segmentation level, without requiring dense anchor definitions. This model also enables contextualized reasoning by taking into account the entire image, all referring query phrases of interest and (optionally) lingual context (e.g., a sentence from which referring phrases are parsed). Specifically, we leverage a transfomer architecture, with a visual-lingual encoder, to encode image and lingual context, and a two-headed (detection and segmentation) custom contextualized tranformer decoder. The contextualized decoder takes as input learned contextualized phrase queries and decodes them directly to bounding boxes and segmentation masks. Implicit 1-to-1 correspondence between input referring phrases and resulting outputs also enables a more direct formulation of the loss without requiring Hungarian matching. With this simple model we outperform state-of-the-art methods by a large margin on both REC and RES tasks. We also show that a simple pre-training schedule (on an external dataset) further improves the performance. Extensive experiments and ablations illustrate that our model benefit greatly from the contextualized information and the multi-task training.
+
+Contributions. Our contributions are: (1) We propose a simple and general one-stage transformerbased architecture for referring expression comprehension and segmentation. The core of this model is the novel transformer decoder that leverages contextualized phrase queries and is able to directly decode those, subject to contextualized image embeddings, into corresponding image regions and segments; (2) Our approach is unique in enabling simultaneous REC and RES using a single trained model (the only other method capable of this is [36]); showing that such multi-task learning leads to improvements on both tasks; (3) As with other transformer-based architectures, we show that pre-training can further improve the performance and both vanila and pre-trained models outperform state-of-the-art on both tasks by significant margins (up to $8 . 5 \%$ on RefCOCO dataset for REC and $1 9 . 4 \%$ for RES). We also thoroughly validate our design in detailed ablations.
+
+# 2 Related works
+
+Referring Expression Comprehension (REC). REC focuses on producing an image bounding box tightly encompassing a language query. Previous two-staged works [17, 19, 29, 30, 56] reformulate this as a ranking task with a set of candidate regions predicted from a pre-trained proposal mechanism. Despite achieving great success, the performance of two-staged methods is capped by the speed and accuracy of region proposals in the first stage. More recently, one-stage approaches [26, 51, 52] have been used to alleviate the aforementioned limitations. Yang et al. [51, 52] proposed to fuse query information with visual features and pick the bounding box with maximum activation scores from YOLOv3 [43]. Yang et al. [50] explore language structure guided propagation in the context of one stage grounding. Liao et al. [26] utilizes CenterNet [11] to perform correlation filtering for region center localization. However, such methods either require manually tuned anchor boxes or suffer from semantic loss due to modality misalignment. In contrast, our model learns to better align modalities using a cross-modal transformer and directly decode bounding boxes for each query.
+
+Referring Expression Segmentation (RES). Similar to REC, RES, proposed in [18], aims to predict segmentation masks to better describe the shape of the referred region. A typical solution for referring expression segmentation is to fuse multi-modal information with a segmentation network (e.g., [16, 31]) and train it to output the segmented masks [18, 29, 38, 53, 56]. More recent approaches focus on designing module to enable better multi-modal interactions, e.g., progressive multi-scale fusion used in [21] and cross-modal attention block used in [20]. Since localization information matters in predicting instance segmentations (as noted in Mask RCNN [16]), very recent work [22] aims to explicitly localize object before doing segmentation. Despite the relatively high performance being achieved in RES, existing approaches still struggle to determine the correct referent region and tend to output noisy segmentation results with an irregular shape, while our model is able to produce segmentations with fine-grained shapes even on challenging scenarios with occlusions or shadows.
+
+Multi-task Learning for REC and RES. Multi-task learning is widely applied in object detection and segmentation [2, 16], often, by leveraging shared backbone and task-specific heads. Building on this idea, Luo et al. [36] proposed a multi-task collaborative network (MCN) to jointly address REC and RES. They introduce consistency energy maximization loss that constrains the feature activation map in REC and RES to be similar. While our model is also set up to learn REC and RES tasks jointly, we argue that an explicit constraint tends to downplay the quality of the final predicted mask since the feature map from the REC branch can blur out fine-grained region shape information needed by the RES branch (see Figure 2). Hence, we use an implicit constraint where tasks head of REC and RES are trained to output corresponding bounding box and mask from the same joint multi-modal representation. We illustrate that our model can benefit from multi-task supervision, leading to more accurate results as compared to single-task variants.
+
+Pretrained Multi-modal Transformers. Transformer-based pretrained models [5, 12, 33, 47, 54] have recently showed strong potential in multi-modal understanding. LXMERT [47] and ViLBERT [33] use two stream transformers with cross-attention transformer layers on top for multimodal fusion. More recent works, [5, 12] advocate a single-stream design to fuse two modalities earlier. The success of the aforementioned models can largely be attributed to the cross-modal representations obtained by multi-task pretraining on a large amount of aligned image-text pairs. Despite state-of-the-art performance of such models on the downstream REC task, these models, fundamentally, are still a form of a two-stage pipeline where image features are extracted using pretrained detectors or proposal mechanisms. We focus on a one-stage architecture variant that allows visual and lingual features to be aligned at the early stages. Although the focus of our work is not to design a better pretraining scheme, we show that our model can outperform the existing state-of-the-art with proper pretraining.
+
+Transformer-based Detectors. More recently, DETR [2] and its variants [13, 58], were proposed to enable end-to-end object detection. DETR reformulates detection as a set prediction tasks and uses transformers to decode learnable queries to bounding boxes. Despite state-of-art performance, DETR is disadvantaged by its optimization difficulty and, usually, extra-long training time. While adopting a similar pipeline, our model focus on aligning different modalities to generate contextualized expression-specific referring queries. We also design our model to get rid of Hungarian matching loss by leveraging one-to-one correspondences between predicted bounding boxes and referring expressions, which leads to faster convergence for our model.
+
+# 3 Approach
+
+Given an image $\mathcal { T }$ and a set of query phrases $\mathcal { Q } _ { p } = \{ \mathbf { p } _ { i } \} _ { i = 1 , \dots , M }$ , that we assume to come from an (optional) contextual text source2 $\mathcal { Q }$ , our goal is to predict a set of bounding boxes $B = \{ \mathbf { b } _ { i } \} _ { i = 1 , \dots , M }$ and corresponding segmentation masks ${ \cal S } = \{ { \bf s } _ { i } \} _ { i = 1 , \dots , M }$ , one for each query phrase $i$ that localizes that phrase in the image. Note, $M$ is the number of phrases / referring expressions for a given image $\mathcal { T }$ and is typically between 1 and 16 for the Flick $3 0 \mathrm { k }$ [41] dataset.
+
+As shown in Figure 1, our referring transformer is composed of four components. Given an image(con)text pair, $<  { \mathcal { T } } ,  { \mathcal { Q } } >$ , a cross-modal encoder generates joint image-text embeddings for each visual and textual token – feature columns and word embeddings respectively. Query phrases $\mathcal { Q } _ { p }$ and image-text embeddings are then fed into a query encoder which produces query phrase embeddings. The decoder jointly reasons across all these query phrase embeddings and decodes multi-task feature, which is then sent to the detection and segmentation head to produce a set of boxes $\boldsymbol { B }$ and masks $s$ The result is a one-staged end-to-end model that solves the REC and RES tasks at the same time. We will now introduce constituent architectural components for the four stages briefly described above.
+
+# 3.1 Feature Extraction
+
+Visual & Text Backbone. Starting from an initial image $\mathcal { T } \in \mathbb { R } ^ { 3 \times H _ { 0 } \times W _ { 0 } }$ , we adopt the widely used ResNet [15] to generate its low-resolution feature map $\mathbf { f } _ { I } \in \mathbb { R } ^ { C _ { i } \times H W }$ . For the corresponding expression or sentence, we use the uncased base of BERT [8] to obtain the representation $\mathbf { f } _ { Q } \in$ $\mathbb { R } ^ { C _ { t } \times N }$ , while $N$ is the length of the input context sentence.
+
+![](images/e40ae0a0b3ed22270911f094dd1b90cc0e55acb591f3e2843ed7485181a3033e.jpg)  
+Figure 1: Referring Transformer. An overview of the proposed architecture is shown in (a). For an image and (con)text input, a visual-lingual encoder is used to refine image features, extracted from a convolutional backbone, and lingual features, extracted by a BERT. A query encoder and decoder produce features for REC and RES heads, given multi-modal features and query phrases. The detailed structure of the query encoder and decoder is shown in (b). Colored squares denote embeddings for corresponding query phrases.
+
+Visual-Lingual Encoder. The visual-lingual encoder is designed to fuse information from multimodal sources. For cross-modality encoding, we use a transformer encoder based model, which is composed of 6 transformer encoder layers. Specifically, given both image and text features, multi-layer perceptrons are applied first to project different modalities to a joint embedding space with a hidden dimension of $C$ . To provide transformer encoders with positional information, we follow [2, 8] to add cosine positional embedding $P _ { i m g }$ for image features and learnable positional embedding $P _ { t e x t }$ for text features. We then concatenate the projected features into a single sequence $\mathbf { f } ~ \in ~ \mathbb { R } ^ { C \times ( H W + N ) }$ . To distinguish between modalities, we also deign a learnable modal label embedding $E _ { l a b e l } : \{ E _ { i m g } , E _ { t e x t } ^ { - } \}$ which is added to the original sequences. The visual-lingual encoder then takes a sequence as input, and $\{ P _ { i m g } , P _ { t e x t } , E _ { l a b e l } \}$ are fed into each encoder layer. The encoder output is a multi-modal feature sequence $\mathbf { f } _ { v l } \in \mathbb { R } ^ { C \times ( H W + N ) }$ .
+
+# 3.2 Query Encoder and Decoder
+
+The query encoder and decoder aims to encode / decode query phrases, conditioned on visual-lingual features from the encoder, into an output bounding box and segmentation. In this stage, we first generate embeddings corresponding to each query phrase. These query phrase embeddings are then fed into the decoder together with the visual-lingual features from the encoder to generate outputs.
+
+Encoding Query Phrases. To enable the decoder to generate the desired output (bounding box and/or segmentation) the queries must encode several bits of crucial information. Mainly, (1) encoding of the query phrases, (2) image encoding and (3) phrase-specific optional (con)text information. For phrase encoding in (1) we use a BERT model with pooling heads which share weights with (con)text encoder; this results in the phrase feature vector $\mathbf { f _ { p } } _ { i } \in \mathbb { R } ^ { C }$ for the $i$ -th referring phrase. We note that because we use visual-lingual encoder, (2) and (3) are jointly encoded in multi-modal features $\mathbf { f } _ { v l }$ described in Section 3.1 above. However, $\mathbf { f } _ { v l }$ is phrase-agnostic encoding of the image and (con)text. To generate phrase-specific context, given a phrase $\mathbf { p } _ { i }$ , average pooling is used to extract the phrase-specific context information $\mathbf { f } _ { c } ( \mathbf { p } _ { i } )$ from the visual-lingual feature sequence as follows:
+
+$$
+\mathbf { f } _ { c } ( \mathbf { p } _ { i } ) = \frac { \sum \mathbf { f } _ { v l } [ l _ { \mathbf { p } _ { i } } : r _ { \mathbf { p } _ { i } } ] } { r _ { \mathbf { p } _ { i } } - l _ { \mathbf { p } _ { i } } }
+$$
+
+where $l _ { \mathbf { p } _ { i } }$ and $r _ { \mathbf { p } _ { i } }$ denotes the left and right bounds of phrase $\mathbf { p } _ { i }$ in the original (con)text sentence. Finally, given phrase encoding $\mathbf { f _ { p } } _ { i }$ and phrase-specific context $\mathbf { f } _ { c } ( \mathbf { p } _ { i } )$ we construct our phrase queries
+
+using a multi-later perceptron:
+
+$$
+\widehat { Q _ { { \bf p } i } } = \mathtt { M L P } \left( [ { \bf f } _ { c } ( { \bf p } _ { i } ) ; { \bf f _ { p } } _ { i } ] \right) + E _ { p } ,
+$$
+
+where $E _ { p } \in \mathbb { R } ^ { C }$ is a learnable embedding which serves as a bias to the formed query.
+
+Decoding. In the decoder, self attention layers are used to enable information flow in a dense connected graph of phrase queries. This allows phrase queries to contextualize and refine each other; the inspiration for this step is taken from [1]. After that, a cross attention layer decodes visual-lingual information given the updated phrase query and feature sequence from the encoder. The design of our decoder is similar to the transformer decoder, except attention is non-causal.
+
+# 3.3 Multi-task training
+
+In this section, we demonstrate how the decoded phrase-specific query features can be naturally used to train multiple heads for different referring tasks (regression for REC and segmentation for RES).
+
+Referring Comprehension/Detection (REC). For referring detection tasks, the final output is computed by a simple two-layer perceptron over the decoded phrase-specific query features. We let the detection head directly output center coordinates $\tilde { \mathbf { b } } = ( x , y , h , w )$ for the referred image. To supervise the training, we use a weighted sum of an L1 loss and a Generalized IOU loss [45]:
+
+$$
+\begin{array} { r } { \mathcal { L } _ { d e t } = \lambda _ { i o u } \mathcal { L } _ { i o u } ( \mathbf { b } , \tilde { \mathbf { b } } ) + \lambda _ { L 1 } | | \mathbf { b } - \tilde { \mathbf { b } } | | _ { 1 } . } \end{array}
+$$
+
+The $\lambda _ { i o u }$ and $\lambda _ { L 1 }$ control the relative weighting of the two losses in the REC objective.
+
+Referring Segmentation (RES). Following previous work [2], we design an FPN-like architecture to predict a referring segmentation mask for each phrase expression. Attention masks from the decoder and image features from the visual-lingual encoder are concatenated as the FPN input, while features from different stages of image backbones are used as skip connections to refine the final output. The last linear layer project the upsampled feature to a single channel heatmap and a sigmoid function is used to map the feature to mask scores $\tilde { \mathbf { s } } \in \mathbb { R } ^ { H _ { 0 } / 4 \times W _ { 0 } / 4 }$ . The loss for training RES task is:
+
+$$
+\begin{array} { r } { \mathcal { L } _ { s e g } = \lambda _ { f o c a l } \mathcal { L } _ { f o c a l } ( \mathbf { s } , \tilde { \mathbf { s } } ) + \lambda _ { d i c e } \mathcal { L } _ { d i c e } ( \mathbf { s } , \tilde { \mathbf { s } } ) . } \end{array}
+$$
+
+Here $\mathcal { L } _ { f o c a l }$ is the focal loss for classifying pixels used in [28], $\mathcal { L } _ { d i c e }$ is the DICE/F-1 loss proposed in [39]; $\lambda _ { f o c a l }$ and $\lambda _ { d i c e }$ are hyper-parameters controlling the relative importance of the two losses.
+
+Joint Training. While it is possible to train referring segmentation and referring detection tasks separately, we find that joint training is highly beneficial. Therefore the combined training loss which we optimize is $\mathcal { L } = \mathcal { L } _ { s e g } + \mathcal { L } _ { d e t }$ .
+
+Pretraining the Transformer. Transformers are generally data hungry and requires a lot of data to train [5, 33]. Although in this paper we do not use a large pretraining model and a lot of data. We found that simple pretraining strategy on the region description splits of Visual-Genome dataset [25] makes our model achieve comparable and even better performance against some of state-of-the-art pretrained models. Interestingly, we found that although there is no ground truth segmentation provided in Visual-Genome, the RES task can still benefit greatly from pretrained models, likely due to the fine-tuned multi-task representation.
+
+# 4 Experiments
+
+# 4.1 Datasets
+
+RefCOCO/RefCOCO $^ +$ /RefCOCOg (REC&RES). RefCOCO, RefCOCO $^ +$ [55] and RefCOCOg [40] are collections of images and referred objects from MSCOCO [27]. On RefCOCO and Ref$\mathrm { C O C O + }$ we follow the split used in [55] and report scores on the validation, testA and testB splits. On RefCOCOg, we use the RefCOCO-umd splits proposed in [40].
+
+Flickr30k Entities (REC). Flickr30k Entities [41] contains 31,783 images and $1 5 8 \mathrm { k }$ caption sentences with 427k annotated phrase. We use splits from [41, 42]. Bounding boxes and phrase annotations are consistent with the previous one-stage approaches [51, 52] for fair comparisons.
+
+ReferIt (REC). The ReferItGame dataset [24] contains 20,000 images. We follow setup in [3] for splitting train, validation and test set; resulting in 54k, 6k and 6k referring expressions respectively.
+
+Table 1: Comparison on REC task. Performance on RefCOCO/RefCOCO+/RefCOCOg datasets [55] is reported. Ours∗ denotes that pretraining is used. RN50 and RN101 refer to ResNet50 and ResNet101 [15] respectively; DN53 refers to DarkNet53 [43] backbone.   
+
+<table><tr><td rowspan="2">Models</td><td rowspan="2">Visual Features</td><td rowspan="2">Pretrain Images</td><td rowspan="2">Multi- task</td><td colspan="3">RefCOCO</td><td colspan="3">RefCOCO+</td><td rowspan="2">RefCOCOg</td></tr><tr><td>val</td><td>testA</td><td>testB</td><td>val</td><td>testA</td><td>testB val-u</td></tr><tr><td>Two-stage:</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td>test-u</td></tr><tr><td>CMN[19]</td><td>VGG16</td><td>None</td><td>×</td><td>-</td><td>71.03</td><td>65.77</td><td>-</td><td>54.32</td><td>47.76</td><td>-</td><td>-</td></tr><tr><td>RvG-Tree [17]</td><td>RN101</td><td>None</td><td>×</td><td>75.06</td><td>78.61</td><td>69.85</td><td>63.51</td><td>67.45</td><td>56.66</td><td>66.95</td><td>66.51</td></tr><tr><td>CM-Att-Erase [30]</td><td>RN101</td><td>None</td><td>×</td><td>78.35</td><td>83.14</td><td>71.32</td><td>68.09</td><td>73.65</td><td>58.03</td><td>67.99</td><td>68.67</td></tr><tr><td>MAttNet [56]</td><td>RN101</td><td>None</td><td>√</td><td>76.65</td><td>81.14</td><td>69.99</td><td>65.33</td><td>71.62</td><td>56.02</td><td>66.58</td><td>67.27</td></tr><tr><td>NMTree [29]</td><td>RN101</td><td>None</td><td>√</td><td>76.41</td><td>81.21</td><td>70.09</td><td>66.46</td><td>72.02</td><td>57.52</td><td>65.87</td><td>66.44</td></tr><tr><td>One-stage:</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>RCCF[26]</td><td>DLA34</td><td>None</td><td>×</td><td>-</td><td>81.06</td><td>71.85</td><td>-</td><td>70.35</td><td>56.32</td><td>-</td><td>65.73</td></tr><tr><td>SSG [4]</td><td>DN53</td><td>None</td><td>×</td><td>=</td><td>76.51</td><td>67.50</td><td>-</td><td>62.14</td><td>49.27</td><td>58.80</td><td>-</td></tr><tr><td>FAOA [51]</td><td>DN53</td><td>None</td><td>×</td><td>72.54</td><td>74.35</td><td>68.50</td><td>56.81</td><td>60.23</td><td>49.60</td><td>61.33</td><td>60.36</td></tr><tr><td>ReSC-Large [52]</td><td>DN53</td><td>None</td><td>×</td><td>77.63</td><td>80.45</td><td>72.30</td><td>63.59</td><td>68.36</td><td>56.81</td><td>67.30</td><td>67.20</td></tr><tr><td>MCN[36]</td><td>DN53</td><td>None</td><td>√</td><td>80.08</td><td>82.29</td><td>74.98</td><td>67.16</td><td>72.86</td><td>57.31</td><td>66.46</td><td>66.01</td></tr><tr><td>Ours</td><td>RN50</td><td>None</td><td>√</td><td>81.82</td><td>85.33</td><td>76.31</td><td>71.13</td><td>75.58</td><td>61.91</td><td>69.32</td><td>69.10</td></tr><tr><td>Ours</td><td>RN101</td><td>None</td><td>√</td><td>82.23</td><td>85.59</td><td>76.57</td><td>71.58</td><td>75.96</td><td>62.16</td><td>69.41</td><td>69.40</td></tr><tr><td>Pretrained:</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>VilBERT[33]</td><td>RN101</td><td>3.3M</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td>RN101</td><td></td><td>×</td><td>-</td><td>=</td><td>-</td><td>72.34</td><td>78.52</td><td>62.61</td><td>1</td><td>-</td></tr><tr><td>ERNIE-ViL_L[54]</td><td>RN101</td><td>4.3M 4.6M</td><td>×</td><td>=</td><td></td><td></td><td>75.89</td><td>82.37</td><td>66.91</td><td></td><td></td></tr><tr><td>UNTIER_L[5]</td><td>RN101</td><td>4.6M</td><td>×</td><td>81.41</td><td>87.04</td><td>74.17</td><td>75.90</td><td>81.45</td><td>66.70</td><td>74.86</td><td>75.77</td></tr><tr><td>VILLA_L[12]</td><td>RN50</td><td></td><td>×</td><td>82.39</td><td>87.48</td><td>74.84</td><td>76.17</td><td>81.54</td><td>66.84</td><td>76.18</td><td>76.71</td></tr><tr><td>Ours*</td><td></td><td>100k</td><td>√</td><td>85.43</td><td>87.48</td><td>79.86</td><td>76.40</td><td>81.35</td><td>66.59</td><td>78.43</td><td>77.86</td></tr><tr><td>Ours*</td><td>RN101</td><td>100k</td><td>√</td><td>85.65</td><td>88.73</td><td>81.16</td><td>77.55</td><td>82.26</td><td>68.99</td><td>79.25</td><td>80.01</td></tr></table>
+
+# 4.2 Implementing Details
+
+We train our model with AdamW [32]. The initial learning rate is set to 1e-4 while the learning rate of image backbone and context encoder is set to 1e-5. We initialized weights in the transformer encoder and decoder with Xavier initialization [14]. For image backbone, we experiment with the popular ResNet-50 and ResNet-101 networks [15] where weights are initialized from corresponding ImageNet-pretrained models. For the context encoder and phrase encoder, we use an uncased version of BERT model [8] with weights initialized from pretrained checkpoints provided by HuggingFace [49]. For data augmentation, we scale images such that the longest side is 640 pixels and follow [51] to do random intensity saturation and affine transforms. We remove the random horizontal flip augmentation used in previous work [51] since we notice it causes semantic ambiguity on RefCOCO, likely due to relative location (e.g., left of/right of) specific queries in the dataset.
+
+On Flickr30k dataset, we set the maxium length of context sentence to 90 and maximum number of referring phrases to 16. On the ReferIt and the RefCOCO dataset, only phrase expressions are provided and the task aims to predict a single bounding box for each of the expressions. In those cases, the context sentence is taken as the referring phrase expression itself. We set the maximum length of context sentence on these two datasets to 40. To fairly compare with pretrained methods, we use region description split in the VisualGenome [25] to pretrain our model. The dataset contains approximately $1 0 0 \mathrm { k }$ images and we remove the images that appear in Flickr30k Entities and RefCOCO/RefCOCOg/RefCOCO+’s validation and test set to avoid potential test data leak. For all the pretrained methods, we train the model on pretraining dataset for 6 epoches. We find that longer pretraining schedule gives better performance, but since the focus of this paper is not on pretraining methods, we stick to shorter pretraining schedules to save computational resources. All experiments are conducted using 4 Nvidia 2080TI GPU with batch size as 32. For all the results given, we run experiments several times with random seeds and the error bars are within $\pm 0 . 5 \%$ .
+
+# 4.3 Quantitative Analysis
+
+Evaluation Metrics. For referring expression comprehension (REC), consistent with prior works, we use precision as the evaluation metric. We mark a referring detection as correct when the intersection-over-union (IoU) between the predicted bounding box and ground truth is larger than 0.5. For referring expression segmentation (RES), we reported the Mean IoU (MIoU) between the predicted segmentation mask and ground truth mask.
+
+REC and RES on RefCOCO/RefCOCO $+$ /RefCOCOg. Our model addresses REC and RES tasks jointly. We compare their respective performances with the state-of-the-art in Table 1 and 2.
+
+Table 2: Comparison on RES tasks. Performance on RefCOCO/RefCOCO $+$ /RefCOCOg datasets [55] is reported. Ours∗ denotes that pretraining is used. RN50 abd RN101 refer to ResNet50 and ResNet101 [15] respectively; DN53 refers to DarkNet53 [43] backbone.   
+
+<table><tr><td rowspan="2">Methods</td><td rowspan="2">Backbone</td><td colspan="3">RefCOCO</td><td colspan="3">RefCOCO+</td><td colspan="2">RefCOCOg</td><td rowspan="2">Inference time(ms)</td></tr><tr><td>val</td><td>testA</td><td>testB</td><td>val</td><td>testA</td><td>testB</td><td>val</td><td>test</td></tr><tr><td>DMN [38]</td><td>RN101</td><td>49.78</td><td>54.83</td><td>45.13</td><td>38.88</td><td>44.22</td><td>32.29</td><td>-</td><td>-</td><td>-</td></tr><tr><td>MAttNet [56]</td><td>RN101</td><td>56.51</td><td>62.37</td><td>51.70</td><td>46.67</td><td>52.39</td><td>40.08</td><td>47.64</td><td>48.61</td><td>378</td></tr><tr><td>NMTree [29]</td><td>RN101</td><td>56.59</td><td>63.02</td><td>52.06</td><td>47.40</td><td>53.01</td><td>41.56</td><td>46.59</td><td>47.88</td><td>1</td></tr><tr><td>Lang2seg [6]</td><td>RN101</td><td>58.90</td><td>61.77</td><td>53.81</td><td>-</td><td>-</td><td>-</td><td>46.37</td><td>46.95</td><td></td></tr><tr><td>BCAM[20]</td><td>RN101</td><td>61.35</td><td>63.37</td><td>59.57</td><td>48.57</td><td>52.87</td><td>42.13</td><td>-</td><td>=</td><td></td></tr><tr><td>CMPC[21]</td><td>RN101</td><td>61.36</td><td>64.53</td><td>59.64</td><td>49.56</td><td>53.44</td><td>43.23</td><td>=</td><td>=</td><td>=</td></tr><tr><td>MCN+ASNLS [36]</td><td>DN53</td><td>62.44</td><td>64.20</td><td>59.71</td><td>50.62</td><td>54.99</td><td>44.69</td><td>49.22</td><td>49.40</td><td>56</td></tr><tr><td>CGAN [35]</td><td>DN53</td><td>64.86</td><td>68.04</td><td>62.07</td><td>51.03</td><td>55.51</td><td>44.06</td><td>51.01</td><td>51.69</td><td>-</td></tr><tr><td>LTS [22]</td><td>DN53</td><td>65.43</td><td>67.76</td><td>63.08</td><td>54.21</td><td>58.32</td><td>48.02</td><td>54.40</td><td>54.25</td><td>1</td></tr><tr><td>Ours</td><td>RN50</td><td>69.94</td><td>72.80</td><td>66.13</td><td>60.9</td><td>65.20</td><td>53.45</td><td>57.69</td><td>58.37</td><td>38</td></tr><tr><td>Ours</td><td>RN101</td><td>70.56</td><td>73.49</td><td>66.57</td><td>61.08</td><td>64.69</td><td>52.73</td><td>58.73</td><td>58.51</td><td>41</td></tr><tr><td>Ours*</td><td>RN50</td><td>73.61</td><td>75.22</td><td>69.80</td><td>65.30</td><td>69.69</td><td>56.98</td><td>65.70</td><td>65.41</td><td>38</td></tr><tr><td>Ours*</td><td>RN101</td><td>74.34</td><td>76.77</td><td>70.87</td><td>66.75</td><td>70.58</td><td>59.40</td><td>66.63</td><td>67.39</td><td>41</td></tr></table>
+
+![](images/ae52ea765ab73627d130406f12ccbc83f1847c53fe2d5875520aa3f4dee6d22d.jpg)  
+Figure 2: Qualitative Evaluation. In (a) comparison to MCN [36] on REC is shown; orange, blue and red bounding boxes correspond to outputs from MCN, our model and the ground truth. In (b) similar comparison on RES is made. The attention map is drawn from the last layer of the decoder. We add mosaic to all human face to protect personal information.
+
+In Table 1, the model is first compared with previous one-stage and two-stage approaches for REC. Without bells and whistles, we observe a consistent performance boost of $+ 2 . 7 \% / + 4 \% / + 2 . 1 \%$ on RefCOCO, $+ 6 . 6 \% / + 4 . 3 \% / + 8 . 5 \%$ on $\operatorname { R e f C O C O + }$ and $+ 4 . 4 \% / + 5 . 1 \%$ on RefCOCOg. To compare with pretrained BERT methods, we use the pretraining strategy discussed in Section 3.3. As results show, our model achieves comprehensive advantage and shows distinct improvement on some splits, even compared to advance BERT models that use $4 0 \times$ more data in pretraining. Table 2 illustrates results on RES task in terms of MIoU score. It can be seen that our model achieves the best performance; substantially better than the state-of-art. We further observe that pretraining on the REC task gives a huge performance boost to the RES task, even when no segmentation mask is used in pre-training. Multi-task training enables the model to leverage performance boost in one task to improve the other.
+
+We show the inference time for our model in Table 2. Our model can directly decode all query phrases in an image in parallel, allowing it to reach real-time performance. Importantly, note the corresponding scores for our model in Table 1 and Table 2 are based on the output of a single multitask model that predicts referring detection box and segmentation mask simultaneously. The only related work that shares this property is the MCN [36], which has substantially inferior performance.
+
+Table 3: Comparison with State-of-The-Art Methods. Table illustrates performance on the test set of ReferItGame [24] and Flickr30K Entities [41] datasets in terms of top-1 accuracy $( \% )$ .   
+
+<table><tr><td>Models</td><td>Backbone</td><td>ReferItGame test</td><td>Flickr30K test</td><td>Inference time on Flickr30k(ms)</td></tr><tr><td colspan="5">Two-stage</td></tr><tr><td>MAttNet [56]</td><td>RN101</td><td>29.04</td><td>-</td><td>320</td></tr><tr><td>Similarity Net [48]</td><td>RN101</td><td>34.54</td><td>60.89</td><td>184</td></tr><tr><td>CITE [42]</td><td>RN101</td><td>35.07</td><td>61.33</td><td>196</td></tr><tr><td>DDPN[57]</td><td>RN101</td><td>63.00</td><td>73.30</td><td>-</td></tr><tr><td colspan="5">One-stage</td></tr><tr><td>SSG[4]</td><td>DN53</td><td>54.24</td><td>-</td><td>25</td></tr><tr><td>ZSGNet [46]</td><td>RN50</td><td>58.63</td><td>58.63</td><td>-</td></tr><tr><td>FAOA [51]</td><td>DN53</td><td>60.67</td><td>68.71</td><td>23</td></tr><tr><td>RCCF[26]</td><td>DLA34</td><td>63.79</td><td>-</td><td>25</td></tr><tr><td>ReSC-Large [52]</td><td>DN53</td><td>64.60</td><td>69.28</td><td>36</td></tr><tr><td>Ours</td><td>RN50</td><td>70.81</td><td>78.13</td><td>37(14)</td></tr><tr><td>Ours</td><td>RN101</td><td>71.42</td><td>78.66</td><td>40(15)</td></tr><tr><td>Ours*</td><td>RN50</td><td>75.49</td><td>79.46</td><td>37(14)</td></tr><tr><td>Ours*</td><td>RN101</td><td>76.18</td><td>81.18</td><td>40(15)</td></tr></table>
+
+REC on Flickr30k-Entities. For Flickr30k dataset, previous one-stage works [51, 52] extract short phrases from sentences and treated them as separate referring expression comprehension tasks. We argue that in this setting, queries are mostly short phrases and therefore cannot well reflect the model’s ability to comprehend them in context. In contrast, our model, given an image and a caption (con)text sentence, aims to predict bounding boxes for all referred entities in the sentence. Doing so gives several advantages: 1. We are able to contextualize referring expressions given all other referring expressions and (con)text provided by the sentence. 2. Locations for all phrases can be inferred in one forward pass of the network, which saves a lot of computation as compared to previous one-stage approaches [51, 52] that process one phrase at a time. Note that our task formulation is consistent with some two-stage models [1, 9], but is unique for a one stage approach.
+
+In Table 3 we compare our results with state-of-the-art methods. Without pretraining, we obtain a huge performance boost compared to both previous one-stage $( + 1 3 . 5 4 \% )$ and two-stage $( + 7 . 3 1 \% )$ state-of-the art methods. By using pretrained models, we observe that our model tends to generalize better on the test set and gives even better performance. We also provide comparison of inference time both per image and (per-expression), since our model can amortize inference across expressions. Per-expression, our inference time is substantially lower than all prior methods.
+
+REC on ReferIt. Since ReferIt is a relative small dataset, we use a slightly smaller model which contains 3 cross attention layers in the query decoder. The results are shown in Table 3. Our model is able to perform better, by a large margin, than even the latest one-stage methods. We also observe a consistent boost brought by pretraining.
+
+# 4.4 Qualitative Analysis
+
+In Figure 2, we show our qualitative comparison with previous state-of-the-art multi-task model – MCN [36]. The first two rows of Figure 2(a) show failure cases of MCN that can be better handled by our model. We observe that MCN appears to fail because it neglects some attributes in referring expression (e.g., "yellow drink" and "blue striped shirt"), while our model is able to better model the query and pay attention to object attributes. In the last row, we shows several failure cases of our model. For the first case, the query requires the model to have the ability to recognize number $" 4 4 "$ . For the second and third case, there is visual ambiguity to identify the nearest glass to the bowl or to determine which bear(brown or white) has the longest leg.
+
+In Figure 2(b), we show qualitative comparison in terms of referred segmentation mask. Compared to MCN, our model is able to output more detailed object shape and finer outlines. Moreover, our model shows the ability to handle shadows (e.g., the right bottom of the donut) and occlusions (e.g., the man occluded by another man’s arm) and predict smoother segmentation mask. We also give a result on a challenging case in the last row, where the texture boundary of the two giraffe is hard to distinguish. Despite imperfections, our model is still able to focus on the giraffe’s head in the foreground and performs much better than MCN. Part of our model’s ability to generate fine-grained mask can be explained by better localization ability brought by the REC task, in which case the RES head can focus on tuning the shape and boundary of the mask.
+
+Table 4: Ablation studies. Table on the top ablates our multi-task and pretraining schehme on $\operatorname { R e f C O C O } / + / \mathrm { g }$ validation set. Table on the bottom ablates on core components of our model.   
+
+<table><tr><td>REC</td><td>RES Pretrain</td><td>REC Acc↑</td><td>RESMiou↑</td><td>IE</td></tr><tr><td>√</td><td>√</td><td>81.08 /70.02/68.15</td><td>66.03/58.39/54.61 =</td><td>23.52%</td></tr><tr><td>√</td><td>√</td><td>81.82 / 71.13 /69.32</td><td>69.94 / 60.90 / 57.69</td><td>4.73%</td></tr><tr><td>√</td><td>√</td><td>85.01/75.46/77.96</td><td>=</td><td></td></tr><tr><td>√</td><td>√ √</td><td>85.43 / 76.40 / 78.43</td><td>73.61 / 65.30 / 65.70</td><td>4.48%</td></tr></table>
+
+Table 5: Results on RefCOCO $^ +$ Dataset with Different Input Resolutions. Our methods correspond to the RN50 model without pretraining.   
+
+<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>Flickr30k</td></tr><tr><td rowspan=1 colspan=1>Model component-w/o Query Decoder-w/o Context Encoder</td><td rowspan=1 colspan=1>49.3873.68</td></tr><tr><td rowspan=1 colspan=1>Query Encoder-w/o Context&amp;Phrase Feature-w/o Context Feature-w/o Phrase Feature</td><td rowspan=1 colspan=1>42.0576.6477.02</td></tr><tr><td rowspan=1 colspan=1>Full model</td><td rowspan=1 colspan=1>78.13</td></tr></table>
+
+<table><tr><td rowspan="2">Models</td><td rowspan="2">Resolution</td><td colspan="3">REC(prec@0.5)</td><td colspan="3">RES(MIoU)</td></tr><tr><td>val</td><td>testA</td><td>testB</td><td>val</td><td>testA</td><td>testB</td></tr><tr><td>FAOA [51]</td><td>256× 256</td><td>56.81</td><td>60.23</td><td>49.60</td><td>-</td><td>-</td><td>-</td></tr><tr><td>ReSC-Large [52]</td><td>256× 256</td><td>63.59</td><td>68.36</td><td>56.81</td><td>-</td><td>-</td><td>1</td></tr><tr><td>CMPC[21]</td><td>320×320</td><td>1</td><td>-</td><td>1</td><td>49.56</td><td>53.44</td><td>43.23</td></tr><tr><td>LTS [22]</td><td>416× 416</td><td>-</td><td>=</td><td>=</td><td>54.21</td><td>58.32</td><td>48.02</td></tr><tr><td>MCN [36]</td><td>416× 416</td><td>67.16</td><td>72.86</td><td>57.31</td><td>50.62</td><td>54.99</td><td>44.69</td></tr><tr><td>Ours</td><td>256× 256</td><td>70.05</td><td>73.29</td><td>61.48</td><td>58.26</td><td>61.09</td><td>52.20</td></tr><tr><td>Ours</td><td>320×320</td><td>70.03</td><td>73.23</td><td>61.52</td><td>58.42</td><td>61.48</td><td>52.34</td></tr><tr><td>Ours</td><td>416× 416</td><td>71.50</td><td>75.87</td><td>61.71</td><td>61.00</td><td>64.48</td><td>52.44</td></tr><tr><td>Ours</td><td>640× 640</td><td>71.58</td><td>75.96</td><td>62.16</td><td>61.08</td><td>64.69</td><td>52.73</td></tr></table>
+
+# 4.5 Ablation Studies
+
+We first consider the importance of the multi-task setup in Table 4 (top). Results indicate that multi-task training consistently boosts both REC and RES performance on Refcoco $/ + / \mathrm { g }$ datasets by a considerable margin. More specifically, we observe that REC loss helps the transformer to better locate the referred object and converge faster in early stages of training. At the same time, RES loss aids the model with more fine-grained information on the shape of the referred region, which helps to further enhance the accuracy. IE here is Inconsistency Error metric originally used in [36] to measure the prediction conflict between the REC and RES task. We can see that joint training of RES and REC greatly reduce the inconsistency between the two tasks. Note that our model also has a much lower multi-task inconsistency compared to MCN [36], with a corresponding IE score of $7 . 5 4 \% ( - 4 0 \% )$ . This shows that our model can do better collaborative learning.
+
+Next, we validate the design of our network architecture. We report our scores on the Flickr30k test sets. In Table 4 (bottom), we ablate the model’s major components and features used to form the query. Without (w/o) context encoder indicates that we directly use learnable embedding to encode text; w/o Query Decoder means that we directly use the average pooled feature from the encoder to predict a single referred output. We can see that the context encoder plays an important role in providing good textual representation for further multi-modal fusion. Query encoders are also quite important without which we also observe a big performance drop. For the ablation on query features, we observe that both context feature and phrase features are crucial without which the performance will decrease considerably. The table also showed that the network will not work without guidance of both context and phrase features since we cannot establish a correspondence between multiple queries and outputs in such a case.
+
+In RES and REC tasks, the size of input image is a matter of trade off between performance and speed, which is largely effected by the network architecture. Despite that our model is designed to be able to process $6 4 0 \times 6 4 0$ images at real time speed, we also test our model at different input resolution for reference, as showed in Table 5. Note that for resolution 256 and 320, we adjust strides in the final stage of ResNet to keep the number of visual features sent into visual-lingual encoder roughly the same.
+
+Table 6: Comparison with Concurrent Work. Performance on RefCOCO/RefCOCO $\left| + \right.$ /RefCOCOg datasets [55]. Ours∗ denotes that pretraining is used. All methods use ResNet101 image backbone.   
+
+<table><tr><td rowspan="2">Models</td><td rowspan="2">Visual Features</td><td rowspan="2">Pretrain Images</td><td rowspan="2">Multi- task</td><td colspan="3">RefCOCO</td><td colspan="3">RefCOCO+</td><td rowspan="2">RefC0COg</td></tr><tr><td>val</td><td>testA</td><td>testB</td><td>testA</td><td>testB</td><td>val-u</td></tr><tr><td>One-stage:</td><td></td><td></td><td></td><td></td><td></td><td></td><td>val</td><td></td><td></td><td></td><td>test-u</td></tr><tr><td>VGTR [10]</td><td>Bi-LSTM</td><td>None</td><td>×</td><td>79.20</td><td>82.32</td><td>73.78</td><td>63.91</td><td>70.09</td><td>56.51</td><td>65.73</td><td>67.23</td></tr><tr><td>TransVG [7]</td><td>BERT</td><td>None</td><td>×</td><td>81.02</td><td>82.72</td><td>78.35</td><td>64.82</td><td>70.70</td><td>56.94</td><td>68.67</td><td>67.73</td></tr><tr><td>Ours</td><td>BERT</td><td>None</td><td>√</td><td>82.23</td><td>85.59</td><td>76.57</td><td>71.58</td><td>75.96</td><td>62.16</td><td>69.41</td><td>69.40</td></tr><tr><td>Pretrained:</td><td></td><td></td><td>√</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>MDETR [23] Ours*</td><td>RoBERTa BERT</td><td>200k 100k</td><td>√</td><td>86.75 85.65</td><td>89.58 88.73</td><td>81.41 81.16</td><td>79.52 77.55</td><td>84.09 82.26</td><td>70.62 68.99</td><td>81.64 79.25</td><td>80.89 80.01</td></tr></table>
+
+# 4.6 Comparison with Contemporaneous Work
+
+Concurrent and independent to us, very recently, there are some closely related works that use transformers for visual referring tasks [7, 10, 23]. We will briefly discuss some of the differences.
+
+To begin, [7, 10] focus on REC, while our approach is formulated in multi-task setting and solves both REC and RES tasks simultaneously. In addition, our model is faster and is capable of grounding multiple contextualized phrases, while [7, 10] follow previous one-stage approaches and are only able to infer a single expression at a time; leading, in our case, to more accurate results. MDETR [23] leverages contrastive loss and soft token loss to help better match bounding boxes to phrases. In contrast, our method adopts a simple and straightforward method to pre-match bounding boxes to phrases using a one-to-one matching; this leads to simpler learning objective.
+
+We provide quantitative comparison on REC task with these approaches, based on their reported numbers in Table 6. Compared to [7, 10], our model performs substantially better in all, with an exception of RefCOCO testB (where [7] is marginally better), datasets and splits. The biggest improvements can be seen on $\operatorname { R e f C O C O + }$ , where our model is $1 0 . 4 \%$ better (or 6.76 points better), than the closest concurrent work of [7], on the Val split; similar sizable improvements are illustrated on other splits, e.g., $9 . 2 \%$ on $\operatorname { R e f C O C O + }$ testB. In addition, our approach is considerably faster in runtime, since our model is able to handle multiple queries simultaneously (unlike [7, 10]). Compared to [23], in a pretrained model setting, we see that our model performs similarly on RefCOCO and marginally worse on $\operatorname { R e f C O C O + }$ and $\operatorname { R e f C O C O g }$ . This difference can perhaps be attributed to two factors: (1) larger pretrain dataset and longer triaining schedule. (As reported in [23], MDETR takes 224 GPU days to pretrain, while the pretraining for our model is roughly 28 GPU days) (2) using more sophisticated language model (RoBERTa for [23] vs. BERT for us). Limited experiments in Supplemental Material show that indeed, the use of RoBERTa leads to certain improvements. In addition, we setup our method in multi-task setting to solve RES and REC task at the same time, so our formulation while perhaps marginally inferior on REC is more general overall.
+
+# 5 Conclusions and Future Work
+
+In this work, we present Referring Transformer, a one-step approach to referring expression comprehension (REC) and segmentation (RES). We jointly train our model for RES and REC tasks while enabling contextualized multi-expression references. Our models outperform state-of-the-art by a large margin on five / three datasets for REC / RES respectively, while achieving real-time runtime.
+
+One limitation for our model is that we follow the setup in previous works [51, 52] and assume that each expression refers to only one region. In the future, we plan to explore learning to predict multiple regions for each referring entity if necessary. Large-scale multi-task pretraining has been demonstrated to be very effective for ViLBEERT and other similar architectures; this is complementary to our focus in this paper, and we expect such strategies to further improve the performance.
+
+# 6 Acknowledgments and Disclosure of Funding
+
+This work was funded, in part, by the Vector Institute for AI, Canada CIFAR AI Chair, NSERC CRC, NSERC Discovery and Discovery Accelerator Grants. Resources used in preparing this research were provided, in part, by the Province of Ontario, the Government of Canada through CIFAR, and companies sponsoring the Vector Institute www.vectorinstitute.ai/#partners. Additional hardware support was provided by John R. Evans Leaders Fund CFI grant and Compute Canada under the Resource Allocation Competition award.
+
+References   
+[1] M. Bajaj, L. Wang, and L. Sigal. G3raphground: Graph-based language grounding. In Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), pages 4281–4290, 2019.   
+[2] N. Carion, F. Massa, G. Synnaeve, N. Usunier, A. Kirillov, and S. Zagoruyko. End-to-end object detection with transformers. In European Conference on Computer Vision (ECCV), pages 213–229, 2020.   
+[3] K. Chen, R. Kovvuri, and R. Nevatia. Query-guided regression network with context policy for phrase grounding. In Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), pages 824–832, 2017.   
+[4] X. Chen, L. Ma, J. Chen, Z. Jie, W. Liu, and J. Luo. Real-time referring expression comprehension by single-stage grounding network. arXiv preprint arXiv:1812.03426, 2018.   
+[5] Y.-C. Chen, L. Li, L. Yu, A. El Kholy, F. Ahmed, Z. Gan, Y. Cheng, and J. Liu. Uniter: Universal image-text representation learning. In European Conference on Computer Vision (ECCV), pages 104–120, 2020.   
+[6] Y. W. Chen, Y. H. Tsai, T. Wang, Y. Y. Lin, and M. H. Yang. Referring expression object segmentation with caption-aware consistency. In Proceedings of the British Machine Vision Conference (BMVC), 2019.   
+[7] J. Deng, Z. Yang, T. Chen, W. Zhou, and H. Li. TransVG: End-to-end visual grounding with transformers. arXiv preprint arXiv:2104.08541, 2021.   
+[8] J. Devlin, M.-W. Chang, K. Lee, and K. 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.   
+[9] P. Dogan, L. Sigal, and M. Gross. Neural sequential phrase grounding (seqground). In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pages 4175–4184, 2019.   
+[10] Y. Du, Z. Fu, Q. Liu, and Y. Wang. Visual grounding with transformers. arXiv preprint arXiv:2105.04281, 2021.   
+[11] K. Duan, S. Bai, L. Xie, H. Qi, Q. Huang, and Q. Tian. Centernet: Keypoint triplets for object detection. In Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), pages 6569–6578, 2019.   
+[12] Z. Gan, Y.-C. Chen, L. Li, C. Zhu, Y. Cheng, and J. Liu. Large-scale adversarial training for vision-andlanguage representation learning. In Proceedings of the International Conference on Neural Information Processing Systems (NeurIPS), 2020.   
+[13] P. Gao, M. Zheng, X. Wang, J. Dai, and H. Li. Fast convergence of detr with spatially modulated co-attention. arXiv preprint arXiv:2101.07448, 2021.   
+[14] X. Glorot and Y. Bengio. Understanding the difficulty of training deep feedforward neural networks. In Proceedings of the Thirteenth International Conference on Artificial Intelligence and Statistics, pages 249–256, 2010.   
+[15] K. He, X. Zhang, S. Ren, and J. Sun. Deep residual learning for image recognition. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pages 770–778, 2016.   
+[16] K. He, G. Gkioxari, P. Dollár, and R. Girshick. Mask r-cnn. In Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), pages 2961–2969, 2017.   
+[17] R. Hong, D. Liu, X. Mo, X. He, and H. Zhang. Learning to compose and reason with language tree structures for visual grounding. IEEE Transactions on Pattern Analysis and Machine Intelligence (TPAMI), 2019.   
+[18] R. Hu, M. Rohrbach, and T. Darrell. Segmentation from natural language expressions. In European Conference on Computer Vision (ECCV), pages 108–124, 2016.   
+[19] R. Hu, M. Rohrbach, J. Andreas, T. Darrell, and K. Saenko. Modeling relationships in referential expressions with compositional modular networks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pages 1115–1124, 2017.   
+[20] Z. Hu, G. Feng, J. Sun, L. Zhang, and H. Lu. Bi-directional relationship inferring network for referring image segmentation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2020.   
+[21] S. Huang, T. Hui, S. Liu, G. Li, Y. Wei, J. Han, L. Liu, and B. Li. Referring image segmentation via cross-modal progressive comprehension. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2020.   
+[22] Y. Jing, T. Kong, W. Wang, L. Wang, L. Li, and T. Tan. Locate then segment: A strong pipeline for referring image segmentation. arXiv preprint arXiv:2103.16284, 2021.   
+[23] A. Kamath, M. Singh, Y. LeCun, I. Misra, G. Synnaeve, and N. Carion. MDETR–modulated detection for end-to-end multi-modal understanding. arXiv preprint arXiv:2104.12763, 2021.   
+[24] S. Kazemzadeh, V. Ordonez, M. Matten, and T. Berg. Referitgame: Referring to objects in photographs of natural scenes. In Proceedings of the Conference on Empirical Methods in Natural Language Processing (EMNLP), pages 787–798, 2014.   
+[25] R. Krishna, Y. Zhu, O. Groth, J. Johnson, K. Hata, J. Kravitz, S. Chen, Y. Kalantidis, L.-J. Li, D. A. Shamma, et al. Visual genome: Connecting language and vision using crowdsourced dense image annotations. International Journal of Computer Vision (IJCV), 123(1):32–73, 2017.   
+[26] Y. Liao, S. Liu, G. Li, F. Wang, Y. Chen, C. Qian, and B. Li. A real-time cross-modality correlation filtering method for referring expression comprehension. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2020.   
+[27] T.-Y. Lin, M. Maire, S. Belongie, J. Hays, P. Perona, D. Ramanan, P. Dollár, and C. L. Zitnick. Microsoft coco: Common objects in context. In European Conference on Computer Vision (ECCV), pages 740–755, 2014.   
+[28] T.-Y. Lin, P. Goyal, R. Girshick, K. He, and P. Dollár. Focal loss for dense object detection. In Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), pages 2980–2988, 2017.   
+[29] D. Liu, H. Zhang, F. Wu, and Z.-J. Zha. Learning to assemble neural module tree networks for visual grounding. In Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), pages 4673–4682, 2019.   
+[30] X. Liu, Z. Wang, J. Shao, X. Wang, and H. Li. Improving referring expression grounding with crossmodal attention-guided erasing. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pages 1950–1959, 2019.   
+[31] J. Long, E. Shelhamer, and T. Darrell. Fully convolutional networks for semantic segmentation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pages 3431– 3440, 2015.   
+[32] I. Loshchilov and F. Hutter. Decoupled weight decay regularization. In International Conference on Learning Representations (ICLR), 2019.   
+[33] J. Lu, D. Batra, D. Parikh, and S. Lee. ViLBERT: Pretraining task-agnostic visiolinguistic representations for vision-and-language tasks. In Proceedings of the International Conference on Neural Information Processing Systems (NeurIPS), pages 13–23, 2019.   
+[34] J. Lu, V. Goswami, M. Rohrbach, D. Parikh, and S. Lee. 12-in-1: Multi-task vision and language representation learning. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pages 10437–10446, 2020.   
+[35] G. Luo, Y. Zhou, R. Ji, X. Sun, J. Su, C.-W. Lin, and Q. Tian. Cascade grouped attention network for referring expression segmentation. In ACM International Conference on Multimedia, 2020.   
+[36] G. Luo, Y. Zhou, X. Sun, L. Cao, C. Wu, C. Deng, and R. Ji. Multi-task collaborative network for joint referring expression comprehension and segmentation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2020.   
+[37] J. Mao, J. Huang, A. Toshev, O. Camburu, A. L. Yuille, and K. Murphy. Generation and comprehension of unambiguous object descriptions. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pages 11–20, 2016.   
+[38] E. Margffoy-Tuay, J. C. Pérez, E. Botero, and P. Arbeláez. Dynamic multimodal instance segmentation guided by natural language queries. In European Conference on Computer Vision (ECCV), 2018.   
+[39] F. Milletari, N. Navab, and S.-A. Ahmadi. V-net: Fully convolutional neural networks for volumetric medical image segmentation. In International Conference on 3D Vision (3DV), pages 565–571, 2016.   
+[40] V. K. Nagaraja, V. I. Morariu, and L. S. Davis. Modeling context between objects for referring expression understanding. In European Conference on Computer Vision (ECCV), pages 792–807, 2016.   
+[41] B. A. Plummer, L. Wang, C. M. Cervantes, J. C. Caicedo, J. Hockenmaier, and S. Lazebnik. Flickr30k entities: Collecting region-to-phrase correspondences for richer image-to-sentence models. In Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), pages 2641–2649, 2015.   
+[42] B. A. Plummer, P. Kordas, M. H. Kiapour, S. Zheng, R. Piramuthu, and S. Lazebnik. Conditional image-text embedding networks. In European Conference on Computer Vision (ECCV), pages 249–264, 2018.   
+[43] J. Redmon and A. Farhadi. Yolov3: An incremental improvement. arXiv preprint arXiv:1804.02767, 2018.   
+[44] S. Ren, K. He, R. Girshick, and J. Sun. Faster r-cnn: Towards real-time object detection with region proposal networks. IEEE Transactions on Pattern Analysis and Machine Intelligence (TPAMI), 39(6): 1137–1149, 2017.   
+[45] H. Rezatofighi, N. Tsoi, J. Gwak, A. Sadeghian, I. Reid, and S. Savarese. Generalized intersection over union: A metric and a loss for bounding box regression. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pages 658–666, 2019.   
+[46] A. Sadhu, K. Chen, and R. Nevatia. Zero-shot grounding of objects from natural language queries. In Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), pages 4694–4703, 2019.   
+[47] H. Tan and M. Bansal. Lxmert: Learning cross-modality encoder representations from transformers. Proceedings of the Conference on Empirical Methods in Natural Language Processing (EMNLP), 2019.   
+[48] L. Wang, Y. Li, J. Huang, and S. Lazebnik. Learning two-branch neural networks for image-text matching tasks. IEEE Transactions on Pattern Analysis and Machine Intelligence (TPAMI), 41(2):394–407, 2018.   
+[49] T. Wolf, L. Debut, V. Sanh, J. Chaumond, C. Delangue, A. Moi, P. Cistac, T. Rault, R. Louf, M. Funtowicz, J. Davison, S. Shleifer, P. von Platen, C. Ma, Y. Jernite, J. Plu, C. Xu, T. L. Scao, S. Gugger, M. Drame, Q. Lhoest, and A. M. Rush. Transformers: State-of-the-art natural language processing. In Proceedings of the Conference on Empirical Methods in Natural Language Processing (EMNLP), pages 38–45, 2020.   
+[50] S. Yang, G. Li, and Y. Yu. Propagating over phrase relations for one-stage visual grounding. In European Conference on Computer Vision, pages 589–605. Springer, 2020.   
+[51] Z. Yang, B. Gong, L. Wang, W. Huang, D. Yu, and J. Luo. A fast and accurate one-stage approach to visual grounding. In Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), pages 4683–4693, 2019.   
+[52] Z. Yang, T. Chen, L. Wang, and J. Luo. Improving one-stage visual grounding by recursive sub-query construction. In European Conference on Computer Vision (ECCV), 2020.   
+[53] L. Ye, M. Rochan, Z. Liu, and Y. Wang. Cross-modal self-attention network for referring image segmentation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2019.   
+[54] F. Yu, J. Tang, W. Yin, Y. Sun, H. Tian, H. Wu, and H. Wang. Ernie-vil: Knowledge enhanced visionlanguage representations through scene graph. arXiv preprint arXiv:2006.16934, 2020.   
+[55] L. Yu, P. Poirson, S. Yang, A. C. Berg, and T. L. Berg. Modeling context in referring expressions. In European Conference on Computer Vision (ECCV), pages 69–85, 2016.   
+[56] L. Yu, Z. Lin, X. Shen, J. Yang, X. Lu, M. Bansal, and T. L. Berg. Mattnet: Modular attention network for referring expression comprehension. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pages 1307–1315, 2018.   
+[57] Z. Yu, J. Yu, C. Xiang, Z. Zhao, Q. Tian, and D. Tao. Rethinking diversified and discriminative proposal generation for visual grounding. International Joint Conference on Artificial Intelligence (IJCAI), 2018.   
+[58] X. Zhu, W. Su, L. Lu, B. Li, X. Wang, and J. Dai. Deformable detr: Deformable transformers for end-to-end object detection. In International Conference on Learning Representations (ICLR), 2021.

parse/train/J64lDCrYGi/J64lDCrYGi_content_list.json

@@ -0,0 +1,1058 @@
+[
+    {
+        "type": "text",
+        "text": "Referring Transformer: A One-step Approach to Multi-task Visual Grounding ",
+        "text_level": 1,
+        "bbox": [
+            204,
+            122,
+            795,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Muchen Li1,2 muchenli@cs.ubc.ca ",
+        "bbox": [
+            292,
+            224,
+            457,
+            253
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Leonid Sigal1,2,3,4 lsigal@cs.ubc.ca ",
+        "bbox": [
+            547,
+            224,
+            684,
+            255
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1Department of Computer Science, University of British Columbia   \n2Vector Institute for AI 3CIFAR AI Chair 4NSERC CRC Chair ",
+        "bbox": [
+            263,
+            258,
+            735,
+            287
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            323,
+            535,
+            339
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "As an important step towards visual reasoning, visual grounding (e.g., phrase localization, referring expression comprehension / segmentation) has been widely explored. Previous approaches to referring expression comprehension (REC) or segmentation (RES) either suffer from limited performance, due to a two-stage setup, or require the designing of complex task-specific one-stage architectures. In this paper, we propose a simple one-stage multi-task framework for visual grounding tasks. Specifically, we leverage a transformer architecture, where two modalities are fused in a visual-lingual encoder. In the decoder, the model learns to generate contextualized lingual queries which are then decoded and used to directly regress the bounding box and produce a segmentation mask for the corresponding referred regions. With this simple but highly contextualized model, we outperform state-of-the-art methods by a large margin on both REC and RES tasks. We also show that a simple pre-training schedule (on an external dataset) further improves the performance. Extensive experiments and ablations illustrate that our model benefits greatly from contextualized information and multi-task training. ",
+        "bbox": [
+            233,
+            356,
+            766,
+            563
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            589,
+            310,
+            607
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Multi-modal grounding1 tasks (e.g., phrase localization [1, 3, 9, 41, 48], referring expression comprehension [17, 19, 24, 26, 29, 30, 37, 51, 52, 55, 56] and segmentation [6, 18, 20, 21, 29, 38, 53, 56]) aim to generalize traditional object detection and segmentation to localization of regions (rectangular or at a pixel level) in images that correspond to free-form linguistic expressions. These tasks have emerged as core problems in vision and ML due to the breadth of applications that can make use of such techniques, spanning image captioning, visual question answering, visual reasoning and others. ",
+        "bbox": [
+            174,
+            622,
+            825,
+            705
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The majority of multi-modal grounding architectures, to date, take the form of two-stage approaches, inspired by Faster RCNN [44] and others, which first generate a set of image region proposals and then associate/ground one, or more, of these regions to a phrase by considering how well the content matches the query phrase. Context among the regions and multiple query phrases, which often come parsed from a single sentence, has also been considered in various ways (e.g., using LSTM stacks [9], graph neural networks [1] and others). More recent variants leverage pre-trained multi-modal Transformers (e.g., ViLBERT [33, 34]) to fine-tune to the grounding tasks. Such models have an added benefit of being able to learn sophisticated cross-modal feature representations from external large-scale data, which further improve the performance. However, a significant limitation of all such two-stage methods is their inability to condition the proposal mechanism on the query phrase itself, which inherently limits the upper bound of performance (see Table 3 in [51]). ",
+        "bbox": [
+            174,
+            712,
+            825,
+            823
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            92,
+            823,
+            133
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To address these limitations, more recently, a number of one-stage approaches have been introduced [22, 36, 51, 52]. Most of these take inspiration from Yolo [43] and the variants, and rely on more integrated visual-linguistic fusion and a dense anchoring mechanism to directly predict the grounding regions. While this alleviates the need for a proposal stage, it instead requires somewhat ad hoc anchor definitions, often obtained by clustering of labeled regions, and also limits ability to contextualize grounding decisions as each query phrase is effectively processed independently. Finally, little attention in the literature has been given to leveraging relationship among the REC and RES tasks. ",
+        "bbox": [
+            174,
+            140,
+            825,
+            237
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this work we propose an end-to-end one-stage architecture, inspired by the recent DETR [2] detection framework, which is capable of simultaneous language grounding at both a boundingbox and segmentation level, without requiring dense anchor definitions. This model also enables contextualized reasoning by taking into account the entire image, all referring query phrases of interest and (optionally) lingual context (e.g., a sentence from which referring phrases are parsed). Specifically, we leverage a transfomer architecture, with a visual-lingual encoder, to encode image and lingual context, and a two-headed (detection and segmentation) custom contextualized tranformer decoder. The contextualized decoder takes as input learned contextualized phrase queries and decodes them directly to bounding boxes and segmentation masks. Implicit 1-to-1 correspondence between input referring phrases and resulting outputs also enables a more direct formulation of the loss without requiring Hungarian matching. With this simple model we outperform state-of-the-art methods by a large margin on both REC and RES tasks. We also show that a simple pre-training schedule (on an external dataset) further improves the performance. Extensive experiments and ablations illustrate that our model benefit greatly from the contextualized information and the multi-task training. ",
+        "bbox": [
+            174,
+            242,
+            825,
+            435
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Contributions. Our contributions are: (1) We propose a simple and general one-stage transformerbased architecture for referring expression comprehension and segmentation. The core of this model is the novel transformer decoder that leverages contextualized phrase queries and is able to directly decode those, subject to contextualized image embeddings, into corresponding image regions and segments; (2) Our approach is unique in enabling simultaneous REC and RES using a single trained model (the only other method capable of this is [36]); showing that such multi-task learning leads to improvements on both tasks; (3) As with other transformer-based architectures, we show that pre-training can further improve the performance and both vanila and pre-trained models outperform state-of-the-art on both tasks by significant margins (up to $8 . 5 \\%$ on RefCOCO dataset for REC and $1 9 . 4 \\%$ for RES). We also thoroughly validate our design in detailed ablations. ",
+        "bbox": [
+            174,
+            443,
+            825,
+            580
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Related works ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            599,
+            325,
+            616
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Referring Expression Comprehension (REC). REC focuses on producing an image bounding box tightly encompassing a language query. Previous two-staged works [17, 19, 29, 30, 56] reformulate this as a ranking task with a set of candidate regions predicted from a pre-trained proposal mechanism. Despite achieving great success, the performance of two-staged methods is capped by the speed and accuracy of region proposals in the first stage. More recently, one-stage approaches [26, 51, 52] have been used to alleviate the aforementioned limitations. Yang et al. [51, 52] proposed to fuse query information with visual features and pick the bounding box with maximum activation scores from YOLOv3 [43]. Yang et al. [50] explore language structure guided propagation in the context of one stage grounding. Liao et al. [26] utilizes CenterNet [11] to perform correlation filtering for region center localization. However, such methods either require manually tuned anchor boxes or suffer from semantic loss due to modality misalignment. In contrast, our model learns to better align modalities using a cross-modal transformer and directly decode bounding boxes for each query. ",
+        "bbox": [
+            174,
+            628,
+            825,
+            794
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Referring Expression Segmentation (RES). Similar to REC, RES, proposed in [18], aims to predict segmentation masks to better describe the shape of the referred region. A typical solution for referring expression segmentation is to fuse multi-modal information with a segmentation network (e.g., [16, 31]) and train it to output the segmented masks [18, 29, 38, 53, 56]. More recent approaches focus on designing module to enable better multi-modal interactions, e.g., progressive multi-scale fusion used in [21] and cross-modal attention block used in [20]. Since localization information matters in predicting instance segmentations (as noted in Mask RCNN [16]), very recent work [22] aims to explicitly localize object before doing segmentation. Despite the relatively high performance being achieved in RES, existing approaches still struggle to determine the correct referent region and tend to output noisy segmentation results with an irregular shape, while our model is able to produce segmentations with fine-grained shapes even on challenging scenarios with occlusions or shadows. ",
+        "bbox": [
+            174,
+            800,
+            825,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            92,
+            823,
+            133
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Multi-task Learning for REC and RES. Multi-task learning is widely applied in object detection and segmentation [2, 16], often, by leveraging shared backbone and task-specific heads. Building on this idea, Luo et al. [36] proposed a multi-task collaborative network (MCN) to jointly address REC and RES. They introduce consistency energy maximization loss that constrains the feature activation map in REC and RES to be similar. While our model is also set up to learn REC and RES tasks jointly, we argue that an explicit constraint tends to downplay the quality of the final predicted mask since the feature map from the REC branch can blur out fine-grained region shape information needed by the RES branch (see Figure 2). Hence, we use an implicit constraint where tasks head of REC and RES are trained to output corresponding bounding box and mask from the same joint multi-modal representation. We illustrate that our model can benefit from multi-task supervision, leading to more accurate results as compared to single-task variants. ",
+        "bbox": [
+            174,
+            138,
+            825,
+            291
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Pretrained Multi-modal Transformers. Transformer-based pretrained models [5, 12, 33, 47, 54] have recently showed strong potential in multi-modal understanding. LXMERT [47] and ViLBERT [33] use two stream transformers with cross-attention transformer layers on top for multimodal fusion. More recent works, [5, 12] advocate a single-stream design to fuse two modalities earlier. The success of the aforementioned models can largely be attributed to the cross-modal representations obtained by multi-task pretraining on a large amount of aligned image-text pairs. Despite state-of-the-art performance of such models on the downstream REC task, these models, fundamentally, are still a form of a two-stage pipeline where image features are extracted using pretrained detectors or proposal mechanisms. We focus on a one-stage architecture variant that allows visual and lingual features to be aligned at the early stages. Although the focus of our work is not to design a better pretraining scheme, we show that our model can outperform the existing state-of-the-art with proper pretraining. ",
+        "bbox": [
+            174,
+            297,
+            825,
+            450
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Transformer-based Detectors. More recently, DETR [2] and its variants [13, 58], were proposed to enable end-to-end object detection. DETR reformulates detection as a set prediction tasks and uses transformers to decode learnable queries to bounding boxes. Despite state-of-art performance, DETR is disadvantaged by its optimization difficulty and, usually, extra-long training time. While adopting a similar pipeline, our model focus on aligning different modalities to generate contextualized expression-specific referring queries. We also design our model to get rid of Hungarian matching loss by leveraging one-to-one correspondences between predicted bounding boxes and referring expressions, which leads to faster convergence for our model. ",
+        "bbox": [
+            174,
+            455,
+            825,
+            566
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 Approach ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            582,
+            289,
+            599
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Given an image $\\mathcal { T }$ and a set of query phrases $\\mathcal { Q } _ { p } = \\{ \\mathbf { p } _ { i } \\} _ { i = 1 , \\dots , M }$ , that we assume to come from an (optional) contextual text source2 $\\mathcal { Q }$ , our goal is to predict a set of bounding boxes $B = \\{ \\mathbf { b } _ { i } \\} _ { i = 1 , \\dots , M }$ and corresponding segmentation masks ${ \\cal S } = \\{ { \\bf s } _ { i } \\} _ { i = 1 , \\dots , M }$ , one for each query phrase $i$ that localizes that phrase in the image. Note, $M$ is the number of phrases / referring expressions for a given image $\\mathcal { T }$ and is typically between 1 and 16 for the Flick $3 0 \\mathrm { k }$ [41] dataset. ",
+        "bbox": [
+            174,
+            608,
+            823,
+            680
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "As shown in Figure 1, our referring transformer is composed of four components. Given an image(con)text pair, $<  { \\mathcal { T } } ,  { \\mathcal { Q } } >$ , a cross-modal encoder generates joint image-text embeddings for each visual and textual token – feature columns and word embeddings respectively. Query phrases $\\mathcal { Q } _ { p }$ and image-text embeddings are then fed into a query encoder which produces query phrase embeddings. The decoder jointly reasons across all these query phrase embeddings and decodes multi-task feature, which is then sent to the detection and segmentation head to produce a set of boxes $\\boldsymbol { B }$ and masks $s$ The result is a one-staged end-to-end model that solves the REC and RES tasks at the same time. We will now introduce constituent architectural components for the four stages briefly described above. ",
+        "bbox": [
+            174,
+            685,
+            825,
+            797
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 Feature Extraction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            815,
+            344,
+            830
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Visual & Text Backbone. Starting from an initial image $\\mathcal { T } \\in \\mathbb { R } ^ { 3 \\times H _ { 0 } \\times W _ { 0 } }$ , we adopt the widely used ResNet [15] to generate its low-resolution feature map $\\mathbf { f } _ { I } \\in \\mathbb { R } ^ { C _ { i } \\times H W }$ . For the corresponding expression or sentence, we use the uncased base of BERT [8] to obtain the representation $\\mathbf { f } _ { Q } \\in$ $\\mathbb { R } ^ { C _ { t } \\times N }$ , while $N$ is the length of the input context sentence. ",
+        "bbox": [
+            174,
+            842,
+            823,
+            871
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/e40ae0a0b3ed22270911f094dd1b90cc0e55acb591f3e2843ed7485181a3033e.jpg",
+        "image_caption": [
+            "Figure 1: Referring Transformer. An overview of the proposed architecture is shown in (a). For an image and (con)text input, a visual-lingual encoder is used to refine image features, extracted from a convolutional backbone, and lingual features, extracted by a BERT. A query encoder and decoder produce features for REC and RES heads, given multi-modal features and query phrases. The detailed structure of the query encoder and decoder is shown in (b). Colored squares denote embeddings for corresponding query phrases. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            90,
+            816,
+            314
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            417,
+            821,
+            448
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Visual-Lingual Encoder. The visual-lingual encoder is designed to fuse information from multimodal sources. For cross-modality encoding, we use a transformer encoder based model, which is composed of 6 transformer encoder layers. Specifically, given both image and text features, multi-layer perceptrons are applied first to project different modalities to a joint embedding space with a hidden dimension of $C$ . To provide transformer encoders with positional information, we follow [2, 8] to add cosine positional embedding $P _ { i m g }$ for image features and learnable positional embedding $P _ { t e x t }$ for text features. We then concatenate the projected features into a single sequence $\\mathbf { f } ~ \\in ~ \\mathbb { R } ^ { C \\times ( H W + N ) }$ . To distinguish between modalities, we also deign a learnable modal label embedding $E _ { l a b e l } : \\{ E _ { i m g } , E _ { t e x t } ^ { - } \\}$ which is added to the original sequences. The visual-lingual encoder then takes a sequence as input, and $\\{ P _ { i m g } , P _ { t e x t } , E _ { l a b e l } \\}$ are fed into each encoder layer. The encoder output is a multi-modal feature sequence $\\mathbf { f } _ { v l } \\in \\mathbb { R } ^ { C \\times ( H W + N ) }$ . ",
+        "bbox": [
+            173,
+            454,
+            825,
+            609
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 Query Encoder and Decoder ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            626,
+            411,
+            640
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The query encoder and decoder aims to encode / decode query phrases, conditioned on visual-lingual features from the encoder, into an output bounding box and segmentation. In this stage, we first generate embeddings corresponding to each query phrase. These query phrase embeddings are then fed into the decoder together with the visual-lingual features from the encoder to generate outputs. ",
+        "bbox": [
+            174,
+            651,
+            825,
+            707
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Encoding Query Phrases. To enable the decoder to generate the desired output (bounding box and/or segmentation) the queries must encode several bits of crucial information. Mainly, (1) encoding of the query phrases, (2) image encoding and (3) phrase-specific optional (con)text information. For phrase encoding in (1) we use a BERT model with pooling heads which share weights with (con)text encoder; this results in the phrase feature vector $\\mathbf { f _ { p } } _ { i } \\in \\mathbb { R } ^ { C }$ for the $i$ -th referring phrase. We note that because we use visual-lingual encoder, (2) and (3) are jointly encoded in multi-modal features $\\mathbf { f } _ { v l }$ described in Section 3.1 above. However, $\\mathbf { f } _ { v l }$ is phrase-agnostic encoding of the image and (con)text. To generate phrase-specific context, given a phrase $\\mathbf { p } _ { i }$ , average pooling is used to extract the phrase-specific context information $\\mathbf { f } _ { c } ( \\mathbf { p } _ { i } )$ from the visual-lingual feature sequence as follows: ",
+        "bbox": [
+            173,
+            712,
+            825,
+            849
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e2e90a85e446958d0263727e66978780d9c6e97128c1945208a61a1ccb2a6aab.jpg",
+        "text": "$$\n\\mathbf { f } _ { c } ( \\mathbf { p } _ { i } ) = \\frac { \\sum \\mathbf { f } _ { v l } [ l _ { \\mathbf { p } _ { i } } : r _ { \\mathbf { p } _ { i } } ] } { r _ { \\mathbf { p } _ { i } } - l _ { \\mathbf { p } _ { i } } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            413,
+            845,
+            583,
+            881
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $l _ { \\mathbf { p } _ { i } }$ and $r _ { \\mathbf { p } _ { i } }$ denotes the left and right bounds of phrase $\\mathbf { p } _ { i }$ in the original (con)text sentence. Finally, given phrase encoding $\\mathbf { f _ { p } } _ { i }$ and phrase-specific context $\\mathbf { f } _ { c } ( \\mathbf { p } _ { i } )$ we construct our phrase queries ",
+        "bbox": [
+            173,
+            883,
+            823,
+            912
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "using a multi-later perceptron: ",
+        "bbox": [
+            174,
+            92,
+            374,
+            106
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a7e972d95010fe1816927ef162a16a71463820f5e002b9992c2e318c810ad631.jpg",
+        "text": "$$\n\\widehat { Q _ { { \\bf p } i } } = \\mathtt { M L P } \\left( [ { \\bf f } _ { c } ( { \\bf p } _ { i } ) ; { \\bf f _ { p } } _ { i } ] \\right) + E _ { p } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            392,
+            111,
+            606,
+            132
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $E _ { p } \\in \\mathbb { R } ^ { C }$ is a learnable embedding which serves as a bias to the formed query. ",
+        "bbox": [
+            166,
+            138,
+            732,
+            154
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Decoding. In the decoder, self attention layers are used to enable information flow in a dense connected graph of phrase queries. This allows phrase queries to contextualize and refine each other; the inspiration for this step is taken from [1]. After that, a cross attention layer decodes visual-lingual information given the updated phrase query and feature sequence from the encoder. The design of our decoder is similar to the transformer decoder, except attention is non-causal. ",
+        "bbox": [
+            174,
+            159,
+            825,
+            229
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.3 Multi-task training ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            244,
+            348,
+            261
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this section, we demonstrate how the decoded phrase-specific query features can be naturally used to train multiple heads for different referring tasks (regression for REC and segmentation for RES). ",
+        "bbox": [
+            174,
+            270,
+            823,
+            299
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Referring Comprehension/Detection (REC). For referring detection tasks, the final output is computed by a simple two-layer perceptron over the decoded phrase-specific query features. We let the detection head directly output center coordinates $\\tilde { \\mathbf { b } } = ( x , y , h , w )$ for the referred image. To supervise the training, we use a weighted sum of an L1 loss and a Generalized IOU loss [45]: ",
+        "bbox": [
+            173,
+            304,
+            825,
+            363
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7ea9297155a964ddb353e7cc07414bc35845c0b4ae41fa86e3421fff6e0be1aa.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathcal { L } _ { d e t } = \\lambda _ { i o u } \\mathcal { L } _ { i o u } ( \\mathbf { b } , \\tilde { \\mathbf { b } } ) + \\lambda _ { L 1 } | | \\mathbf { b } - \\tilde { \\mathbf { b } } | | _ { 1 } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            362,
+            368,
+            635,
+            387
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The $\\lambda _ { i o u }$ and $\\lambda _ { L 1 }$ control the relative weighting of the two losses in the REC objective. ",
+        "bbox": [
+            173,
+            393,
+            741,
+            409
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Referring Segmentation (RES). Following previous work [2], we design an FPN-like architecture to predict a referring segmentation mask for each phrase expression. Attention masks from the decoder and image features from the visual-lingual encoder are concatenated as the FPN input, while features from different stages of image backbones are used as skip connections to refine the final output. The last linear layer project the upsampled feature to a single channel heatmap and a sigmoid function is used to map the feature to mask scores $\\tilde { \\mathbf { s } } \\in \\mathbb { R } ^ { H _ { 0 } / 4 \\times W _ { 0 } / 4 }$ . The loss for training RES task is: ",
+        "bbox": [
+            173,
+            412,
+            825,
+            511
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/466a7fada956653e94f48a3f0d9f757580f9b7da25dd7e13ff9bf3b38ad226a6.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathcal { L } _ { s e g } = \\lambda _ { f o c a l } \\mathcal { L } _ { f o c a l } ( \\mathbf { s } , \\tilde { \\mathbf { s } } ) + \\lambda _ { d i c e } \\mathcal { L } _ { d i c e } ( \\mathbf { s } , \\tilde { \\mathbf { s } } ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            346,
+            511,
+            650,
+            529
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Here $\\mathcal { L } _ { f o c a l }$ is the focal loss for classifying pixels used in [28], $\\mathcal { L } _ { d i c e }$ is the DICE/F-1 loss proposed in [39]; $\\lambda _ { f o c a l }$ and $\\lambda _ { d i c e }$ are hyper-parameters controlling the relative importance of the two losses. ",
+        "bbox": [
+            171,
+            530,
+            823,
+            559
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Joint Training. While it is possible to train referring segmentation and referring detection tasks separately, we find that joint training is highly beneficial. Therefore the combined training loss which we optimize is $\\mathcal { L } = \\mathcal { L } _ { s e g } + \\mathcal { L } _ { d e t }$ . ",
+        "bbox": [
+            174,
+            564,
+            823,
+            608
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Pretraining the Transformer. Transformers are generally data hungry and requires a lot of data to train [5, 33]. Although in this paper we do not use a large pretraining model and a lot of data. We found that simple pretraining strategy on the region description splits of Visual-Genome dataset [25] makes our model achieve comparable and even better performance against some of state-of-the-art pretrained models. Interestingly, we found that although there is no ground truth segmentation provided in Visual-Genome, the RES task can still benefit greatly from pretrained models, likely due to the fine-tuned multi-task representation. ",
+        "bbox": [
+            173,
+            613,
+            825,
+            710
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            723,
+            312,
+            739
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 Datasets ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            747,
+            272,
+            762
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "RefCOCO/RefCOCO $^ +$ /RefCOCOg (REC&RES). RefCOCO, RefCOCO $^ +$ [55] and RefCOCOg [40] are collections of images and referred objects from MSCOCO [27]. On RefCOCO and Ref$\\mathrm { C O C O + }$ we follow the split used in [55] and report scores on the validation, testA and testB splits. On RefCOCOg, we use the RefCOCO-umd splits proposed in [40]. ",
+        "bbox": [
+            174,
+            772,
+            826,
+            829
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Flickr30k Entities (REC). Flickr30k Entities [41] contains 31,783 images and $1 5 8 \\mathrm { k }$ caption sentences with 427k annotated phrase. We use splits from [41, 42]. Bounding boxes and phrase annotations are consistent with the previous one-stage approaches [51, 52] for fair comparisons. ",
+        "bbox": [
+            174,
+            834,
+            825,
+            877
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "ReferIt (REC). The ReferItGame dataset [24] contains 20,000 images. We follow setup in [3] for splitting train, validation and test set; resulting in 54k, 6k and 6k referring expressions respectively. ",
+        "bbox": [
+            173,
+            882,
+            821,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/fe6ad8c71f4e1ea98a00788df050322d5fad0606b76dc406574e4f9a44fec78c.jpg",
+        "table_caption": [
+            "Table 1: Comparison on REC task. Performance on RefCOCO/RefCOCO+/RefCOCOg datasets [55] is reported. Ours∗ denotes that pretraining is used. RN50 and RN101 refer to ResNet50 and ResNet101 [15] respectively; DN53 refers to DarkNet53 [43] backbone. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Models</td><td rowspan=\"2\">Visual Features</td><td rowspan=\"2\">Pretrain Images</td><td rowspan=\"2\">Multi- task</td><td colspan=\"3\">RefCOCO</td><td colspan=\"3\">RefCOCO+</td><td rowspan=\"2\">RefCOCOg</td></tr><tr><td>val</td><td>testA</td><td>testB</td><td>val</td><td>testA</td><td>testB val-u</td></tr><tr><td>Two-stage:</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td>test-u</td></tr><tr><td>CMN[19]</td><td>VGG16</td><td>None</td><td>×</td><td>-</td><td>71.03</td><td>65.77</td><td>-</td><td>54.32</td><td>47.76</td><td>-</td><td>-</td></tr><tr><td>RvG-Tree [17]</td><td>RN101</td><td>None</td><td>×</td><td>75.06</td><td>78.61</td><td>69.85</td><td>63.51</td><td>67.45</td><td>56.66</td><td>66.95</td><td>66.51</td></tr><tr><td>CM-Att-Erase [30]</td><td>RN101</td><td>None</td><td>×</td><td>78.35</td><td>83.14</td><td>71.32</td><td>68.09</td><td>73.65</td><td>58.03</td><td>67.99</td><td>68.67</td></tr><tr><td>MAttNet [56]</td><td>RN101</td><td>None</td><td>√</td><td>76.65</td><td>81.14</td><td>69.99</td><td>65.33</td><td>71.62</td><td>56.02</td><td>66.58</td><td>67.27</td></tr><tr><td>NMTree [29]</td><td>RN101</td><td>None</td><td>√</td><td>76.41</td><td>81.21</td><td>70.09</td><td>66.46</td><td>72.02</td><td>57.52</td><td>65.87</td><td>66.44</td></tr><tr><td>One-stage:</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>RCCF[26]</td><td>DLA34</td><td>None</td><td>×</td><td>-</td><td>81.06</td><td>71.85</td><td>-</td><td>70.35</td><td>56.32</td><td>-</td><td>65.73</td></tr><tr><td>SSG [4]</td><td>DN53</td><td>None</td><td>×</td><td>=</td><td>76.51</td><td>67.50</td><td>-</td><td>62.14</td><td>49.27</td><td>58.80</td><td>-</td></tr><tr><td>FAOA [51]</td><td>DN53</td><td>None</td><td>×</td><td>72.54</td><td>74.35</td><td>68.50</td><td>56.81</td><td>60.23</td><td>49.60</td><td>61.33</td><td>60.36</td></tr><tr><td>ReSC-Large [52]</td><td>DN53</td><td>None</td><td>×</td><td>77.63</td><td>80.45</td><td>72.30</td><td>63.59</td><td>68.36</td><td>56.81</td><td>67.30</td><td>67.20</td></tr><tr><td>MCN[36]</td><td>DN53</td><td>None</td><td>√</td><td>80.08</td><td>82.29</td><td>74.98</td><td>67.16</td><td>72.86</td><td>57.31</td><td>66.46</td><td>66.01</td></tr><tr><td>Ours</td><td>RN50</td><td>None</td><td>√</td><td>81.82</td><td>85.33</td><td>76.31</td><td>71.13</td><td>75.58</td><td>61.91</td><td>69.32</td><td>69.10</td></tr><tr><td>Ours</td><td>RN101</td><td>None</td><td>√</td><td>82.23</td><td>85.59</td><td>76.57</td><td>71.58</td><td>75.96</td><td>62.16</td><td>69.41</td><td>69.40</td></tr><tr><td>Pretrained:</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>VilBERT[33]</td><td>RN101</td><td>3.3M</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td>RN101</td><td></td><td>×</td><td>-</td><td>=</td><td>-</td><td>72.34</td><td>78.52</td><td>62.61</td><td>1</td><td>-</td></tr><tr><td>ERNIE-ViL_L[54]</td><td>RN101</td><td>4.3M 4.6M</td><td>×</td><td>=</td><td></td><td></td><td>75.89</td><td>82.37</td><td>66.91</td><td></td><td></td></tr><tr><td>UNTIER_L[5]</td><td>RN101</td><td>4.6M</td><td>×</td><td>81.41</td><td>87.04</td><td>74.17</td><td>75.90</td><td>81.45</td><td>66.70</td><td>74.86</td><td>75.77</td></tr><tr><td>VILLA_L[12]</td><td>RN50</td><td></td><td>×</td><td>82.39</td><td>87.48</td><td>74.84</td><td>76.17</td><td>81.54</td><td>66.84</td><td>76.18</td><td>76.71</td></tr><tr><td>Ours*</td><td></td><td>100k</td><td>√</td><td>85.43</td><td>87.48</td><td>79.86</td><td>76.40</td><td>81.35</td><td>66.59</td><td>78.43</td><td>77.86</td></tr><tr><td>Ours*</td><td>RN101</td><td>100k</td><td>√</td><td>85.65</td><td>88.73</td><td>81.16</td><td>77.55</td><td>82.26</td><td>68.99</td><td>79.25</td><td>80.01</td></tr></table>",
+        "bbox": [
+            187,
+            140,
+            805,
+            387
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 Implementing Details ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            411,
+            362,
+            426
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We train our model with AdamW [32]. The initial learning rate is set to 1e-4 while the learning rate of image backbone and context encoder is set to 1e-5. We initialized weights in the transformer encoder and decoder with Xavier initialization [14]. For image backbone, we experiment with the popular ResNet-50 and ResNet-101 networks [15] where weights are initialized from corresponding ImageNet-pretrained models. For the context encoder and phrase encoder, we use an uncased version of BERT model [8] with weights initialized from pretrained checkpoints provided by HuggingFace [49]. For data augmentation, we scale images such that the longest side is 640 pixels and follow [51] to do random intensity saturation and affine transforms. We remove the random horizontal flip augmentation used in previous work [51] since we notice it causes semantic ambiguity on RefCOCO, likely due to relative location (e.g., left of/right of) specific queries in the dataset. ",
+        "bbox": [
+            173,
+            438,
+            825,
+            577
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "On Flickr30k dataset, we set the maxium length of context sentence to 90 and maximum number of referring phrases to 16. On the ReferIt and the RefCOCO dataset, only phrase expressions are provided and the task aims to predict a single bounding box for each of the expressions. In those cases, the context sentence is taken as the referring phrase expression itself. We set the maximum length of context sentence on these two datasets to 40. To fairly compare with pretrained methods, we use region description split in the VisualGenome [25] to pretrain our model. The dataset contains approximately $1 0 0 \\mathrm { k }$ images and we remove the images that appear in Flickr30k Entities and RefCOCO/RefCOCOg/RefCOCO+’s validation and test set to avoid potential test data leak. For all the pretrained methods, we train the model on pretraining dataset for 6 epoches. We find that longer pretraining schedule gives better performance, but since the focus of this paper is not on pretraining methods, we stick to shorter pretraining schedules to save computational resources. All experiments are conducted using 4 Nvidia 2080TI GPU with batch size as 32. For all the results given, we run experiments several times with random seeds and the error bars are within $\\pm 0 . 5 \\%$ . ",
+        "bbox": [
+            174,
+            583,
+            825,
+            762
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.3 Quantitative Analysis ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            781,
+            362,
+            796
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Evaluation Metrics. For referring expression comprehension (REC), consistent with prior works, we use precision as the evaluation metric. We mark a referring detection as correct when the intersection-over-union (IoU) between the predicted bounding box and ground truth is larger than 0.5. For referring expression segmentation (RES), we reported the Mean IoU (MIoU) between the predicted segmentation mask and ground truth mask. ",
+        "bbox": [
+            174,
+            808,
+            825,
+            877
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "REC and RES on RefCOCO/RefCOCO $+$ /RefCOCOg. Our model addresses REC and RES tasks jointly. We compare their respective performances with the state-of-the-art in Table 1 and 2. ",
+        "bbox": [
+            173,
+            882,
+            820,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/7b6d9ab4f318c2df954e6974ae07467e62e3ebb51838ea47c231e15ae55d7e80.jpg",
+        "table_caption": [
+            "Table 2: Comparison on RES tasks. Performance on RefCOCO/RefCOCO $+$ /RefCOCOg datasets [55] is reported. Ours∗ denotes that pretraining is used. RN50 abd RN101 refer to ResNet50 and ResNet101 [15] respectively; DN53 refers to DarkNet53 [43] backbone. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Methods</td><td rowspan=\"2\">Backbone</td><td colspan=\"3\">RefCOCO</td><td colspan=\"3\">RefCOCO+</td><td colspan=\"2\">RefCOCOg</td><td rowspan=\"2\">Inference time(ms)</td></tr><tr><td>val</td><td>testA</td><td>testB</td><td>val</td><td>testA</td><td>testB</td><td>val</td><td>test</td></tr><tr><td>DMN [38]</td><td>RN101</td><td>49.78</td><td>54.83</td><td>45.13</td><td>38.88</td><td>44.22</td><td>32.29</td><td>-</td><td>-</td><td>-</td></tr><tr><td>MAttNet [56]</td><td>RN101</td><td>56.51</td><td>62.37</td><td>51.70</td><td>46.67</td><td>52.39</td><td>40.08</td><td>47.64</td><td>48.61</td><td>378</td></tr><tr><td>NMTree [29]</td><td>RN101</td><td>56.59</td><td>63.02</td><td>52.06</td><td>47.40</td><td>53.01</td><td>41.56</td><td>46.59</td><td>47.88</td><td>1</td></tr><tr><td>Lang2seg [6]</td><td>RN101</td><td>58.90</td><td>61.77</td><td>53.81</td><td>-</td><td>-</td><td>-</td><td>46.37</td><td>46.95</td><td></td></tr><tr><td>BCAM[20]</td><td>RN101</td><td>61.35</td><td>63.37</td><td>59.57</td><td>48.57</td><td>52.87</td><td>42.13</td><td>-</td><td>=</td><td></td></tr><tr><td>CMPC[21]</td><td>RN101</td><td>61.36</td><td>64.53</td><td>59.64</td><td>49.56</td><td>53.44</td><td>43.23</td><td>=</td><td>=</td><td>=</td></tr><tr><td>MCN+ASNLS [36]</td><td>DN53</td><td>62.44</td><td>64.20</td><td>59.71</td><td>50.62</td><td>54.99</td><td>44.69</td><td>49.22</td><td>49.40</td><td>56</td></tr><tr><td>CGAN [35]</td><td>DN53</td><td>64.86</td><td>68.04</td><td>62.07</td><td>51.03</td><td>55.51</td><td>44.06</td><td>51.01</td><td>51.69</td><td>-</td></tr><tr><td>LTS [22]</td><td>DN53</td><td>65.43</td><td>67.76</td><td>63.08</td><td>54.21</td><td>58.32</td><td>48.02</td><td>54.40</td><td>54.25</td><td>1</td></tr><tr><td>Ours</td><td>RN50</td><td>69.94</td><td>72.80</td><td>66.13</td><td>60.9</td><td>65.20</td><td>53.45</td><td>57.69</td><td>58.37</td><td>38</td></tr><tr><td>Ours</td><td>RN101</td><td>70.56</td><td>73.49</td><td>66.57</td><td>61.08</td><td>64.69</td><td>52.73</td><td>58.73</td><td>58.51</td><td>41</td></tr><tr><td>Ours*</td><td>RN50</td><td>73.61</td><td>75.22</td><td>69.80</td><td>65.30</td><td>69.69</td><td>56.98</td><td>65.70</td><td>65.41</td><td>38</td></tr><tr><td>Ours*</td><td>RN101</td><td>74.34</td><td>76.77</td><td>70.87</td><td>66.75</td><td>70.58</td><td>59.40</td><td>66.63</td><td>67.39</td><td>41</td></tr></table>",
+        "bbox": [
+            207,
+            137,
+            789,
+            295
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/ae52ea765ab73627d130406f12ccbc83f1847c53fe2d5875520aa3f4dee6d22d.jpg",
+        "image_caption": [
+            "Figure 2: Qualitative Evaluation. In (a) comparison to MCN [36] on REC is shown; orange, blue and red bounding boxes correspond to outputs from MCN, our model and the ground truth. In (b) similar comparison on RES is made. The attention map is drawn from the last layer of the decoder. We add mosaic to all human face to protect personal information. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            187,
+            323,
+            807,
+            585
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In Table 1, the model is first compared with previous one-stage and two-stage approaches for REC. Without bells and whistles, we observe a consistent performance boost of $+ 2 . 7 \\% / + 4 \\% / + 2 . 1 \\%$ on RefCOCO, $+ 6 . 6 \\% / + 4 . 3 \\% / + 8 . 5 \\%$ on $\\operatorname { R e f C O C O + }$ and $+ 4 . 4 \\% / + 5 . 1 \\%$ on RefCOCOg. To compare with pretrained BERT methods, we use the pretraining strategy discussed in Section 3.3. As results show, our model achieves comprehensive advantage and shows distinct improvement on some splits, even compared to advance BERT models that use $4 0 \\times$ more data in pretraining. Table 2 illustrates results on RES task in terms of MIoU score. It can be seen that our model achieves the best performance; substantially better than the state-of-art. We further observe that pretraining on the REC task gives a huge performance boost to the RES task, even when no segmentation mask is used in pre-training. Multi-task training enables the model to leverage performance boost in one task to improve the other. ",
+        "bbox": [
+            173,
+            683,
+            825,
+            835
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We show the inference time for our model in Table 2. Our model can directly decode all query phrases in an image in parallel, allowing it to reach real-time performance. Importantly, note the corresponding scores for our model in Table 1 and Table 2 are based on the output of a single multitask model that predicts referring detection box and segmentation mask simultaneously. The only related work that shares this property is the MCN [36], which has substantially inferior performance. ",
+        "bbox": [
+            174,
+            842,
+            825,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/2f7d735b2d283889a4ea7c36cfc744f5cda137142070389476e1db0424a715ec.jpg",
+        "table_caption": [
+            "Table 3: Comparison with State-of-The-Art Methods. Table illustrates performance on the test set of ReferItGame [24] and Flickr30K Entities [41] datasets in terms of top-1 accuracy $( \\% )$ . "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Models</td><td>Backbone</td><td>ReferItGame test</td><td>Flickr30K test</td><td>Inference time on Flickr30k(ms)</td></tr><tr><td colspan=\"5\">Two-stage</td></tr><tr><td>MAttNet [56]</td><td>RN101</td><td>29.04</td><td>-</td><td>320</td></tr><tr><td>Similarity Net [48]</td><td>RN101</td><td>34.54</td><td>60.89</td><td>184</td></tr><tr><td>CITE [42]</td><td>RN101</td><td>35.07</td><td>61.33</td><td>196</td></tr><tr><td>DDPN[57]</td><td>RN101</td><td>63.00</td><td>73.30</td><td>-</td></tr><tr><td colspan=\"5\">One-stage</td></tr><tr><td>SSG[4]</td><td>DN53</td><td>54.24</td><td>-</td><td>25</td></tr><tr><td>ZSGNet [46]</td><td>RN50</td><td>58.63</td><td>58.63</td><td>-</td></tr><tr><td>FAOA [51]</td><td>DN53</td><td>60.67</td><td>68.71</td><td>23</td></tr><tr><td>RCCF[26]</td><td>DLA34</td><td>63.79</td><td>-</td><td>25</td></tr><tr><td>ReSC-Large [52]</td><td>DN53</td><td>64.60</td><td>69.28</td><td>36</td></tr><tr><td>Ours</td><td>RN50</td><td>70.81</td><td>78.13</td><td>37(14)</td></tr><tr><td>Ours</td><td>RN101</td><td>71.42</td><td>78.66</td><td>40(15)</td></tr><tr><td>Ours*</td><td>RN50</td><td>75.49</td><td>79.46</td><td>37(14)</td></tr><tr><td>Ours*</td><td>RN101</td><td>76.18</td><td>81.18</td><td>40(15)</td></tr></table>",
+        "bbox": [
+            305,
+            123,
+            692,
+            291
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REC on Flickr30k-Entities. For Flickr30k dataset, previous one-stage works [51, 52] extract short phrases from sentences and treated them as separate referring expression comprehension tasks. We argue that in this setting, queries are mostly short phrases and therefore cannot well reflect the model’s ability to comprehend them in context. In contrast, our model, given an image and a caption (con)text sentence, aims to predict bounding boxes for all referred entities in the sentence. Doing so gives several advantages: 1. We are able to contextualize referring expressions given all other referring expressions and (con)text provided by the sentence. 2. Locations for all phrases can be inferred in one forward pass of the network, which saves a lot of computation as compared to previous one-stage approaches [51, 52] that process one phrase at a time. Note that our task formulation is consistent with some two-stage models [1, 9], but is unique for a one stage approach. ",
+        "bbox": [
+            173,
+            318,
+            825,
+            457
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In Table 3 we compare our results with state-of-the-art methods. Without pretraining, we obtain a huge performance boost compared to both previous one-stage $( + 1 3 . 5 4 \\% )$ and two-stage $( + 7 . 3 1 \\% )$ state-of-the art methods. By using pretrained models, we observe that our model tends to generalize better on the test set and gives even better performance. We also provide comparison of inference time both per image and (per-expression), since our model can amortize inference across expressions. Per-expression, our inference time is substantially lower than all prior methods. ",
+        "bbox": [
+            174,
+            463,
+            825,
+            546
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REC on ReferIt. Since ReferIt is a relative small dataset, we use a slightly smaller model which contains 3 cross attention layers in the query decoder. The results are shown in Table 3. Our model is able to perform better, by a large margin, than even the latest one-stage methods. We also observe a consistent boost brought by pretraining. ",
+        "bbox": [
+            174,
+            553,
+            825,
+            608
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.4 Qualitative Analysis ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            638,
+            352,
+            654
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In Figure 2, we show our qualitative comparison with previous state-of-the-art multi-task model – MCN [36]. The first two rows of Figure 2(a) show failure cases of MCN that can be better handled by our model. We observe that MCN appears to fail because it neglects some attributes in referring expression (e.g., \"yellow drink\" and \"blue striped shirt\"), while our model is able to better model the query and pay attention to object attributes. In the last row, we shows several failure cases of our model. For the first case, the query requires the model to have the ability to recognize number $\" 4 4 \"$ . For the second and third case, there is visual ambiguity to identify the nearest glass to the bowl or to determine which bear(brown or white) has the longest leg. ",
+        "bbox": [
+            173,
+            669,
+            826,
+            781
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In Figure 2(b), we show qualitative comparison in terms of referred segmentation mask. Compared to MCN, our model is able to output more detailed object shape and finer outlines. Moreover, our model shows the ability to handle shadows (e.g., the right bottom of the donut) and occlusions (e.g., the man occluded by another man’s arm) and predict smoother segmentation mask. We also give a result on a challenging case in the last row, where the texture boundary of the two giraffe is hard to distinguish. Despite imperfections, our model is still able to focus on the giraffe’s head in the foreground and performs much better than MCN. Part of our model’s ability to generate fine-grained mask can be explained by better localization ability brought by the REC task, in which case the RES head can focus on tuning the shape and boundary of the mask. ",
+        "bbox": [
+            174,
+            786,
+            825,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/62b5dbc5a955b227a6187f9be9633628854e5042bfc8f0b7374e39cf046f79d9.jpg",
+        "table_caption": [
+            "Table 4: Ablation studies. Table on the top ablates our multi-task and pretraining schehme on $\\operatorname { R e f C O C O } / + / \\mathrm { g }$ validation set. Table on the bottom ablates on core components of our model. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>REC</td><td>RES Pretrain</td><td>REC Acc↑</td><td>RESMiou↑</td><td>IE</td></tr><tr><td>√</td><td>√</td><td>81.08 /70.02/68.15</td><td>66.03/58.39/54.61 =</td><td>23.52%</td></tr><tr><td>√</td><td>√</td><td>81.82 / 71.13 /69.32</td><td>69.94 / 60.90 / 57.69</td><td>4.73%</td></tr><tr><td>√</td><td>√</td><td>85.01/75.46/77.96</td><td>=</td><td></td></tr><tr><td>√</td><td>√ √</td><td>85.43 / 76.40 / 78.43</td><td>73.61 / 65.30 / 65.70</td><td>4.48%</td></tr></table>",
+        "bbox": [
+            272,
+            123,
+            725,
+            194
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/e38a4a08de5d04aa5bdeaeb4f9cfc37b461ee0174c095a29856c670714270bce.jpg",
+        "table_caption": [
+            "Table 5: Results on RefCOCO $^ +$ Dataset with Different Input Resolutions. Our methods correspond to the RN50 model without pretraining. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>Flickr30k</td></tr><tr><td rowspan=1 colspan=1>Model component-w/o Query Decoder-w/o Context Encoder</td><td rowspan=1 colspan=1>49.3873.68</td></tr><tr><td rowspan=1 colspan=1>Query Encoder-w/o Context&amp;Phrase Feature-w/o Context Feature-w/o Phrase Feature</td><td rowspan=1 colspan=1>42.0576.6477.02</td></tr><tr><td rowspan=1 colspan=1>Full model</td><td rowspan=1 colspan=1>78.13</td></tr></table>",
+        "bbox": [
+            370,
+            198,
+            625,
+            304
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/0ef955392457586b7b877d1bc31b2791dfcab262386f5c6b8f7d22096d7eb881.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Models</td><td rowspan=\"2\">Resolution</td><td colspan=\"3\">REC(prec@0.5)</td><td colspan=\"3\">RES(MIoU)</td></tr><tr><td>val</td><td>testA</td><td>testB</td><td>val</td><td>testA</td><td>testB</td></tr><tr><td>FAOA [51]</td><td>256× 256</td><td>56.81</td><td>60.23</td><td>49.60</td><td>-</td><td>-</td><td>-</td></tr><tr><td>ReSC-Large [52]</td><td>256× 256</td><td>63.59</td><td>68.36</td><td>56.81</td><td>-</td><td>-</td><td>1</td></tr><tr><td>CMPC[21]</td><td>320×320</td><td>1</td><td>-</td><td>1</td><td>49.56</td><td>53.44</td><td>43.23</td></tr><tr><td>LTS [22]</td><td>416× 416</td><td>-</td><td>=</td><td>=</td><td>54.21</td><td>58.32</td><td>48.02</td></tr><tr><td>MCN [36]</td><td>416× 416</td><td>67.16</td><td>72.86</td><td>57.31</td><td>50.62</td><td>54.99</td><td>44.69</td></tr><tr><td>Ours</td><td>256× 256</td><td>70.05</td><td>73.29</td><td>61.48</td><td>58.26</td><td>61.09</td><td>52.20</td></tr><tr><td>Ours</td><td>320×320</td><td>70.03</td><td>73.23</td><td>61.52</td><td>58.42</td><td>61.48</td><td>52.34</td></tr><tr><td>Ours</td><td>416× 416</td><td>71.50</td><td>75.87</td><td>61.71</td><td>61.00</td><td>64.48</td><td>52.44</td></tr><tr><td>Ours</td><td>640× 640</td><td>71.58</td><td>75.96</td><td>62.16</td><td>61.08</td><td>64.69</td><td>52.73</td></tr></table>",
+        "bbox": [
+            254,
+            344,
+            738,
+            477
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.5 Ablation Studies ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            496,
+            328,
+            511
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We first consider the importance of the multi-task setup in Table 4 (top). Results indicate that multi-task training consistently boosts both REC and RES performance on Refcoco $/ + / \\mathrm { g }$ datasets by a considerable margin. More specifically, we observe that REC loss helps the transformer to better locate the referred object and converge faster in early stages of training. At the same time, RES loss aids the model with more fine-grained information on the shape of the referred region, which helps to further enhance the accuracy. IE here is Inconsistency Error metric originally used in [36] to measure the prediction conflict between the REC and RES task. We can see that joint training of RES and REC greatly reduce the inconsistency between the two tasks. Note that our model also has a much lower multi-task inconsistency compared to MCN [36], with a corresponding IE score of $7 . 5 4 \\% ( - 4 0 \\% )$ . This shows that our model can do better collaborative learning. ",
+        "bbox": [
+            174,
+            525,
+            825,
+            662
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Next, we validate the design of our network architecture. We report our scores on the Flickr30k test sets. In Table 4 (bottom), we ablate the model’s major components and features used to form the query. Without (w/o) context encoder indicates that we directly use learnable embedding to encode text; w/o Query Decoder means that we directly use the average pooled feature from the encoder to predict a single referred output. We can see that the context encoder plays an important role in providing good textual representation for further multi-modal fusion. Query encoders are also quite important without which we also observe a big performance drop. For the ablation on query features, we observe that both context feature and phrase features are crucial without which the performance will decrease considerably. The table also showed that the network will not work without guidance of both context and phrase features since we cannot establish a correspondence between multiple queries and outputs in such a case. ",
+        "bbox": [
+            173,
+            670,
+            825,
+            821
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In RES and REC tasks, the size of input image is a matter of trade off between performance and speed, which is largely effected by the network architecture. Despite that our model is designed to be able to process $6 4 0 \\times 6 4 0$ images at real time speed, we also test our model at different input resolution for reference, as showed in Table 5. Note that for resolution 256 and 320, we adjust strides in the final stage of ResNet to keep the number of visual features sent into visual-lingual encoder roughly the same. ",
+        "bbox": [
+            174,
+            828,
+            825,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/58ec28f4d7afef6e00fce8a5ad66983ca0d90677dabd3a4a9fc9cdfc16a77265.jpg",
+        "table_caption": [
+            "Table 6: Comparison with Concurrent Work. Performance on RefCOCO/RefCOCO $\\left| + \\right.$ /RefCOCOg datasets [55]. Ours∗ denotes that pretraining is used. All methods use ResNet101 image backbone. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Models</td><td rowspan=\"2\">Visual Features</td><td rowspan=\"2\">Pretrain Images</td><td rowspan=\"2\">Multi- task</td><td colspan=\"3\">RefCOCO</td><td colspan=\"3\">RefCOCO+</td><td rowspan=\"2\">RefC0COg</td></tr><tr><td>val</td><td>testA</td><td>testB</td><td>testA</td><td>testB</td><td>val-u</td></tr><tr><td>One-stage:</td><td></td><td></td><td></td><td></td><td></td><td></td><td>val</td><td></td><td></td><td></td><td>test-u</td></tr><tr><td>VGTR [10]</td><td>Bi-LSTM</td><td>None</td><td>×</td><td>79.20</td><td>82.32</td><td>73.78</td><td>63.91</td><td>70.09</td><td>56.51</td><td>65.73</td><td>67.23</td></tr><tr><td>TransVG [7]</td><td>BERT</td><td>None</td><td>×</td><td>81.02</td><td>82.72</td><td>78.35</td><td>64.82</td><td>70.70</td><td>56.94</td><td>68.67</td><td>67.73</td></tr><tr><td>Ours</td><td>BERT</td><td>None</td><td>√</td><td>82.23</td><td>85.59</td><td>76.57</td><td>71.58</td><td>75.96</td><td>62.16</td><td>69.41</td><td>69.40</td></tr><tr><td>Pretrained:</td><td></td><td></td><td>√</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>MDETR [23] Ours*</td><td>RoBERTa BERT</td><td>200k 100k</td><td>√</td><td>86.75 85.65</td><td>89.58 88.73</td><td>81.41 81.16</td><td>79.52 77.55</td><td>84.09 82.26</td><td>70.62 68.99</td><td>81.64 79.25</td><td>80.89 80.01</td></tr></table>",
+        "bbox": [
+            191,
+            125,
+            805,
+            227
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "4.6 Comparison with Contemporaneous Work ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            238,
+            508,
+            253
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Concurrent and independent to us, very recently, there are some closely related works that use transformers for visual referring tasks [7, 10, 23]. We will briefly discuss some of the differences. ",
+        "bbox": [
+            174,
+            263,
+            821,
+            292
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "To begin, [7, 10] focus on REC, while our approach is formulated in multi-task setting and solves both REC and RES tasks simultaneously. In addition, our model is faster and is capable of grounding multiple contextualized phrases, while [7, 10] follow previous one-stage approaches and are only able to infer a single expression at a time; leading, in our case, to more accurate results. MDETR [23] leverages contrastive loss and soft token loss to help better match bounding boxes to phrases. In contrast, our method adopts a simple and straightforward method to pre-match bounding boxes to phrases using a one-to-one matching; this leads to simpler learning objective. ",
+        "bbox": [
+            174,
+            297,
+            825,
+            396
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We provide quantitative comparison on REC task with these approaches, based on their reported numbers in Table 6. Compared to [7, 10], our model performs substantially better in all, with an exception of RefCOCO testB (where [7] is marginally better), datasets and splits. The biggest improvements can be seen on $\\operatorname { R e f C O C O + }$ , where our model is $1 0 . 4 \\%$ better (or 6.76 points better), than the closest concurrent work of [7], on the Val split; similar sizable improvements are illustrated on other splits, e.g., $9 . 2 \\%$ on $\\operatorname { R e f C O C O + }$ testB. In addition, our approach is considerably faster in runtime, since our model is able to handle multiple queries simultaneously (unlike [7, 10]). Compared to [23], in a pretrained model setting, we see that our model performs similarly on RefCOCO and marginally worse on $\\operatorname { R e f C O C O + }$ and $\\operatorname { R e f C O C O g }$ . This difference can perhaps be attributed to two factors: (1) larger pretrain dataset and longer triaining schedule. (As reported in [23], MDETR takes 224 GPU days to pretrain, while the pretraining for our model is roughly 28 GPU days) (2) using more sophisticated language model (RoBERTa for [23] vs. BERT for us). Limited experiments in Supplemental Material show that indeed, the use of RoBERTa leads to certain improvements. In addition, we setup our method in multi-task setting to solve RES and REC task at the same time, so our formulation while perhaps marginally inferior on REC is more general overall. ",
+        "bbox": [
+            174,
+            401,
+            825,
+            609
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 Conclusions and Future Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            622,
+            459,
+            638
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this work, we present Referring Transformer, a one-step approach to referring expression comprehension (REC) and segmentation (RES). We jointly train our model for RES and REC tasks while enabling contextualized multi-expression references. Our models outperform state-of-the-art by a large margin on five / three datasets for REC / RES respectively, while achieving real-time runtime. ",
+        "bbox": [
+            174,
+            646,
+            825,
+            702
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "One limitation for our model is that we follow the setup in previous works [51, 52] and assume that each expression refers to only one region. In the future, we plan to explore learning to predict multiple regions for each referring entity if necessary. Large-scale multi-task pretraining has been demonstrated to be very effective for ViLBEERT and other similar architectures; this is complementary to our focus in this paper, and we expect such strategies to further improve the performance. ",
+        "bbox": [
+            174,
+            708,
+            825,
+            779
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 Acknowledgments and Disclosure of Funding ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            796,
+            583,
+            814
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "This work was funded, in part, by the Vector Institute for AI, Canada CIFAR AI Chair, NSERC CRC, NSERC Discovery and Discovery Accelerator Grants. Resources used in preparing this research were provided, in part, by the Province of Ontario, the Government of Canada through CIFAR, and companies sponsoring the Vector Institute www.vectorinstitute.ai/#partners. Additional hardware support was provided by John R. Evans Leaders Fund CFI grant and Compute Canada under the Resource Allocation Competition award. ",
+        "bbox": [
+            174,
+            827,
+            825,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References   \n[1] M. Bajaj, L. Wang, and L. Sigal. G3raphground: Graph-based language grounding. In Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), pages 4281–4290, 2019.   \n[2] N. Carion, F. Massa, G. Synnaeve, N. Usunier, A. Kirillov, and S. Zagoruyko. End-to-end object detection with transformers. In European Conference on Computer Vision (ECCV), pages 213–229, 2020.   \n[3] K. Chen, R. Kovvuri, and R. Nevatia. Query-guided regression network with context policy for phrase grounding. In Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), pages 824–832, 2017.   \n[4] X. Chen, L. Ma, J. Chen, Z. Jie, W. Liu, and J. Luo. Real-time referring expression comprehension by single-stage grounding network. arXiv preprint arXiv:1812.03426, 2018.   \n[5] Y.-C. Chen, L. Li, L. Yu, A. El Kholy, F. Ahmed, Z. Gan, Y. Cheng, and J. Liu. Uniter: Universal image-text representation learning. In European Conference on Computer Vision (ECCV), pages 104–120, 2020.   \n[6] Y. W. Chen, Y. H. Tsai, T. Wang, Y. Y. Lin, and M. H. Yang. Referring expression object segmentation with caption-aware consistency. In Proceedings of the British Machine Vision Conference (BMVC), 2019.   \n[7] J. Deng, Z. Yang, T. Chen, W. Zhou, and H. Li. TransVG: End-to-end visual grounding with transformers. arXiv preprint arXiv:2104.08541, 2021.   \n[8] J. Devlin, M.-W. Chang, K. Lee, and K. 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.   \n[9] P. Dogan, L. Sigal, and M. Gross. Neural sequential phrase grounding (seqground). In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pages 4175–4184, 2019.   \n[10] Y. Du, Z. Fu, Q. Liu, and Y. Wang. Visual grounding with transformers. arXiv preprint arXiv:2105.04281, 2021.   \n[11] K. Duan, S. Bai, L. Xie, H. Qi, Q. Huang, and Q. Tian. Centernet: Keypoint triplets for object detection. In Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), pages 6569–6578, 2019.   \n[12] Z. Gan, Y.-C. Chen, L. Li, C. Zhu, Y. Cheng, and J. Liu. Large-scale adversarial training for vision-andlanguage representation learning. In Proceedings of the International Conference on Neural Information Processing Systems (NeurIPS), 2020.   \n[13] P. Gao, M. Zheng, X. Wang, J. Dai, and H. Li. Fast convergence of detr with spatially modulated co-attention. arXiv preprint arXiv:2101.07448, 2021.   \n[14] X. Glorot and Y. Bengio. Understanding the difficulty of training deep feedforward neural networks. In Proceedings of the Thirteenth International Conference on Artificial Intelligence and Statistics, pages 249–256, 2010.   \n[15] K. He, X. Zhang, S. Ren, and J. Sun. Deep residual learning for image recognition. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pages 770–778, 2016.   \n[16] K. He, G. Gkioxari, P. Dollár, and R. Girshick. Mask r-cnn. In Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), pages 2961–2969, 2017.   \n[17] R. Hong, D. Liu, X. Mo, X. He, and H. Zhang. Learning to compose and reason with language tree structures for visual grounding. IEEE Transactions on Pattern Analysis and Machine Intelligence (TPAMI), 2019.   \n[18] R. Hu, M. Rohrbach, and T. Darrell. Segmentation from natural language expressions. In European Conference on Computer Vision (ECCV), pages 108–124, 2016.   \n[19] R. Hu, M. Rohrbach, J. Andreas, T. Darrell, and K. Saenko. Modeling relationships in referential expressions with compositional modular networks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pages 1115–1124, 2017.   \n[20] Z. Hu, G. Feng, J. Sun, L. Zhang, and H. Lu. Bi-directional relationship inferring network for referring image segmentation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2020.   \n[21] S. Huang, T. Hui, S. Liu, G. Li, Y. Wei, J. Han, L. Liu, and B. Li. Referring image segmentation via cross-modal progressive comprehension. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2020.   \n[22] Y. Jing, T. Kong, W. Wang, L. Wang, L. Li, and T. Tan. Locate then segment: A strong pipeline for referring image segmentation. arXiv preprint arXiv:2103.16284, 2021.   \n[23] A. Kamath, M. Singh, Y. LeCun, I. Misra, G. Synnaeve, and N. Carion. MDETR–modulated detection for end-to-end multi-modal understanding. arXiv preprint arXiv:2104.12763, 2021.   \n[24] S. Kazemzadeh, V. Ordonez, M. Matten, and T. Berg. Referitgame: Referring to objects in photographs of natural scenes. In Proceedings of the Conference on Empirical Methods in Natural Language Processing (EMNLP), pages 787–798, 2014.   \n[25] R. Krishna, Y. Zhu, O. Groth, J. Johnson, K. Hata, J. Kravitz, S. Chen, Y. Kalantidis, L.-J. Li, D. A. Shamma, et al. Visual genome: Connecting language and vision using crowdsourced dense image annotations. International Journal of Computer Vision (IJCV), 123(1):32–73, 2017.   \n[26] Y. Liao, S. Liu, G. Li, F. Wang, Y. Chen, C. Qian, and B. Li. A real-time cross-modality correlation filtering method for referring expression comprehension. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2020.   \n[27] T.-Y. Lin, M. Maire, S. Belongie, J. Hays, P. Perona, D. Ramanan, P. Dollár, and C. L. Zitnick. Microsoft coco: Common objects in context. In European Conference on Computer Vision (ECCV), pages 740–755, 2014.   \n[28] T.-Y. Lin, P. Goyal, R. Girshick, K. He, and P. Dollár. Focal loss for dense object detection. In Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), pages 2980–2988, 2017.   \n[29] D. Liu, H. Zhang, F. Wu, and Z.-J. Zha. Learning to assemble neural module tree networks for visual grounding. In Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), pages 4673–4682, 2019.   \n[30] X. Liu, Z. Wang, J. Shao, X. Wang, and H. Li. Improving referring expression grounding with crossmodal attention-guided erasing. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pages 1950–1959, 2019.   \n[31] J. Long, E. Shelhamer, and T. Darrell. Fully convolutional networks for semantic segmentation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pages 3431– 3440, 2015.   \n[32] I. Loshchilov and F. Hutter. Decoupled weight decay regularization. In International Conference on Learning Representations (ICLR), 2019.   \n[33] J. Lu, D. Batra, D. Parikh, and S. Lee. ViLBERT: Pretraining task-agnostic visiolinguistic representations for vision-and-language tasks. In Proceedings of the International Conference on Neural Information Processing Systems (NeurIPS), pages 13–23, 2019.   \n[34] J. Lu, V. Goswami, M. Rohrbach, D. Parikh, and S. Lee. 12-in-1: Multi-task vision and language representation learning. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pages 10437–10446, 2020.   \n[35] G. Luo, Y. Zhou, R. Ji, X. Sun, J. Su, C.-W. Lin, and Q. Tian. Cascade grouped attention network for referring expression segmentation. In ACM International Conference on Multimedia, 2020.   \n[36] G. Luo, Y. Zhou, X. Sun, L. Cao, C. Wu, C. Deng, and R. Ji. Multi-task collaborative network for joint referring expression comprehension and segmentation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2020.   \n[37] J. Mao, J. Huang, A. Toshev, O. Camburu, A. L. Yuille, and K. Murphy. Generation and comprehension of unambiguous object descriptions. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pages 11–20, 2016.   \n[38] E. Margffoy-Tuay, J. C. Pérez, E. Botero, and P. Arbeláez. Dynamic multimodal instance segmentation guided by natural language queries. In European Conference on Computer Vision (ECCV), 2018.   \n[39] F. Milletari, N. Navab, and S.-A. Ahmadi. V-net: Fully convolutional neural networks for volumetric medical image segmentation. In International Conference on 3D Vision (3DV), pages 565–571, 2016.   \n[40] V. K. Nagaraja, V. I. Morariu, and L. S. Davis. Modeling context between objects for referring expression understanding. In European Conference on Computer Vision (ECCV), pages 792–807, 2016.   \n[41] B. A. Plummer, L. Wang, C. M. Cervantes, J. C. Caicedo, J. Hockenmaier, and S. Lazebnik. Flickr30k entities: Collecting region-to-phrase correspondences for richer image-to-sentence models. In Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), pages 2641–2649, 2015.   \n[42] B. A. Plummer, P. Kordas, M. H. Kiapour, S. Zheng, R. Piramuthu, and S. Lazebnik. Conditional image-text embedding networks. In European Conference on Computer Vision (ECCV), pages 249–264, 2018.   \n[43] J. Redmon and A. Farhadi. Yolov3: An incremental improvement. arXiv preprint arXiv:1804.02767, 2018.   \n[44] S. Ren, K. He, R. Girshick, and J. Sun. Faster r-cnn: Towards real-time object detection with region proposal networks. IEEE Transactions on Pattern Analysis and Machine Intelligence (TPAMI), 39(6): 1137–1149, 2017.   \n[45] H. Rezatofighi, N. Tsoi, J. Gwak, A. Sadeghian, I. Reid, and S. Savarese. Generalized intersection over union: A metric and a loss for bounding box regression. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pages 658–666, 2019.   \n[46] A. Sadhu, K. Chen, and R. Nevatia. Zero-shot grounding of objects from natural language queries. In Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), pages 4694–4703, 2019.   \n[47] H. Tan and M. Bansal. Lxmert: Learning cross-modality encoder representations from transformers. Proceedings of the Conference on Empirical Methods in Natural Language Processing (EMNLP), 2019.   \n[48] L. Wang, Y. Li, J. Huang, and S. Lazebnik. Learning two-branch neural networks for image-text matching tasks. IEEE Transactions on Pattern Analysis and Machine Intelligence (TPAMI), 41(2):394–407, 2018.   \n[49] T. Wolf, L. Debut, V. Sanh, J. Chaumond, C. Delangue, A. Moi, P. Cistac, T. Rault, R. Louf, M. Funtowicz, J. Davison, S. Shleifer, P. von Platen, C. Ma, Y. Jernite, J. Plu, C. Xu, T. L. Scao, S. Gugger, M. Drame, Q. Lhoest, and A. M. Rush. Transformers: State-of-the-art natural language processing. In Proceedings of the Conference on Empirical Methods in Natural Language Processing (EMNLP), pages 38–45, 2020.   \n[50] S. Yang, G. Li, and Y. Yu. Propagating over phrase relations for one-stage visual grounding. In European Conference on Computer Vision, pages 589–605. Springer, 2020.   \n[51] Z. Yang, B. Gong, L. Wang, W. Huang, D. Yu, and J. Luo. A fast and accurate one-stage approach to visual grounding. In Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), pages 4683–4693, 2019.   \n[52] Z. Yang, T. Chen, L. Wang, and J. Luo. Improving one-stage visual grounding by recursive sub-query construction. In European Conference on Computer Vision (ECCV), 2020.   \n[53] L. Ye, M. Rochan, Z. Liu, and Y. Wang. Cross-modal self-attention network for referring image segmentation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2019.   \n[54] F. Yu, J. Tang, W. Yin, Y. Sun, H. Tian, H. Wu, and H. Wang. Ernie-vil: Knowledge enhanced visionlanguage representations through scene graph. arXiv preprint arXiv:2006.16934, 2020.   \n[55] L. Yu, P. Poirson, S. Yang, A. C. Berg, and T. L. Berg. Modeling context in referring expressions. In European Conference on Computer Vision (ECCV), pages 69–85, 2016.   \n[56] L. Yu, Z. Lin, X. Shen, J. Yang, X. Lu, M. Bansal, and T. L. Berg. Mattnet: Modular attention network for referring expression comprehension. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pages 1307–1315, 2018.   \n[57] Z. Yu, J. Yu, C. Xiang, Z. Zhao, Q. Tian, and D. Tao. Rethinking diversified and discriminative proposal generation for visual grounding. International Joint Conference on Artificial Intelligence (IJCAI), 2018.   \n[58] X. Zhu, W. Su, L. Lu, B. Li, X. Wang, and J. Dai. Deformable detr: Deformable transformers for end-to-end object detection. In International Conference on Learning Representations (ICLR), 2021. ",
+        "bbox": [
+            171,
+            74,
+            828,
+            916
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            169,
+            69,
+            828,
+            920
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            56,
+            828,
+            857
+        ],
+        "page_idx": 12
+    }
+]

parse/train/SJlDDnVKwS/SJlDDnVKwS.md

@@ -0,0 +1,440 @@
+# IMPROVING EVOLUTIONARY STRATEGIES WITH GENERATIVE NEURAL NETWORKS
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Evolutionary Strategies (ES) are a popular family of black-box zeroth-order optimization algorithms which rely on search distributions to efficiently optimize a large variety of objective functions. This paper investigates the potential benefits of using highly flexible search distributions in ES algorithms, in contrast to standard ones (typically Gaussians). We model such distributions with Generative Neural Networks (GNNs) and introduce a new ES algorithm that leverages their expressiveness to accelerate the stochastic search. Because it acts as a plug-in, our approach allows to augment virtually any standard ES algorithm with flexible search distributions. We demonstrate the empirical advantages of this method on a diversity of objective functions.
+
+# 1 INTRODUCTION
+
+We are interested in the global minimization of a black-box objective function, only accessible through a zeroth-order oracle. In many instances of this problem the objective is expensive to evaluate, which excludes brute force methods as a reasonable mean of optimization. Also, as the objective is potentially non-convex and multi-modal, its global optimization cannot be done greedily but requires a careful balance between exploitation and exploration of the optimization landscape (the surface defined by the objective).
+
+The family of algorithms used to tackle such a problem is usually dictated by the cost of one evaluation of the objective function (or equivalently, by the maximum number of function evaluations that are reasonable to make) and by a precision requirement. For instance, Bayesian Optimization (Jones et al., 1998; Shahriari et al., 2016) targets problems of very high evaluation cost, where the global minimum must be approximately discovered after a few hundreds of function evaluations. When aiming for a higher precision and hence having a larger budget (e.g. thousands of function evaluations), a popular algorithm class is the one of Evolutionary Strategies (ES) (Rechenberg, 1978; Schwefel, 1977), a family of heuristic search procedures.
+
+ES algorithms rely on a search distribution, which role is to propose queries of potentially small value of the objective function. This search distribution is almost always chosen to be a multivariate Gaussian. It is namely the case of the Covariance Matrix Adaptation Evolution Strategies (CMA-ES) (Hansen & Ostermeier, 2001), a state-of-the-art ES algorithm made popular in the machine learning community by its good results on hyper-parameter tuning (Friedrichs & Igel, 2005; Loshchilov & Hutter, 2016). It is also the case for Natural Evolution Strategies (NES) (Wierstra et al., 2008) algorithms, which were recently used for direct policy search in Reinforcement Learning (RL) and shown to compete with state-of-the-art MDP-based RL techniques (Salimans et al., 2017). Occasionally, other distributions have been used; e.g. fat-tails distributions like the Cauchy were shown to outperform the Gaussian for highly multi-modal objectives (Schaul et al., 2011).
+
+We argue in this paper that in ES algorithms, the choice of a standard parametric search distribution (Gaussian, Cauchy, ..) constitutes a potentially harmful implicit constraint for the stochastic search of a global minimum. To overcome the limitations of classical parametric search distributions, we propose using flexible distributions generated by bijective Generative Neural Networks (GNNs), with computable and differentiable log-probabilities. We discuss why common existing optimization methods in ES algorithms cannot be directly used to train such models and design a tailored algorithm that efficiently train GNNs for an ES objective. We show how this new algorithm can readily incorporate existing ES algorithms that operates on simple search distributions,
+
+# Algorithm 1: Generic ES procedure
+
+input: zeroth-order oracle on $f$ , distribution $\pi _ { 0 }$ , population size $\lambda$ repeat
+
+(Sampling) Sample $x _ { 1 } , \dotsc , x _ { \lambda } \stackrel { \mathrm { i . i . d } } { \sim } \pi _ { t }$   
+(Evaluation) Evaluate $f ( x _ { 1 } ) , \ldots , f ( x _ { n } )$ .   
+(Update) Update $\pi _ { t }$ to produce $x$ of potentially smaller objective values. ntil convergence;
+
+like the Gaussian. On a variety of objective functions, we show that this extension can significantly accelerate ES algorithms.
+
+We formally introduce the problem and provide background on Evolutionary Strategies in Section 2. We discuss the role of GNNs in generating flexible search distributions in Section 3. We explain why usual algorithms fail to train GNNs for an ES objective and introduce a new algorithm in Section 4. Finally we report experimental results in Section 5.
+
+# 2 PRELIMINARIES
+
+In what follows, the real-valued objective function $f$ is defined over a compact $\mathcal { X }$ and $\pi$ will generically denote a probability density function over $\mathcal { X }$ . We consider the global optimization of $f$ :
+
+$$
+x ^ { * } \in \operatorname { a r g m i n } _ { x \in \mathcal { X } } f ( x )
+$$
+
+# 2.1 EVOLUTIONARY STRATEGIES
+
+The generic procedure followed by ES algorithms is presented in Algorithm 1. To make the update step tractable, the search distribution is tied to a family of distributions and parametrized by a realvalued parameter vector $\theta$ (e.g. the mean and covariance matrix of a Gaussian), and is referred to as $\pi _ { \theta }$ . This update step constitutes the main difference between ES algorithms.
+
+Natural Evolution Strategies One principled way to perform that update is to minimize the expected objective value over samples $x$ drawn from $\pi _ { \theta }$ . Indeed, when the search distribution is parametric and tied to a parameter $\theta$ , this objective can be differentiated with respect to $\theta$ thanks to the log-trick:
+
+$$
+J ( \theta ) \triangleq \mathbb { E } _ { \pi _ { \theta } } \left[ f ( x ) \right] \qquad { \mathrm { ~ a n d ~ } } \qquad { \frac { \partial J ( \theta ) } { \partial \theta } } = \mathbb { E } _ { \pi _ { \theta } } \left[ f ( x ) { \frac { \partial \log \pi _ { \theta } ( x ) } { \partial \theta } } \right]
+$$
+
+This quantity can be approximated from samples - it is known as the score-function or REINFORCE (Williams, 1992) estimator, and provides a direction of update for $\theta$ . Unfortunately, naively following a stochastic version of the gradient $( 2 ) - \mathtt { a }$ procedure called Plain Gradient Evolutionary Strategies (PGES) – is known to be highly ineffective. PGES main limitation resides in its instability when the search distribution is concentrating, making it unable to precisely locate any local minimum. To improve over the PGES algorithm the authors of Wierstra et al. (2008) proposed to descend $J ( \theta )$ along its natural gradient (Amari, 1998). More precisely, they introduce a trust-region optimization scheme to limit the instability of PGES, and minimize a linear approximation of $J ( \theta )$ under a Kullback-Leibler (KL) divergence constraint:
+
+$$
+\begin{array} { r l } { \underset { \delta \theta } { \operatorname { a r g m i n } } } & { { } J ( \theta + \delta \theta ) \simeq J ( \theta ) + \delta \theta ^ { T } \nabla _ { \theta } J ( \theta ) \quad \mathrm { s . t } \quad \mathrm { K L } ( \pi _ { \theta + \delta \theta } | | \pi _ { \theta } ) \leq \epsilon } \end{array}
+$$
+
+To avoid solving analytically the trust region problem (3), Wierstra et al. (2008) shows that its solution can be approximated by:
+
+$$
+\begin{array} { r } { \delta \theta ^ { * } \propto - F _ { \theta } ^ { - 1 } \nabla _ { \theta } J ( \theta ) \quad \mathrm { w h e r e } \quad F _ { \theta } = \mathbb { E } _ { \pi _ { \theta } } \left[ \nabla _ { \theta } \log \pi _ { \theta } ( x ) \nabla _ { \theta } \log \pi _ { \theta } ( x ) ^ { T } \right] } \end{array}
+$$
+
+is the Fischer Information Matrix (FIM) of $\pi _ { \theta }$ . The parameter $\theta$ is therefore not updated along the negative gradient of $J$ but rather along $F _ { \theta } ^ { - 1 } \nabla _ { \theta } J ( \theta )$ , a quantity known as the natural gradient. The FIM $F _ { \theta }$ is known analytically when $\pi _ { \theta }$ is a multivariate Gaussian and the resulting algorithm, Exponential Natural Evolutionary Strategies (xNES) (Glasmachers et al., 2010) has been shown to reach state-of-the-art performances on a large ES benchmark.
+
+![](images/4a34bd041023d6a274a1434d891b09ef4bfa2b2897ede2637a57dec5d6d07344.jpg)  
+Figure 2: Example of an undesirable behavior of a Gaussian search distribution. The dashed lines represent density level lines of the search distribution. Because the latter cannot have a curved profile, it is forced to drastically reduce its entropy until it reaches the straight part of the valley.
+
+CMA-ES Naturally, there exist other strategies to update the search distribution $\pi _ { \theta }$ . For instance, CMA-ES relies on a variety of heuristic mechanisms like covariance matrix adaptation and evolution paths, but is only defined when $\pi _ { \theta }$ is a multivariate Gaussian. Explaining such mechanisms would be out of the scope of this paper, but the interested reader is referred to the work of Hansen (2016) for a detailed tutorial on CMA-ES.
+
+# 2.2 LIMITATIONS OF CLASSICAL SEARCH DISTRIBUTIONS
+
+ES implicitly balance the need for exploration and exploitation of the optimization landscape. The exploitation phase consists in updating the search distribution, and exploration happens when samples are drawn from the search distribution’s tails. The key role of the search distribution is therefore to produce a support adapted to the landscape’s structure, so that new points are likely to improve over previous samples.
+
+We argue here that the choice of a given parametric distribution (the multivariate Gaussian distribution being overwhelmingly represented in state-of-the-art ES algorithms) constitutes a potentially harmful implicit constraint for the stochastic search of a global minimum. For instance, a Gaussian distribution is not adapted to navigate a curved valley because of its inability to continuously curve its density. This lack of flexibility will lead it to drastically reduce its entropy, until the curved valley looks locally straight. At this point, the ES algorithm resembles a hill-climber and barely takes advantage of the exploration abilities of the search distribution. An illustration of this phenomenon is presented in Figure 2 on the Rosenbrock function. Another limitation of classical search distribution is their inability to follow multiple hypothesis, that is to explore at the same time different local minima. Even if mixture models can show such flexibility, hyper-parameters like the number of mixtures have optimal values that are impossible to guess a priori.
+
+We want to introduce flexible search distributions to overcome these limitations. Such distributions should, despite their expressiveness, be easily trainable. We should also be concerned when designing them with their role in the exploration/exploitation trade off: a search distribution with too much capacity could over-fit some seemingly good samples, leading to premature convergence. To sum-up, we want to design search-distributions that are:
+
+• more flexible than classical distributions   
+• yet easily trainable   
+• while keeping control over the exploration / exploitation trade-off
+
+In the following section, we carefully investigate the class of Generative Neural Networks (GNNs) to find a parametric class of distributions satisfying such properties.
+
+# 3 FLEXIBLE SEARCH DISTRIBUTIONS WITH GNNS
+
+Generative Neural Networks (MacKay, 1995) have been studied in the context of density estimation and shown to be able to model complex and highly multimodal distributions (Srivastava et al., 2017). We propose here to leverage their expressiveness for ES, and train them in a principled way thanks to the ES objective:
+
+$$
+J ( \pi ) = \mathbb { E } _ { \pi } \left[ f ( x ) \right]
+$$
+
+As discussed in Section 2, optimizing $J ( \pi )$ with gradient-based methods is possible through the score-function estimator, which requires to be able to compute and efficiently differentiate the logprobabilities of $\pi$ .
+
+# 3.1 GNN BACKGROUND
+
+The core idea behind a GNN is to map a latent variable $z \in { \mathcal { Z } }$ drawn from a known distribution $\nu _ { \omega }$ to an output variable $x = g _ { \eta } ( z )$ where $g _ { \eta }$ is the forward-pass of a neural network. The parameter $\eta$ represents the weights of this neural network while $\omega$ describe the degrees of freedom of the latent space distribution $\nu _ { \omega }$ . We denote $\theta = ( \omega , \eta )$ and $\pi _ { \boldsymbol { \theta } } ( \boldsymbol { x } )$ the density of the output variable $x$ .
+
+For general neural network architectures, it is impossible to compute $\pi _ { \boldsymbol { \theta } } ( \boldsymbol { x } )$ for samples $x$ drawn from the GNN. This is namely why their are often trained with adversarial methods (Goodfellow et al., 2014) for sample generation purposes, bypassing the need of computing densities, but at the expense of a good density estimation (mode-dropping). An alternative to adversarial methods was proposed with variational auto-encoders (Kingma & Welling, 2013) however at the cost of learning two neural networks (an encoder and a decoder). A less computationally expensive method consists in restricting the possible architectures to build bijective GNNs, also known as Normalizing Flows (NF) (Rezende & Mohamed, 2015; Papamakarios et al., 2017), which allows the exact computation of the distribution’s density. Indeed, if $g _ { \eta }$ is a bijection from $\mathcal { Z }$ to $\mathcal { X }$ with inverse $h _ { \eta } \triangleq g _ { \eta } ^ { - 1 }$ , the change of variable formula provides a way to compute $\pi _ { \boldsymbol { \theta } } ( \boldsymbol { x } )$ :
+
+$$
+\pi _ { \boldsymbol { \theta } } ( x ) = \nu _ { \omega } ( h _ { \eta } ( x ) ) \cdot \left| \frac { \partial h _ { \eta } ( x ) } { \partial x } \right|
+$$
+
+To have a tractable density one therefore needs to ensure that the determinant of the Jacobian $| \partial h _ { \eta } ( x ) / \partial x |$ is easily computable. Several models satisfying these two properties $i . e$ bijectivity and computable Jacobian) have been proposed for density estimation (Rippel & Adams, 2013; Dinh et al., 2014; 2016), and proved their expressiveness despite their relatively simple structure.
+
+NFs therefore answer two of our needs when building our new search distribution: flexibility and easiness to train. In this work, we will focus on one NF model: the Non-Linear Independent Component Estimation (Dinh et al., 2014) (NICE) model, for its numerical stability and volume preserving properties.
+
+# 3.2 NICE MODEL
+
+The authors of NICE proposed to build complex yet invertible transformations through the use of additive coupling layers. An additive coupling layer leaves half of its input unchanged, and adds a non-linear transformation of the first half to the second half. More formally, by noting $\boldsymbol { v } = [ v _ { 1 } , v _ { 2 } ]$ the output of a coupling layer and $u = [ u _ { 1 } , u _ { 2 } ]$ its input, one has:
+
+$$
+v _ { 1 } = u _ { 1 } \quad \mathrm { a n d } \quad v _ { 2 } = u _ { 2 } + t ( u _ { 1 } )
+$$
+
+where $t$ is an arbitrarily complex transformation - modelled by a Multi-Layer Perceptron (MLP) with learnable weights and biases. This transformation has unit Jacobian determinant and is easily invertible:
+
+$$
+u _ { 1 } = v _ { 1 } \quad \mathrm { a n d } \quad u _ { 2 } = v _ { 2 } - t ( v _ { 1 } )
+$$
+
+and only requires a feed-forward pass on the MLP $t$ . The choice of the decomposition $u = [ u _ { 1 } , u _ { 2 } ]$ can be arbitrary, and is performed by applying a binary filter to the input. By stacking additive coupling layers, one can create complex distributions, and the inversion of the resulting mapping is independent of the complexity of the neural networks $t$ . The density of the resulting distribution is readily computable thanks to the inverse transform theorem (5).
+
+# 3.3 VOLUME PRESERVING PROPERTIES
+
+The transformation induced by NICE is volume preserving (it has a unitary Jacobian determinant). This is quite desirable in a ES context, as the role of concentrating the distribution on a minimum can be left to the latent space distribution $\nu _ { \omega }$ . The role of the additive coupling layers is therefore only to introduce non-linearities in the inverse transform $h _ { \eta }$ so that the distribution is better adapted to the optimization landscape. The fact that this fit is volume-preserving (every subset of the latent space has an image in the data space with the same probability mass) encourages the search distribution to align its tails with regions of small value of the optimization landscape, which is likely to improve the quality of future exploration steps. The NICE model therefore fits perfectly our needs for a flexible search distribution that is easy to train, and that provides enough control on the exploration / exploitation trade-off. Other bijective GNN models like the Real-NVP (Dinh et al., 2016) introduce non-volume preserving transformations, which cannot provide such a control. In practice, we observed that using such transformations for ES led to early concentration and premature convergence.
+
+# 4 AN EFFICIENT TRAINING ALGORITHM
+
+We are now equipped with enough tools to use GNNs for ES: an adapted model (NICE) for our search distribution $\pi _ { \theta }$ , and an objective to train it with:
+
+$$
+J ( \theta ) = \mathbb { E } _ { \pi _ { \theta } } \left[ f ( x ) \right]
+$$
+
+Here, $\theta$ describes jointly the free parameters of the latent distribution $\nu _ { \omega }$ and $\eta$ , the weights and biases of the MLPs forming the additive coupling layers.
+
+We start this section by explaining why existing training strategies based on the objective (8) are not sufficient to truly leverage the flexibility of GNNs for ES, before introducing a new algorithm tailored for this task.
+
+# 4.1 LIMITATIONS OF EXISTING TRAINING STRATEGIES
+
+We found that the PGES algorithm (naive stochastic gradient descent of (8) with the score-function estimator) applied to the NICE distribution suffers from the same limitations as when applied to the Gaussian; it is inable to precisely locate any local minimum. As for the Gaussian, training the NICE distribution for ES requires employing more sophisticated algorithms - such as NES.
+
+However, using the natural gradient for the GNNs distributions is not trivial. First the Fischer Information Matrix $F _ { \theta }$ is not known analytically and must be estimated via Monte-Carlo sampling, thereby introducing approximation errors. Also, we found that the approximations justifying to follow the descent direction provided by the natural gradient are not adapted to the NICE distribution. Indeed, the assumption behind the NES update (4) is that the loss $\bar { \boldsymbol { J } } ( \theta )$ can be (locally) well approximated by the quadratic objective:
+
+$$
+J ( \theta + \delta \theta ) = J ( \theta ) + \delta \theta ^ { T } \nabla _ { \theta } J ( \theta ) + \frac { \gamma } { 2 } \delta \theta ^ { T } F _ { \theta } \delta \theta
+$$
+
+where $\gamma$ is a given non-negative Lagrange multiplier. For NICE, given the highly non-linear nature of $\pi _ { \theta }$ this approximation is bound to fail even close to the current parameter $\theta$ and will lead to spurious updates. A classical technique (Martens, 2010) to avoid such updates is to artificially increase the curvature of the quadratic term, and is known as damping. Practically, this implies using $F _ { \theta } + \beta I$ instead of $F _ { \theta }$ as the local curvature metric, with $\beta$ a non-negative damping parameter.
+
+We found that to ensure continuous decrease of $J ( \theta )$ , and because of its highly non-linear nature when using the GNNs, the damping parameter $\beta$ has to be set to such high values that the modifications of the search distribution are too small to quickly make progress and by no means reaches state-of-the-art performances. We observed that even if the training of the additive coupling layers is performed correctly (i.e the distribution has the correct shape), high damping of the latent space parameters prevents the distribution from quickly concentrating when a minimum is found.
+
+It is unclear how the damping parameter should be adapted to avoid spurious update, while still allowing the distribution to make large step in the latent space and ensure fast concentration when needed. In the following, we present an alternated minimization scheme to bypass the issues raised by natural gradient training for GNN distributions in a ES context.
+
+# 4.2 ALTERNATING MINIMIZATION
+
+So far, we used the parameter $\theta$ to describe both $\omega$ and $\eta$ (respectively, the free parameters of the latent space distribution $\nu _ { \omega }$ and the degrees of freedom of the non-linear mapping $g _ { \eta , \ l }$ ), and the
+
+optimization over all these parameters was performed jointly. Separating the roles of $\omega$ and $\eta$ , the initial objective (2) can be rewritten as follows:
+
+$$
+J ( \theta ) = \mathbb { E } _ { z \sim \nu _ { \omega } } \left[ f ( g _ { \eta } ( z ) ) \right] = J ( \omega , \eta )
+$$
+
+Therefore, the initial objective can be rewritten as the expected value of samples drawn from the latent distribution, under the objective $f \circ g _ { \eta }$ - that is, the representation of the objective function $f$ in the latent space. If $\nu _ { \omega }$ is a standard distribution (i.e efficiently trainable with the natural gradient) and $f \circ g _ { \eta }$ is a well structured function (i.e one for which $\nu _ { \omega }$ is an efficient search distribution), then the single optimization of $\omega$ by classical methods (such as the natural gradient) should avoid the limitations discussed in 2.2. This new representation motivates the design of a new training algorithm that optimizes the parameters $\omega$ and $\eta$ separately.
+
+Alternating Minimization In the following, we will replace the notation $\pi _ { \theta }$ with $\pi _ { \omega , \eta }$ to refer to the NICE distribution with parameter $\theta = ( \omega , \eta )$ . We want to optimize $\omega$ and $\eta$ in an alternate fashion, which means performing the following updates at every step of the ES procedure:
+
+$$
+\begin{array} { l } { \omega _ { t + 1 } = \underset { \omega } { \operatorname { a r g m i n } } J ( \omega , \eta _ { t } ) } \\ { \eta _ { t + 1 } = \underset { \eta } { \operatorname { a r g m i n } } J ( \omega _ { t + 1 } , \eta ) } \end{array}
+$$
+
+This means that at iteration $t$ , samples are drawn from $\pi _ { \omega _ { t } , \eta _ { t } }$ and serve to first optimize the latent space distribution parameters $\omega$ , and then the additive coupling layers parameters $\eta$ . For the following iteration, the population is sampled under πωt+1,ηt+1 .
+
+The update (11a) of the latent space parameters is naturally derived from the new representation (10) of the initial objective. Indeed, $\omega$ can be updated via natural gradient ascent of $J ( \omega , \eta _ { t } )$ - that is with keeping $\eta = \eta _ { t }$ fixed. Practically, this therefore reduces to applying a NES algorithm to the latent distribution $\nu _ { \omega }$ on the modified objective function $f \circ g _ { \eta _ { t } }$ .
+
+Once the latent space parameters updated, the coupling layers parameters should be optimized with respect to:
+
+$$
+J ( \omega _ { t + 1 } , \eta ) = \mathbb { E } _ { \pi _ { \omega _ { t + 1 } , \eta } } \left[ f ( x ) \right]
+$$
+
+At this stage, the only available samples are drawn under $\pi _ { \omega _ { t } , \eta _ { t } }$ . To estimate, based on these samples, expectations under $\pi _ { \omega _ { t + 1 } , \eta _ { t } }$ one must use importance propensity scores:
+
+$$
+J ( \omega _ { t + 1 } , \eta ) = \mathbb { E } _ { \pi _ { \omega _ { t } , \eta _ { t } } } \left[ f ( x ) \frac { \pi _ { \omega _ { t + 1 } , \eta } ( x ) } { \pi _ { \omega _ { t } , \eta _ { t } } ( x ) } \right]
+$$
+
+The straightforward minimization of this off-line objective is known to lead to degeneracies (Swaminathan & Joachims, 2015, Section 4), and must therefore be regularized. For our application, it is also desirable to make sure that the update $\eta$ does not undo the progress made in the latent space - in other words, we want to regularize the change in $f \circ g _ { \eta }$ . To that extent, we adopt a technique proposed in Schulman et al. (2017) and minimize a modification on the initial objective with clipped propensity weights:
+
+$$
+\eta _ { t + 1 } = \underset { \eta } { \mathrm { a r g m i n } } \quad \mathbb { E } _ { \pi _ { \omega _ { t + 1 } } , \eta _ { t } } \left[ f ( x ) \mathrm { c l i p } _ { \varepsilon } \left( \frac { \pi _ { \omega _ { t + 1 } , \eta } ( x ) } { \pi _ { \omega _ { t + 1 } , \eta _ { t } } ( x ) } \right) \right]
+$$
+
+${ \mathrm { c l i p } } _ { \varepsilon } ( x )$ clips the value of $x$ between $1 - \epsilon$ and $1 + \epsilon$ . The parameter $\varepsilon$ is an hyper-parameter that controls the change in distribution, and the program (14) can be efficiently solved via a gradient descent type algorithm, such as Adam (Kingma & Ba, 2014).
+
+To sum up, we propose optimizing the latent distribution and the coupling layers separately. The latent space is optimized by natural gradient descent, and the coupling layers via an off-policy objective with clipped propensity weights. We call this algorithm GNN-ES for Generative Neural Networks Evolutionary Strategies.
+
+Latent space optimization It turns out the GNN-ES can be readily modified to incorporate virtually any existing ES algorithms that operates on the simple distribution $\nu _ { \omega }$ . For instance, if $\nu _ { \omega }$ is set to be a multivariate Gaussian with learnable mean and covariance matrix, the latent space optimization (11a) can be performed by either xNES or CMA-ES. This holds for any standard distribution $\nu _ { \omega }$ and any ES algorithm operating on that distribution. This remark allows us to place GNN-ES in a more general framework and to understand it as a way to improve existing ES algorithm, by providing a principled way to learn complex, non-linear transformations on top of rather standard search distributions (like the Gaussian). In what follows, we will use the GNN prefix in front of existing ES algorithm to describe its augmented version with our algorithm, working as a plug-in. Pseudo-code for this general algorithm can be found in Appendix B.
+
+# 4.3 ADDITIONAL TOOLS
+
+Using historic data ES algorithms typically use small populations of samples to estimate expectations. Such small sample sizes don’t allow for enough data exposure for the GNN to build a meaningful transformation $g _ { \eta }$ . To circumvent this problem, we augment the off-line program (14) with samples for past generations thanks to the fused importance sampling estimator (Peshkin & Shelton, 2002). This technique is classical in similar settings like MDP-based reinforcement learning and counterfactual reasoning (Nedelec et al., 2017; Agarwal et al., 2017) and proves to be essential for our problem. Formally, for a given horizon $T$ that controls how far we look in the past, this amounts to storing the samples $x$ drawn from $\pi _ { \theta _ { t - T + 1 } } , \ldots , \pi _ { \theta _ { t } }$ (as well as their respective scores) in a buffer $\mathcal { H } _ { T }$ . The objective (13) can then be rewritten as:
+
+$$
+\mathbb { E } _ { \pi _ { \omega _ { t } , \eta _ { t } } } \left[ f ( x ) \frac { \pi _ { \omega _ { t + 1 } , \eta } ( x ) } { \pi _ { \omega _ { t } , \eta _ { t } } ( x ) } \right] = T \cdot \mathbb { E } _ { x , f ( x ) \in \mathcal { H } _ { T } } \left[ f ( x ) \frac { \pi _ { \omega _ { t + 1 } , \eta } ( x ) } { \pi _ { \theta _ { t - T + 1 } } ( x ) + \dots + \pi _ { \theta _ { t } } ( x ) } \right]
+$$
+
+This technique allows to increase the data exposure of the GNN by using past samples (and therefore does not require additional function evaluations) and to reduce the variance of the off-line estimator of the original expectation (12) (Nedelec et al., 2017). To control the change in distribution, the fused propensity weights can then be clipped in a similar fashion than in the program (14).
+
+Mode preserving properties To achieve improved exploration, the search distribution should align its tails with the level sets of the objective function. This is not guaranteed when performing the update step (14) since the GNN’s update could simply move the mean of the search distribution without shaping the tails. One way to encourage the GNN’s capacity to be allocated to the tails is to impose a mode-preserving property. If $\mu$ denotes the location of a mode of the latent distribution, then the mode of the distribution $\pi _ { \theta }$ generated by the NICE model is located in $g _ { \eta } ( \mu )$ (see Appendix A for the proof). It is therefore easy to build a map $f _ { \eta }$ based on the initial $g _ { \eta }$ that is mode-preserving:
+
+$$
+f _ { \eta } ( z ) \triangleq g _ { \eta } ( z ) - g _ { \eta } ( \mu ) + f _ { \eta _ { t } } ( \mu )
+$$
+
+where $\mu _ { t }$ denotes the mode of the latent distribution $\nu _ { \omega }$ at iteration $t$ . Defined as such, $f _ { \eta }$ preserves the mode of the previous search distribution (since $f _ { \eta _ { t + 1 } } ( \mu ) = f _ { \eta _ { t } } ( \mu ) )$ , is trivially still a bijection and remains volume preserving. Using the push-forward map $f _ { \eta }$ instead of $g _ { \eta }$ , we explicitly push the flexibility brought by the GNN to impact only the tails of the search distribution. As detailed in an ablation study presented in Appendix F, this additional tool turns out to be essential in order to use GNNs for ES.
+
+# 5 EXPERIMENTAL RESULTS
+
+In all that follows, we build the NICE model with three coupling layers. Each coupling layer’s nonlinear mapping $t$ is built with a one hidden layer MLP, with 128 neurons and leaky ReLU (Maas et al., 2013) activation functions. This architecture is kept constant in all our experiments.
+
+# 5.1 VISUALIZATION
+
+We present here two-dimensional visualizations of the behavior of a GNN distribution trained with GNN-xNES - the latent distribution is therefore Gaussian. Figure 3a displays the density level lines
+
+![](images/73234a4420b6789f163034662822ec21c1faba1f0a0927942dab0d95c31b19fb.jpg)  
+Figure 3: Rosenbrock   
+Figure 4: Rastrigin
+
+Density level curves (dotted lines) in the data space and in the latent space of the resulting search distribution on the Rosenbrock function. Figure 3b displays the density level lines of the latent distribution, as well as the learned representation of the objective in the latent space. The search distribution is able to have curved density isolines, enabling better exploration. In the latent space, the global minimum can be reached without navigating a curved valley. Figures 4a and 4b provide similar visualizations on the Rastrigin function, a highly multimodal but symmetric objective. The GNN lowers the barriers between local minima, making it easier to escape a local minimum to the global minimum.
+
+# 5.2 SYNTHETIC OBJECTIVES
+
+Experimental set-up We present experiments on both unimodal and multimodal objectives for xNES and GNN-xNES. We use the official implementation of ${ \bf x } { \bf N } { \bf E } { \bf S } ^ { 1 }$ with default hyper-parameters (such as the population size $\lambda$ ), both as a baseline and as an inner optimization method for GNNxNES. All experiments are run on the COmparing Continous Optimizers (COCO) (Hansen et al., 2016) platform, a popular framework for comparing black-box optimization algorithms. It namely allows to benchmark different algorithms on translated and rotated versions of the same objectives, in order to evaluate multiple configurations with different global minimum positions. We compare xNES and GNN-xNES on functions from the 2018 Black-Box Optimization Benchmark (BBOB) (Hansen et al., 2010) suite. When comparing these two algorithms, we impose that their initial search distributions are close in order to ensure fair comparison. We insist on the fact that the xNES algorithm has the exact same configuration whether it is used by itself or as an inner-optimization algorithm for GNN-xNES. Further experimental details, including additional hyper-parameters value for GNN-xNES are provided in Appendix C.
+
+Unimodal landscapes We run the different algorithms on two unimodal landscapes where we expect GNN search distributions to bring a significant improvement over the Gaussian - as discussed in 2.2. These objectives functions are the Rotated Rosenbrock function (a curved valley with high conditioning) and the Bent Cigar (an asymmetric and curved Cigar function). Extensive details on these objective functions can be found in the BBOB documentation (Hansen et al., 2010). Results on additional unimodal functions can be found in Appendix E.
+
+Performance is measured through Empirical Cumulative Distribution Functions (ECDFs) of the runtime, also known as data profiles (More & Wild, 2009). Such curves report the fraction of problems ´ solved as a function of the number of objective evaluations. For a given precision $\Delta$ , a problem is said to be solved if the best function evaluation made so far is smaller than $f ( x ^ { * } ) + \Delta$ . We create 200 problems, equally spaced on a log-scale from $\Delta = 1 0 ^ { 2 }$ to $\Delta = 1 0 ^ { - 5 }$ and, as in the COCO framework, aggregate them over 15 function instances. Results are presented in Figure 5 for the two benchmark functions and in dimensions $d = 2 , 5 , 1 0$ .
+
+Multimodal landscapes We now compare the performances of the different algorithms on a collection of three multimodal objectives: the Rastrigin function, the Griewank-Rosenbrock function and the Schwefel function. Extensive details about these objectives can be found in Hansen et al. (2010).
+
+![](images/b10c47e6f87a4ca1484e4dbb8fb856ef523e7d90d0615d3965dadde266b9716d.jpg)  
+Figure 5: ECDFs curves comparing GNN-xNES and xNES on the Rotated Rosenbrock and Bent Cigar functions, in dimensions $d { = } 2 , 5 , 1 0$ .
+
+![](images/c5a2dc2c1f95397fa76ee16194d3cf2e62ba52dae3659fc6be5207f67bc1c1f3.jpg)  
+Figure 6: Scaling comparison of GNN-xNES and xNES on the Rastrigin, Griewank-Rosenbrock and Schwefel functions, $d { = } 2 , 5 , 1 0$ .
+
+When using ES algorithms to optimize multimodal functions, it is usual to augment them with restart strategies (Hansen, 2016). When convergence is detected, the search distribution is re-initialized in order to search another part of the landscape, and often the population size is increased. This allows to fairly compared algorithms that converge fast to potentially bad local minima, and algorithms that converges slower to better minima. Their exist a large variety of restart strategies (Loshchilov et al., 2012; Auger & Hansen, 2005); as the official implementation of xNES is not equipped with a default one, we trigger a restart whenever the algorithm makes no progress for more than $3 0 \times d$ iterations. The standard deviation of the search distribution is set back to 1, and its mean sampled uniformly within the compact $\mathcal { X }$ of interest (defined by the COCO framework). At each restart, the population size of the algorithm is multiplied by 2, as in Auger & Hansen (2005). This restart strategy is used for both xNES and GNN-xNES.
+
+We measure performance as the number of functions evaluations to find an objective value smaller than $f ( x ^ { * } ) \stackrel { * } { + } 1 0 ^ { - 5 }$ within a budget of $d \times 1 0 ^ { 5 }$ function evaluations, averaged over 15 function instances. When an algorithm is not able to discover the global minimum within the given budget, we use the maximum number of evaluations as its performance. For visualization purposes, this measure of performance is divided by $d ^ { 2 }$ . Results are reported in Figure 6. On all objectives, and for all dimensions, GNN-xNES discovers (in average) the global minimum faster than xNES. Additional results on others multimodal functions are presented in Appendix E.
+
+![](images/3f18464dcb8a92d8644bf09066084cf2ba259edb116ef3954c7026137fe015d3.jpg)  
+Figure 7: Direct Policy Search experiments
+
+# 5.3 REINFORCEMENT LEARNING EXPERIMENTS
+
+The goal of this section is to present additional comparison between xNES and GNN-xNES on RL-based objective functions - less synthetic than the previously considered BBOB functions. ES algorithms have recently been used for direct policy search in Reinforcement Learning (RL) and shown to reach performances comparable with state-of-the-art MDP-based techniques (Liu et al., 2019; Salimans et al., 2017). Direct Policy Search ignores the MDP structure of the RL environment and rather considers it as a black-box. The search for the optimal policy is performed directly in parameter space to maximize the average reward per trajectory:
+
+$$
+f ( \boldsymbol { x } ) = \mathbb { E } _ { \tau \sim p _ { \boldsymbol { x } } } \left[ \sum _ { j \in \tau } \boldsymbol { r } _ { j } \right]
+$$
+
+where $p _ { x }$ is the distribution of trajectories induced by the policy (the state-conditional distribution over actions) parametrized by $x$ , and $r$ the rewards generated by the environment. The objective (17) can readily be approximated from samples by simply rolling out $M$ trajectories, and optimized using ES. In our experiments2, we set $M = 1 0$ and optimize deterministic linear policies (as in Rajeswaran et al. (2017)).
+
+In Figures $\mathrm { 7 a }$ and 7b we report results of the GNN-xNES algorithm compared to xNES, when run on the Mujoco locomotion tasks Swimmer and InvertedDoublePendulum, both from the OpenAI Gym (Brockman et al., 2016). Performance is measured by the average reward per trajectory as a function of the number of evaluations of the objective $f$ . Results are averaged over 5 random seeds (ruling the initialization of the environment and the initial distribution over the policy parameters $x$ ). In all three environments, GNN-xNES discovers behaviors of high rewards faster than xNES.
+
+# 6 CONCLUSION
+
+In this work, we motivate the use of GNNs for improving Evolutionary Strategies by pinpointing the limitations of classical search distributions, commonly used by standard ES algorithms. We propose a new algorithm that leverages the high flexibility of distributions generated by bijective GNNs with an ES objective. We highlight that this algorithm can be seen as a plug-in extension to existing ES algorithms, and therefore can virtually incorporate any of them. Finally, we show its empirical advantages across a diversity of synthetic objective functions, as well as from objectives coming from Reinforcement Learning. Beyond the proposal of this algorithm, we believe that our work highlights the role of expressiveness in exploration for optimization tasks. This idea could be leverage in other settings where exploration is crucial, such a MDP-based policy search methods. An interesting line of future work could focus on optimizing GNN-based conditional distribution for RL tasks - an idea already developed in Ward et al. (2019); Mazoure et al. (2019). Other possible extensions to our work could focus on investigating first-order and mixed oracles, such as in Grathwohl et al. (2017); Faury et al. (2018).
+
+REFERENCES   
+Aman Agarwal, Soumya Basu, Tobias Schnabel, and Thorsten Joachims. Effective evaluation using logged bandit feedback from multiple loggers. In Proceedings of the 23rd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, pp. 687–696. ACM, 2017.   
+Shun-Ichi Amari. Natural gradient works efficiently in learning. Neural Computation, 10(2):251– 276, 1998.   
+Anne Auger and Nikolaus Hansen. A restart cma evolution strategy with increasing population size. In 2005 IEEE congress on evolutionary computation, volume 2, pp. 1769–1776. IEEE, 2005.   
+Greg Brockman, Vicki Cheung, Ludwig Pettersson, Jonas Schneider, John Schulman, Jie Tang, and Wojciech Zaremba. OpenAi Gym. arXiv preprint arXiv:1606.01540, 2016.   
+Laurent Dinh, David Krueger, and Yoshua Bengio. NICE: Non-Linear Independent Components Estimation. arXiv preprint arXiv:1410.8516, 2014.   
+Laurent Dinh, Jascha Sohl-Dickstein, and Samy Bengio. Density Estimation using Real NVP. arXiv preprint arXiv:1605.08803, 2016.   
+Yan Duan, Xi Chen, Rein Houthooft, John Schulman, and Pieter Abbeel. Benchmarking Deep Reinforcement Learning for Continuous Control. In International Conference on Machine Learning, pp. 1329–1338, 2016.   
+Louis Faury, Flavian Vasile, Clement Calauz ´ enes, and Oliver Fercoq. Neural Generative Models for \` Global Optimization with Gradients. arXiv preprint arXiv:1805.08594, 2018.   
+Frauke Friedrichs and Christian Igel. Evolutionary tuning of multiple SVM parameters. Neurocomputing, 64:107–117, 2005.   
+Tobias Glasmachers, Tom Schaul, Sun Yi, Daan Wierstra, and Jurgen Schmidhuber. Exponential ¨ natural evolution strategies. In Proceedings of the 12th annual conference on Genetic and evolutionary computation, pp. 393–400. ACM, 2010.   
+Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative Adversarial Nets. In Advances in Neural Information Processing Systems, pp. 2672–2680, 2014.   
+Will Grathwohl, Dami Choi, Yuhuai Wu, Geoff Roeder, and David Duvenaud. Backpropagation through the void: Optimizing control variates for black-box gradient estimation. arXiv preprint arXiv:1711.00123, 2017.   
+Nikolaus Hansen. The CMA Evolution Strategy: a tutorial. arXiv preprint arXiv:1604.00772, 2016.   
+Nikolaus Hansen and Andreas Ostermeier. Completely derandomized self-adaptation in Evolution Strategies. Evolutionary Computation, 9(2):159–195, 2001.   
+Nikolaus Hansen, Anne Auger, Steffen Finck, and Raymond Ros. Real-parameter black-box optimization benchmarking 2010: Experimental setup. PhD thesis, INRIA, 2010.   
+Nikolaus Hansen, Anne Auger, Olaf Mersmann, Tea Tusar, and Dimo Brockhoff. Coco: A platform for comparing continuous optimizers in a black-box setting. arXiv preprint arXiv:1603.08785, 2016.   
+Nikolaus Hansen, Youhei Akimoto, and Petr Baudis. CMA-ES/pycma on Github. Zenodo, DOI:10.5281/zenodo.2559634, February 2019. URL https://doi.org/10.5281/ zenodo.2559634.   
+Donald R Jones, Matthias Schonlau, and William J Welch. Efficient global optimization of expensive black-box functions. Journal of Global optimization, 13(4):455–492, 1998.   
+Diederik P Kingma and Jimmy Ba. Adam: A Method for Stochastic Optimization. arXiv preprint arXiv:1412.6980, 2014.   
+Diederik $\mathrm { \bf P }$ Kingma and Max Welling. Auto-encoding Variational Bayes. arXiv preprint arXiv:1312.6114, 2013.
+
+Guoqing Liu, Li Zhao, Feidiao Yang, Jiang Bian, Tao Qin, Nenghai Yu, and Tie-Yan Liu. Trust Region Evolution Strategies. Association for the Advancement of Artificial Intelligence, 2019.
+
+Ilya Loshchilov and Frank Hutter. CMA-ES for hyperparameter optimization of deep neural networks. arXiv preprint arXiv:1604.07269, 2016.
+
+Ilya Loshchilov, Marc Schoenauer, and Michele Sebag. Alternative restart strategies for cma-es. In International Conference on Parallel Problem Solving from Nature, pp. 296–305. Springer, 2012.
+
+Andrew L Maas, Awni Y Hannun, and Andrew Y Ng. Rectifier nonlinearities improve neural network acoustic models. In ICML Workshop on Deep Learning for Audio, Speech and Language Processing. Citeseer, 2013.
+
+David JC MacKay. Bayesian neural networks and density networks. Nuclear Instruments and Methods in Physics Research Section A: Accelerators, Spectrometers, Detectors and Associated Equipment, 354(1):73–80, 1995.
+
+James Martens. Deep Learning via Hessian-free Optimization. In International Conference of Machine Learning, volume 27, pp. 735–742, 2010.
+
+Bogdan Mazoure, Thang Doan, Audrey Durand, R Devon Hjelm, and Joelle Pineau. Leveraging exploration in off-policy algorithms via normalizing flows. arXiv preprint arXiv:1905.06893, 2019.
+
+Jorge J More and Stefan M Wild. Benchmarking derivative-free optimization algorithms. ´ SIAM Journal on Optimization, 20(1):172–191, 2009.
+
+Thomas Nedelec, Nicolas Le Roux, and Vianney Perchet. A Comparative Study of Counterfactual Estimators. arXiv preprint arXiv:1704.00773, 2017.
+
+George Papamakarios, Theo Pavlakou, and Iain Murray. Masked autoregressive flow for density estimation. In Advances in Neural Information Processing Systems, pp. 2338–2347, 2017.
+
+Leonid Peshkin and Christian R Shelton. Learning from scarce experience. In Proceedings of the Nineteenth International Conference on Machine Learning, pp. 498–505. Morgan Kaufmann Publishers Inc., 2002.
+
+Aravind Rajeswaran, Kendall Lowrey, Emanuel V Todorov, and Sham M Kakade. Towards generalization and simplicity in continuous control. In Advances in Neural Information Processing Systems, pp. 6550–6561, 2017.
+
+Ingo Rechenberg. Evolutionsstrategien. In Simulationsmethoden in der Medizin und Biologie, pp. 83–114. Springer, 1978.
+
+Danilo Rezende and Shakir Mohamed. Variational inference with normalizing flows. In International Conference on Machine Learning, pp. 1530–1538, 2015.
+
+Oren Rippel and Ryan Prescott Adams. High-dimensional Probability Estimation with Deep Density Models. arXiv preprint arXiv:1302.5125, 2013.
+
+Tim Salimans, Jonathan Ho, Xi Chen, Szymon Sidor, and Ilya Sutskever. Evolution Strategies as a scalable alternative to Reinforcement Learning. arXiv preprint arXiv:1703.03864, 2017.
+
+Tom Schaul, Justin Bayer, Daan Wierstra, Yi Sun, Martin Felder, Frank Sehnke, Thomas Ruckstieß, ¨ and Jurgen Schmidhuber. PyBrain. ¨ Journal of Machine Learning Research, 11:743–746, 2010.
+
+Tom Schaul, Tobias Glasmachers, and Jurgen Schmidhuber. High dimensions and heavy tails for ¨ Natural Evolution Strategies. In Proceedings of the 13th annual conference on Genetic and Evolutionary Computation, pp. 845–852. ACM, 2011.
+
+John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal Policy Optimization Algorithms. arXiv preprint arXiv:1707.06347, 2017.
+
+Hans-Paul Schwefel. Numerische Optimierung von Computer-Modellen mittels der Evolutionsstrategie: mit einer vergleichenden Einfuhrung in die Hill-Climbing-und Zufallsstrategie ¨ . Birkhauser, 1977. ¨
+
+Bobak Shahriari, Kevin Swersky, Ziyu Wang, Ryan P Adams, and Nando De Freitas. Taking the human out of the loop: A review of Bayesian Optimization. Proceedings of the IEEE, 104(1): 148–175, 2016.   
+Akash Srivastava, Lazar Valkoz, Chris Russell, Michael U Gutmann, and Charles Sutton. Veegan: Reducing mode collapse in GANs using Implicit Variational Learning. In Advances in Neural Information Processing Systems, pp. 3308–3318, 2017.   
+Adith Swaminathan and Thorsten Joachims. Counterfactual Risk Minimization: Learning from Logged Bandit Feedback. In International Conference on Machine Learning, pp. 814–823, 2015.   
+Patrick Nadeem Ward, Ariella Smofsky, and Avishek Joey Bose. Improving exploration in softactor-critic with normalizing flows policies. arXiv preprint arXiv:1906.02771, 2019.   
+Daan Wierstra, Tom Schaul, Jan Peters, and Juergen Schmidhuber. Natural Evolution Strategies. In Evolutionary omputation, 2008. CEC 2008.(IEEE World Congress on Computational Intelligence), pp. 3381–3387. IEEE, 2008.   
+Ronald J Williams. Simple statistical gradient-following algorithms for connectionist Reinforcement Learning. Machine Learning, 8(3-4):229–256, 1992.
+
+# A COMPUTING THE MODE OF THE SEARCH DISTRIBUTION
+
+We prove here the fact that if $\mu$ denotes the location of the mode of the latent distribution $\nu _ { \omega }$ , then $g _ { \eta } ( \mu )$ is a mode for $\pi _ { \omega , \eta }$ . Indeed, under reasonable smoothness assumptions, one has that $y$ is a mode for $\pi _ { \omega , \eta }$ if and only if:
+
+$$
+\frac { \partial \pi _ { \omega , \eta } ( x ) } { \partial x } \bigg | _ { x = y } = 0
+$$
+
+Since $\pi _ { \omega , \eta } ( x ) = \nu _ { \omega } ( h _ { \eta } ( x ) )$ , this is therefore equivalent to:
+
+$$
+\frac { \partial h _ { \eta } ( x ) } { \partial x } \bigg | _ { x = y } \cdot \frac { \partial \nu _ { \omega } ( z ) } { \partial z } \bigg | _ { z = h _ { \eta } ( y ) } = 0
+$$
+
+In the NICE model, we have that $\begin{array} { r } { \left| \frac { \partial h _ { \eta } ( x ) } { \partial x } \right| = 1 } \end{array}$ for all $x$ hence the matrix $\left. \frac { \partial h _ { \eta } ( x ) } { \partial x } \right| _ { x = y }$ is invertible and its kernel is reduced to the null vector. Therefore:
+
+$$
+\frac { \partial \nu _ { \omega } ( z ) } { \partial z } \bigg | _ { z = h _ { \eta } ( y ) } = 0
+$$
+
+and therefore $\mu = h _ { \eta } ( y )$ by definition of $\mu$ (the only critical point of $\nu _ { \omega }$ ). Hence since $h _ { \eta } ^ { - 1 } = g _ { \eta }$ , we have that $y = g _ { \eta } ( \mu )$ which concludes the proof.
+
+# B ALGORITHM PSEUDO-CODE
+
+We provide below the pseudo-code for the generic algorithm GNN- $\mathcal { A }$ -ES, where $\mathcal { A }$ is a generic ES algorithm operating on a parametric distribution $\nu _ { \omega }$ . The additional hyper-parameters are the horizon $T$ as well as the clipping constant $\varepsilon$ . The function ${ \mathrm { c l i p } } ( x , l b , u b )$ clips the input $x$ between a lower-bound $l b$ and an upper-bound $u b$ .
+
+Algorithm 2: GNN-A-ES (ex: GNN-xNES, GNN-CMA-ES)   
+
+<table><tr><td>inputs : objective function f,distribution Vω and its related ES algorithm A hyper-parameters: clipping constant ε, NICE model architecture, initial parameters Wo, initial weights no, horizon T, population size 入 (Initialization) Initialize NICE MLPs weights and biases with 7o. Let Hbe a circular buffer of length T × 入</td></tr></table>
+
+∗The (GNN iteration) step can be performed with virtually any gradient descent solver. In all our experiments, we used Adam (Kingma & Ba, 2014) with learning rate 1e-4 for 500 epochs.
+
+Algorithm 2 does not detail the mode-preserving addition for the sake of readability and clarity. We provide additional details on this procedure here. Let $\mu _ { t }$ be the mode of the latent distribution $\nu _ { \omega _ { t } }$ . At the (Initialization) step, set $\alpha _ { 0 } = g _ { \eta _ { 0 } } ( \mu _ { 0 } )$ where $g _ { \eta } ( \cdot )$ is the push-forward map on the NICE model described in Section 3.2. For all round $t \geq 1$ , let $\dot { f } _ { \eta } ( z ) = \bar { g } _ { \eta } ( z ) - g _ { \eta } ( \mu _ { t } ) \bar { + } \alpha _ { t }$ . The variable $\alpha _ { t }$ represent the push forward mapping of the latent distribution’s mean under the current model. Every time the latent space is updated - the $_ { E S }$ update) step, let $\alpha _ { t + 1 } = f _ { \eta _ { t } } ( \mu _ { t + 1 } )$ . Then, for the (GNN update), optimize the forward-map $f _ { \eta } ( z ) = g _ { \eta } ( z ) - g _ { \eta } ( \mu _ { t + 1 } ) + \alpha _ { t + 1 }$ . After this update, we have $\bar { f } _ { \eta _ { t + 1 } } ( \mu _ { t + 1 } ) = \alpha _ { t + 1 } = f _ { \eta _ { t } } ( \mu _ { t + 1 } ) \bar { { \bf \Phi } }$ , which means that the mode of the search distribution (which is the image of the latent distribution mode) has not been impacted by the GNN update.
+
+# C EXPERIMENTAL DETAILS
+
+# C.1 HYPER-PARAMETERS
+
+Baselines We use xNES with its default (adapted) hyper-parameters (described in Wierstra et al. (2008)) for both its baselines versions and its inner optimization parts in GNN-xNES. The population size $\lambda$ is one such hyper-parameters, and is therefore set to $\lambda = 4 + \lfloor 3 \log ( d ) \rfloor$ . Also, as it is classically done in ES algorithms, we use a rank-based fitness shaping, designed to make the algorithm invariant with respect to order-preserving cost transformations. We use the same fitnessshaping function as in Wierstra et al. (2008).
+
+GNN-ES Across all experiments, we use the same hyper-parameters for GNN-xNES without fine tuning for each tasks. We use three coupling layers, each with a single hidden layer MLP with 128 hidden neurons and Leaky ReLU activations. The MLPs are initialized via Glorot initialization, and the clipping constant is set to $\varepsilon = 0 . 0 5$ . The history size $T$ was determined experimentally, and set to $T = \bar { \lfloor 3 * ( 1 + \log ( d ) ) \rfloor }$ . When restarts are used, this history size is divided by the numbers of restart so far (as the population size grows larger).
+
+# C.2 SYNTHETIC OBJECTIVES
+
+Every synthetic objective we used in this work was taken from the BBOB2019 benchmark dataset. Their expression as well as additional details on the framework can be found in Hansen et al. (2010; 2016). At the beginning of each experiment, we set the Gaussian search distribution (for xNES) and the Gaussian latent distribution (for GNN-xNES) to a standard normal, with a mean uniformly sampled within the compact $\mathcal { X }$ of interest (defined by the COCO framework).
+
+# C.3 RL ENVIRONMENTS
+
+Table 1 provides details on the RL environment used to compare GNN-xNES and xNES, like the dimensions of the state space $s$ and action space $\mathcal { A }$ , the number $d$ of the policy’s degrees of freedom and the maximum number of steps $m$ per trajectory. At the beginning of each experiment, we set the Gaussian search distribution (for xNES) and the Gaussian latent distribution (for GNN-xNES) to a standard normal with zero mean. In this particular case, where the function evaluations are noisy, we kept the default population size of the xNES algorithm.
+
+Table 1: Reinforcement Learning environments   
+
+<table><tr><td>Name</td><td>|S|</td><td>|A|</td><td>d</td><td>m</td></tr><tr><td>Swimmer-v1</td><td>13</td><td>21</td><td>28</td><td>1000</td></tr><tr><td>InvertedDoublePendulum-v1</td><td>11</td><td></td><td>12</td><td>1000</td></tr><tr><td>HalfCheetah-v1</td><td>20</td><td>6</td><td>126</td><td>1000</td></tr></table>
+
+# D TWO-DIMENSIONAL VISUALIZATIONS
+
+We provide in Figure 8 additional two-dimensional visualizations of the behavior of GNN-xNES, on the Rosenbrock, Rastrigin, Beale and Bent-Cigar functions. We see that the NICE distributions can
+
+![](images/311d594c3ec6e8fb78527803e6d60d271d737b730c251be035e25006765a1219.jpg)  
+(d) (Doubly asymmetric) Bent Cigar, global optimum at $( 0 , 0 )$
+
+![](images/da2a20cb2e51968ad3673c4e04b747ac7345cc1e02f779521621aacac09f74da.jpg)  
+(a) Rosenbrock, global op- (b) Rastrigin, global opti- (c) Beale, global optimum timum at $( 1 , 1 )$ mum at $( 0 , 0 )$ at (3, 0.5)
+
+Figure 8: Two-dimensional visualizations. The black dotted lines represent the isolines of the level curves of a NICE search distribution trained with GNN-xNES.   
+
+<table><tr><td>Algorithm</td><td>mean(# restarts), d=2</td><td>mean(# restarts), d=5</td><td>mean(# restarts),d=10</td></tr><tr><td>xNES</td><td>2.3</td><td>2.7</td><td>3.4</td></tr><tr><td>GNN-xNES</td><td>1.3</td><td>2.5</td><td>2.9</td></tr></table>
+
+Table 2: Mean number of restarts needed to discover the global minimum on the Rastrigin function.
+
+efficiently fit each optimization landscapes, without having to reduce its entropy like a multivariate normal would.
+
+# E ADDITIONAL RESULTS
+
+We present here some additional results on some unimodal and multimodal synthetic functions. Figure 9 present ECDFs curve obtained from the Attractive Sector function, a highly asymmetrical function around its global minimum. On such a function, GNN-xNES seems to accelerate xNES in small dimensions, however this speed-up disappears in higher dimensions. Figure 10 presents results on the Rosenbrock function (without random rotations). Again, GNN-xNES accelerates the xNES algorithm. Figure 11 present results on the multimodal functions Gallagher’s Gaussian 101 Peaks and Gallagher’s Gaussian 21 Peaks. Again, GNN-xNES discovers the global minimum faster (on average) than xNES.
+
+In our multimodal experiments, we used simulated restarts as a fair mean of comparing different algorithm (this is common practice in order to fairly compare algorithms that converge fast to potentially bad local minima to algorithms that converge slowly to the global minimum). If the empirical results prove that GNN-xNES accelerate xNES in the discovery of the global minimum, it does not prove that GNN-xNES leverages the flexibility of the GNN to detect the global minimum when xNES misses it. In an attempt to prove that it is indeed the case, we report in Table 2 the number of restarts needed by both GNN-xNES and xNES to discover the global minimum on the Rastrigin function (averaged over the 15 randomly initialized run). For this instance, GNN-xNES consistently discovers the global minimum with less restarts than xNES.
+
+As detailed in Section 4, one can apply Algorithm 2 as a plug-in to any ES method. So far, we empirically evaluated the benefits of our approach by comparing xNES against its GNN extension (GNN-xNES). We present in Figure 12 additional evaluations obtained by comparing CMA-ES and its GNN extension (denoted GNN-CMA-ES) on the Rosenbrock function in dimension 2,5 and 10. CMA-ES is considered to be the state-of-the-art ES algorithm, and improving its performances is a non-trivial task. On the considered example GNN-CMA-ES improves CMA-ES, highlighting the empirical benefit of our approach for a large class of ES algorithm. One can however observe that the performance boost brought by the GNN extension is milder for GNN-CMA-ES then for GNNxNES. We suspect that this is due to the use of cumulation via an evolution path in ${ \mathrm { C M A } } – \mathbf { E S } ^ { 3 }$ , which basically introduces a momentum-like update when optimizing the latent distribution. While using an evolution path makes a lot of sense when optimizing a stationary objective, it can be quite harmful for non-stationary ones. We therefore believe that the cumulation step in CMA-ES (for the latent distribution) and the GNN optimization (making the objective optimized by CMA-ES in the latent space non-stationary) can lead to conflicting updates and might hinder the benefits brought by the GNN’s additional flexibility. Designing a GNN update strategy complying with the use of evolution paths could therefore be a way of further improving GNN-CMA-ES, and is left for future work.
+
+![](images/4780aff2f18f49f8bd5ac4ccf8d08c815faa7980e56dd2a9c4d6ffed6c3bb3dc.jpg)  
+Figure 9: ECDFs curve for the Attractive Sector function, $d { = } 2 , 5 , 1 0$
+
+![](images/15d5a43dad711006f45eb3c63a9311ee94135c357e7b775f9513f021c1f1efe7.jpg)  
+Figure 10: ECDFs curve for the Rosenbrock function, $\mathrm { d } { = } 2 , 5 { , } 1 0$
+
+# F ABLATION STUDY
+
+We present here an ablation study for two additional tools that we introduced after the alternating optimization view: the mode preserving (16) extension as well as the history augmentation (15). Figure 13 presents ECDFs curves on the Rosenbrock, Rotated Rosenbrock and Bent Cigar functions in 2D, for a version of GNN-xNES that doesn’t use history but only the current population. Using history and therefore exposing the GNN to larger datasets improves the procedure. Figure 14 present similar results on a version of GNN-xNES without the mode preserving property (16). Again, one can notice that ensuring that the GNN training is mode-preserving is crucial to improve experimental results.
+
+![](images/9e572d17a157ffd117415bd0f15a63c7cb309d9c5abf2d26176f23925a1ac64f.jpg)  
+Figure 11: Scaling comparison of GNN-xNES and xNES on the Gallagher’s Gaussian 101 Peaks and Gallagher’s Gaussian 21 Peaks functions, $d { = } 2 , 5 , 1 0$ .
+
+![](images/68ddd1cc5a7162a527451ccc1288b466f524bac93c83284b277804ec4d168823.jpg)  
+Figure 12: ECDFs curves for the Rosenbrock function, $\mathrm { ( d } { = } 2 , 5 , 1 0 \mathrm { ) }$ comparing the CMA-ES and GNN-CMA-ES
+
+![](images/ce5f379c22f570a949ae5a5c15dc76ba8c84c7e12ffc5755ca17c0d20d6b8274.jpg)  
+Figure 13: ECDFs curves for xNES, GNN-xNES and GNN-xNES-no-history, for which the history size $T = 1$ . Using past populations to estimate expectations improves the optimization.
+
+![](images/6c05e70bd63b61ad177ed55b672b85c9bdf4e56871bfb862f80ad4ae8ca57013.jpg)  
+Figure 14: ECDFs curves for xNES, GNN-xNES and GNN-xNES-nmp, which is not mode preserving. Ensuring that the training of the GNN doesn’t impact the mode of the search distribution improves the optimization.

parse/train/SJlDDnVKwS/SJlDDnVKwS_content_list.json

@@ -0,0 +1,2099 @@
+[
+    {
+        "type": "text",
+        "text": "IMPROVING EVOLUTIONARY STRATEGIES WITH GENERATIVE NEURAL NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            821,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            171,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            236,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Evolutionary Strategies (ES) are a popular family of black-box zeroth-order optimization algorithms which rely on search distributions to efficiently optimize a large variety of objective functions. This paper investigates the potential benefits of using highly flexible search distributions in ES algorithms, in contrast to standard ones (typically Gaussians). We model such distributions with Generative Neural Networks (GNNs) and introduce a new ES algorithm that leverages their expressiveness to accelerate the stochastic search. Because it acts as a plug-in, our approach allows to augment virtually any standard ES algorithm with flexible search distributions. We demonstrate the empirical advantages of this method on a diversity of objective functions. ",
+        "bbox": [
+            233,
+            263,
+            764,
+            404
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            426,
+            336,
+            443
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We are interested in the global minimization of a black-box objective function, only accessible through a zeroth-order oracle. In many instances of this problem the objective is expensive to evaluate, which excludes brute force methods as a reasonable mean of optimization. Also, as the objective is potentially non-convex and multi-modal, its global optimization cannot be done greedily but requires a careful balance between exploitation and exploration of the optimization landscape (the surface defined by the objective). ",
+        "bbox": [
+            174,
+            457,
+            823,
+            541
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The family of algorithms used to tackle such a problem is usually dictated by the cost of one evaluation of the objective function (or equivalently, by the maximum number of function evaluations that are reasonable to make) and by a precision requirement. For instance, Bayesian Optimization (Jones et al., 1998; Shahriari et al., 2016) targets problems of very high evaluation cost, where the global minimum must be approximately discovered after a few hundreds of function evaluations. When aiming for a higher precision and hence having a larger budget (e.g. thousands of function evaluations), a popular algorithm class is the one of Evolutionary Strategies (ES) (Rechenberg, 1978; Schwefel, 1977), a family of heuristic search procedures. ",
+        "bbox": [
+            174,
+            547,
+            825,
+            659
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ES algorithms rely on a search distribution, which role is to propose queries of potentially small value of the objective function. This search distribution is almost always chosen to be a multivariate Gaussian. It is namely the case of the Covariance Matrix Adaptation Evolution Strategies (CMA-ES) (Hansen & Ostermeier, 2001), a state-of-the-art ES algorithm made popular in the machine learning community by its good results on hyper-parameter tuning (Friedrichs & Igel, 2005; Loshchilov & Hutter, 2016). It is also the case for Natural Evolution Strategies (NES) (Wierstra et al., 2008) algorithms, which were recently used for direct policy search in Reinforcement Learning (RL) and shown to compete with state-of-the-art MDP-based RL techniques (Salimans et al., 2017). Occasionally, other distributions have been used; e.g. fat-tails distributions like the Cauchy were shown to outperform the Gaussian for highly multi-modal objectives (Schaul et al., 2011). ",
+        "bbox": [
+            174,
+            666,
+            825,
+            805
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We argue in this paper that in ES algorithms, the choice of a standard parametric search distribution (Gaussian, Cauchy, ..) constitutes a potentially harmful implicit constraint for the stochastic search of a global minimum. To overcome the limitations of classical parametric search distributions, we propose using flexible distributions generated by bijective Generative Neural Networks (GNNs), with computable and differentiable log-probabilities. We discuss why common existing optimization methods in ES algorithms cannot be directly used to train such models and design a tailored algorithm that efficiently train GNNs for an ES objective. We show how this new algorithm can readily incorporate existing ES algorithms that operates on simple search distributions, ",
+        "bbox": [
+            174,
+            811,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1: Generic ES procedure ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            107,
+            415,
+            122
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "input: zeroth-order oracle on $f$ , distribution $\\pi _ { 0 }$ , population size $\\lambda$ repeat ",
+        "bbox": [
+            173,
+            125,
+            609,
+            152
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "(Sampling) Sample $x _ { 1 } , \\dotsc , x _ { \\lambda } \\stackrel { \\mathrm { i . i . d } } { \\sim } \\pi _ { t }$   \n(Evaluation) Evaluate $f ( x _ { 1 } ) , \\ldots , f ( x _ { n } )$ .   \n(Update) Update $\\pi _ { t }$ to produce $x$ of potentially smaller objective values. ntil convergence; ",
+        "bbox": [
+            187,
+            154,
+            671,
+            213
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "like the Gaussian. On a variety of objective functions, we show that this extension can significantly accelerate ES algorithms. ",
+        "bbox": [
+            173,
+            243,
+            823,
+            272
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We formally introduce the problem and provide background on Evolutionary Strategies in Section 2. We discuss the role of GNNs in generating flexible search distributions in Section 3. We explain why usual algorithms fail to train GNNs for an ES objective and introduce a new algorithm in Section 4. Finally we report experimental results in Section 5. ",
+        "bbox": [
+            174,
+            279,
+            825,
+            335
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 PRELIMINARIES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            354,
+            339,
+            371
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In what follows, the real-valued objective function $f$ is defined over a compact $\\mathcal { X }$ and $\\pi$ will generically denote a probability density function over $\\mathcal { X }$ . We consider the global optimization of $f$ : ",
+        "bbox": [
+            173,
+            383,
+            821,
+            414
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/824182357f2acba869e9b3b0fad5dacbb4ab8a6fec4acc110a8df6d6b06809a2.jpg",
+        "text": "$$\nx ^ { * } \\in \\operatorname { a r g m i n } _ { x \\in \\mathcal { X } } f ( x )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            436,
+            416,
+            562,
+            441
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 EVOLUTIONARY STRATEGIES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            455,
+            418,
+            470
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The generic procedure followed by ES algorithms is presented in Algorithm 1. To make the update step tractable, the search distribution is tied to a family of distributions and parametrized by a realvalued parameter vector $\\theta$ (e.g. the mean and covariance matrix of a Gaussian), and is referred to as $\\pi _ { \\theta }$ . This update step constitutes the main difference between ES algorithms. ",
+        "bbox": [
+            173,
+            482,
+            825,
+            537
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Natural Evolution Strategies One principled way to perform that update is to minimize the expected objective value over samples $x$ drawn from $\\pi _ { \\theta }$ . Indeed, when the search distribution is parametric and tied to a parameter $\\theta$ , this objective can be differentiated with respect to $\\theta$ thanks to the log-trick: ",
+        "bbox": [
+            173,
+            553,
+            825,
+            608
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f9837d63d0a91cc2d318e10a059cb8c549cd62dd22e7277988ffe5a2e4ad98ed.jpg",
+        "text": "$$\nJ ( \\theta ) \\triangleq \\mathbb { E } _ { \\pi _ { \\theta } } \\left[ f ( x ) \\right] \\qquad { \\mathrm { ~ a n d ~ } } \\qquad { \\frac { \\partial J ( \\theta ) } { \\partial \\theta } } = \\mathbb { E } _ { \\pi _ { \\theta } } \\left[ f ( x ) { \\frac { \\partial \\log \\pi _ { \\theta } ( x ) } { \\partial \\theta } } \\right]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            269,
+            611,
+            727,
+            645
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "This quantity can be approximated from samples - it is known as the score-function or REINFORCE (Williams, 1992) estimator, and provides a direction of update for $\\theta$ . Unfortunately, naively following a stochastic version of the gradient $( 2 ) - \\mathtt { a }$ procedure called Plain Gradient Evolutionary Strategies (PGES) – is known to be highly ineffective. PGES main limitation resides in its instability when the search distribution is concentrating, making it unable to precisely locate any local minimum. To improve over the PGES algorithm the authors of Wierstra et al. (2008) proposed to descend $J ( \\theta )$ along its natural gradient (Amari, 1998). More precisely, they introduce a trust-region optimization scheme to limit the instability of PGES, and minimize a linear approximation of $J ( \\theta )$ under a Kullback-Leibler (KL) divergence constraint: ",
+        "bbox": [
+            173,
+            646,
+            825,
+            772
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b02cab4fb5c022c21926cb74919e7cf6122c85b25b79becf9ac72935bbeb1f9d.jpg",
+        "text": "$$\n\\begin{array} { r l } { \\underset { \\delta \\theta } { \\operatorname { a r g m i n } } } & { { } J ( \\theta + \\delta \\theta ) \\simeq J ( \\theta ) + \\delta \\theta ^ { T } \\nabla _ { \\theta } J ( \\theta ) \\quad \\mathrm { s . t } \\quad \\mathrm { K L } ( \\pi _ { \\theta + \\delta \\theta } | | \\pi _ { \\theta } ) \\leq \\epsilon } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            264,
+            773,
+            732,
+            801
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To avoid solving analytically the trust region problem (3), Wierstra et al. (2008) shows that its solution can be approximated by: ",
+        "bbox": [
+            178,
+            803,
+            825,
+            832
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7c43f84021de5e06124819a8b8fb9210dbf9208cd6b213c5cc7d67b73f85d62d.jpg",
+        "text": "$$\n\\begin{array} { r } { \\delta \\theta ^ { * } \\propto - F _ { \\theta } ^ { - 1 } \\nabla _ { \\theta } J ( \\theta ) \\quad \\mathrm { w h e r e } \\quad F _ { \\theta } = \\mathbb { E } _ { \\pi _ { \\theta } } \\left[ \\nabla _ { \\theta } \\log \\pi _ { \\theta } ( x ) \\nabla _ { \\theta } \\log \\pi _ { \\theta } ( x ) ^ { T } \\right] } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            258,
+            833,
+            738,
+            853
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "is the Fischer Information Matrix (FIM) of $\\pi _ { \\theta }$ . The parameter $\\theta$ is therefore not updated along the negative gradient of $J$ but rather along $F _ { \\theta } ^ { - 1 } \\nabla _ { \\theta } J ( \\theta )$ , a quantity known as the natural gradient. The FIM $F _ { \\theta }$ is known analytically when $\\pi _ { \\theta }$ is a multivariate Gaussian and the resulting algorithm, Exponential Natural Evolutionary Strategies (xNES) (Glasmachers et al., 2010) has been shown to reach state-of-the-art performances on a large ES benchmark. ",
+        "bbox": [
+            173,
+            854,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/4a34bd041023d6a274a1434d891b09ef4bfa2b2897ede2637a57dec5d6d07344.jpg",
+        "image_caption": [
+            "Figure 2: Example of an undesirable behavior of a Gaussian search distribution. The dashed lines represent density level lines of the search distribution. Because the latter cannot have a curved profile, it is forced to drastically reduce its entropy until it reaches the straight part of the valley. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            102,
+            802,
+            214
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "CMA-ES Naturally, there exist other strategies to update the search distribution $\\pi _ { \\theta }$ . For instance, CMA-ES relies on a variety of heuristic mechanisms like covariance matrix adaptation and evolution paths, but is only defined when $\\pi _ { \\theta }$ is a multivariate Gaussian. Explaining such mechanisms would be out of the scope of this paper, but the interested reader is referred to the work of Hansen (2016) for a detailed tutorial on CMA-ES. ",
+        "bbox": [
+            174,
+            295,
+            825,
+            364
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 LIMITATIONS OF CLASSICAL SEARCH DISTRIBUTIONS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            382,
+            584,
+            395
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "ES implicitly balance the need for exploration and exploitation of the optimization landscape. The exploitation phase consists in updating the search distribution, and exploration happens when samples are drawn from the search distribution’s tails. The key role of the search distribution is therefore to produce a support adapted to the landscape’s structure, so that new points are likely to improve over previous samples. ",
+        "bbox": [
+            174,
+            406,
+            825,
+            477
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We argue here that the choice of a given parametric distribution (the multivariate Gaussian distribution being overwhelmingly represented in state-of-the-art ES algorithms) constitutes a potentially harmful implicit constraint for the stochastic search of a global minimum. For instance, a Gaussian distribution is not adapted to navigate a curved valley because of its inability to continuously curve its density. This lack of flexibility will lead it to drastically reduce its entropy, until the curved valley looks locally straight. At this point, the ES algorithm resembles a hill-climber and barely takes advantage of the exploration abilities of the search distribution. An illustration of this phenomenon is presented in Figure 2 on the Rosenbrock function. Another limitation of classical search distribution is their inability to follow multiple hypothesis, that is to explore at the same time different local minima. Even if mixture models can show such flexibility, hyper-parameters like the number of mixtures have optimal values that are impossible to guess a priori. ",
+        "bbox": [
+            174,
+            483,
+            825,
+            637
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We want to introduce flexible search distributions to overcome these limitations. Such distributions should, despite their expressiveness, be easily trainable. We should also be concerned when designing them with their role in the exploration/exploitation trade off: a search distribution with too much capacity could over-fit some seemingly good samples, leading to premature convergence. To sum-up, we want to design search-distributions that are: ",
+        "bbox": [
+            174,
+            643,
+            823,
+            713
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "• more flexible than classical distributions   \n• yet easily trainable   \n• while keeping control over the exploration / exploitation trade-off ",
+        "bbox": [
+            215,
+            724,
+            663,
+            763
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In the following section, we carefully investigate the class of Generative Neural Networks (GNNs) to find a parametric class of distributions satisfying such properties. ",
+        "bbox": [
+            173,
+            775,
+            823,
+            803
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 FLEXIBLE SEARCH DISTRIBUTIONS WITH GNNS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            823,
+            607,
+            838
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Generative Neural Networks (MacKay, 1995) have been studied in the context of density estimation and shown to be able to model complex and highly multimodal distributions (Srivastava et al., 2017). We propose here to leverage their expressiveness for ES, and train them in a principled way thanks to the ES objective: ",
+        "bbox": [
+            174,
+            853,
+            825,
+            909
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7e5fd06f3309d842ca29b445163727d22b8bc8ca6216622977218ef1d1aee296.jpg",
+        "text": "$$\nJ ( \\pi ) = \\mathbb { E } _ { \\pi } \\left[ f ( x ) \\right]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            437,
+            907,
+            560,
+            925
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "As discussed in Section 2, optimizing $J ( \\pi )$ with gradient-based methods is possible through the score-function estimator, which requires to be able to compute and efficiently differentiate the logprobabilities of $\\pi$ . ",
+        "bbox": [
+            174,
+            103,
+            823,
+            145
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 GNN BACKGROUND ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            162,
+            354,
+            178
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The core idea behind a GNN is to map a latent variable $z \\in { \\mathcal { Z } }$ drawn from a known distribution $\\nu _ { \\omega }$ to an output variable $x = g _ { \\eta } ( z )$ where $g _ { \\eta }$ is the forward-pass of a neural network. The parameter $\\eta$ represents the weights of this neural network while $\\omega$ describe the degrees of freedom of the latent space distribution $\\nu _ { \\omega }$ . We denote $\\theta = ( \\omega , \\eta )$ and $\\pi _ { \\boldsymbol { \\theta } } ( \\boldsymbol { x } )$ the density of the output variable $x$ . ",
+        "bbox": [
+            174,
+            189,
+            823,
+            246
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For general neural network architectures, it is impossible to compute $\\pi _ { \\boldsymbol { \\theta } } ( \\boldsymbol { x } )$ for samples $x$ drawn from the GNN. This is namely why their are often trained with adversarial methods (Goodfellow et al., 2014) for sample generation purposes, bypassing the need of computing densities, but at the expense of a good density estimation (mode-dropping). An alternative to adversarial methods was proposed with variational auto-encoders (Kingma & Welling, 2013) however at the cost of learning two neural networks (an encoder and a decoder). A less computationally expensive method consists in restricting the possible architectures to build bijective GNNs, also known as Normalizing Flows (NF) (Rezende & Mohamed, 2015; Papamakarios et al., 2017), which allows the exact computation of the distribution’s density. Indeed, if $g _ { \\eta }$ is a bijection from $\\mathcal { Z }$ to $\\mathcal { X }$ with inverse $h _ { \\eta } \\triangleq g _ { \\eta } ^ { - 1 }$ , the change of variable formula provides a way to compute $\\pi _ { \\boldsymbol { \\theta } } ( \\boldsymbol { x } )$ : ",
+        "bbox": [
+            173,
+            252,
+            825,
+            395
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/abeeee5741be5bdc13b231dd8901c4de1a8e582d215616beb83c1ded0e15b5f5.jpg",
+        "text": "$$\n\\pi _ { \\boldsymbol { \\theta } } ( x ) = \\nu _ { \\omega } ( h _ { \\eta } ( x ) ) \\cdot \\left| \\frac { \\partial h _ { \\eta } ( x ) } { \\partial x } \\right|\n$$",
+        "text_format": "latex",
+        "bbox": [
+            393,
+            401,
+            604,
+            436
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To have a tractable density one therefore needs to ensure that the determinant of the Jacobian $| \\partial h _ { \\eta } ( x ) / \\partial x |$ is easily computable. Several models satisfying these two properties $i . e$ bijectivity and computable Jacobian) have been proposed for density estimation (Rippel & Adams, 2013; Dinh et al., 2014; 2016), and proved their expressiveness despite their relatively simple structure. ",
+        "bbox": [
+            174,
+            443,
+            825,
+            500
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "NFs therefore answer two of our needs when building our new search distribution: flexibility and easiness to train. In this work, we will focus on one NF model: the Non-Linear Independent Component Estimation (Dinh et al., 2014) (NICE) model, for its numerical stability and volume preserving properties. ",
+        "bbox": [
+            174,
+            506,
+            823,
+            561
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 NICE MODEL ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            579,
+            310,
+            593
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The authors of NICE proposed to build complex yet invertible transformations through the use of additive coupling layers. An additive coupling layer leaves half of its input unchanged, and adds a non-linear transformation of the first half to the second half. More formally, by noting $\\boldsymbol { v } = [ v _ { 1 } , v _ { 2 } ]$ the output of a coupling layer and $u = [ u _ { 1 } , u _ { 2 } ]$ its input, one has: ",
+        "bbox": [
+            174,
+            604,
+            825,
+            661
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2ed20fc116b40d84853d62f4e9c5bac1f994d5e4bbcd1f496eaf6cd3ea9fa762.jpg",
+        "text": "$$\nv _ { 1 } = u _ { 1 } \\quad \\mathrm { a n d } \\quad v _ { 2 } = u _ { 2 } + t ( u _ { 1 } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            387,
+            667,
+            611,
+            686
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $t$ is an arbitrarily complex transformation - modelled by a Multi-Layer Perceptron (MLP) with learnable weights and biases. This transformation has unit Jacobian determinant and is easily invertible: ",
+        "bbox": [
+            174,
+            693,
+            825,
+            734
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/674a318f173be90b63cae55d85e9f3096dc3c4c26ab8b0791ba33ee2eb34617e.jpg",
+        "text": "$$\nu _ { 1 } = v _ { 1 } \\quad \\mathrm { a n d } \\quad u _ { 2 } = v _ { 2 } - t ( v _ { 1 } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            388,
+            733,
+            609,
+            751
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "and only requires a feed-forward pass on the MLP $t$ . The choice of the decomposition $u = [ u _ { 1 } , u _ { 2 } ]$ can be arbitrary, and is performed by applying a binary filter to the input. By stacking additive coupling layers, one can create complex distributions, and the inversion of the resulting mapping is independent of the complexity of the neural networks $t$ . The density of the resulting distribution is readily computable thanks to the inverse transform theorem (5). ",
+        "bbox": [
+            174,
+            753,
+            823,
+            824
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.3 VOLUME PRESERVING PROPERTIES",
+        "text_level": 1,
+        "bbox": [
+            176,
+            842,
+            455,
+            856
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The transformation induced by NICE is volume preserving (it has a unitary Jacobian determinant). This is quite desirable in a ES context, as the role of concentrating the distribution on a minimum can be left to the latent space distribution $\\nu _ { \\omega }$ . The role of the additive coupling layers is therefore only to introduce non-linearities in the inverse transform $h _ { \\eta }$ so that the distribution is better adapted to the optimization landscape. The fact that this fit is volume-preserving (every subset of the latent space has an image in the data space with the same probability mass) encourages the search distribution to align its tails with regions of small value of the optimization landscape, which is likely to improve the quality of future exploration steps. The NICE model therefore fits perfectly our needs for a flexible search distribution that is easy to train, and that provides enough control on the exploration / exploitation trade-off. Other bijective GNN models like the Real-NVP (Dinh et al., 2016) introduce non-volume preserving transformations, which cannot provide such a control. In practice, we observed that using such transformations for ES led to early concentration and premature convergence. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            825,
+            229
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 AN EFFICIENT TRAINING ALGORITHM ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            250,
+            519,
+            265
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We are now equipped with enough tools to use GNNs for ES: an adapted model (NICE) for our search distribution $\\pi _ { \\theta }$ , and an objective to train it with: ",
+        "bbox": [
+            173,
+            279,
+            823,
+            306
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/acc0e4d3035f85f37af9edc31a40644238e7cab149c5789581fdcdc5a380dae0.jpg",
+        "text": "$$\nJ ( \\theta ) = \\mathbb { E } _ { \\pi _ { \\theta } } \\left[ f ( x ) \\right]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            436,
+            310,
+            562,
+            328
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Here, $\\theta$ describes jointly the free parameters of the latent distribution $\\nu _ { \\omega }$ and $\\eta$ , the weights and biases of the MLPs forming the additive coupling layers. ",
+        "bbox": [
+            173,
+            332,
+            823,
+            359
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We start this section by explaining why existing training strategies based on the objective (8) are not sufficient to truly leverage the flexibility of GNNs for ES, before introducing a new algorithm tailored for this task. ",
+        "bbox": [
+            174,
+            366,
+            825,
+            409
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 LIMITATIONS OF EXISTING TRAINING STRATEGIES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            425,
+            562,
+            439
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We found that the PGES algorithm (naive stochastic gradient descent of (8) with the score-function estimator) applied to the NICE distribution suffers from the same limitations as when applied to the Gaussian; it is inable to precisely locate any local minimum. As for the Gaussian, training the NICE distribution for ES requires employing more sophisticated algorithms - such as NES. ",
+        "bbox": [
+            173,
+            450,
+            825,
+            507
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "However, using the natural gradient for the GNNs distributions is not trivial. First the Fischer Information Matrix $F _ { \\theta }$ is not known analytically and must be estimated via Monte-Carlo sampling, thereby introducing approximation errors. Also, we found that the approximations justifying to follow the descent direction provided by the natural gradient are not adapted to the NICE distribution. Indeed, the assumption behind the NES update (4) is that the loss $\\bar { \\boldsymbol { J } } ( \\theta )$ can be (locally) well approximated by the quadratic objective: ",
+        "bbox": [
+            173,
+            513,
+            825,
+            597
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/84a9bcb1bd2938b7ee40528a5bde608db5859f2e8e173dd5f4d8775da7957fdf.jpg",
+        "text": "$$\nJ ( \\theta + \\delta \\theta ) = J ( \\theta ) + \\delta \\theta ^ { T } \\nabla _ { \\theta } J ( \\theta ) + \\frac { \\gamma } { 2 } \\delta \\theta ^ { T } F _ { \\theta } \\delta \\theta\n$$",
+        "text_format": "latex",
+        "bbox": [
+            341,
+            601,
+            658,
+            627
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\gamma$ is a given non-negative Lagrange multiplier. For NICE, given the highly non-linear nature of $\\pi _ { \\theta }$ this approximation is bound to fail even close to the current parameter $\\theta$ and will lead to spurious updates. A classical technique (Martens, 2010) to avoid such updates is to artificially increase the curvature of the quadratic term, and is known as damping. Practically, this implies using $F _ { \\theta } + \\beta I$ instead of $F _ { \\theta }$ as the local curvature metric, with $\\beta$ a non-negative damping parameter. ",
+        "bbox": [
+            174,
+            630,
+            825,
+            700
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We found that to ensure continuous decrease of $J ( \\theta )$ , and because of its highly non-linear nature when using the GNNs, the damping parameter $\\beta$ has to be set to such high values that the modifications of the search distribution are too small to quickly make progress and by no means reaches state-of-the-art performances. We observed that even if the training of the additive coupling layers is performed correctly (i.e the distribution has the correct shape), high damping of the latent space parameters prevents the distribution from quickly concentrating when a minimum is found. ",
+        "bbox": [
+            174,
+            705,
+            823,
+            790
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "It is unclear how the damping parameter should be adapted to avoid spurious update, while still allowing the distribution to make large step in the latent space and ensure fast concentration when needed. In the following, we present an alternated minimization scheme to bypass the issues raised by natural gradient training for GNN distributions in a ES context. ",
+        "bbox": [
+            174,
+            797,
+            825,
+            853
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.2 ALTERNATING MINIMIZATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            869,
+            421,
+            883
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "So far, we used the parameter $\\theta$ to describe both $\\omega$ and $\\eta$ (respectively, the free parameters of the latent space distribution $\\nu _ { \\omega }$ and the degrees of freedom of the non-linear mapping $g _ { \\eta , \\ l }$ ), and the ",
+        "bbox": [
+            176,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "optimization over all these parameters was performed jointly. Separating the roles of $\\omega$ and $\\eta$ , the initial objective (2) can be rewritten as follows: ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/71a1fe73425079bbb6e34cda1ae2decab6a6d51a49675e5305e08d7aa8c31584.jpg",
+        "text": "$$\nJ ( \\theta ) = \\mathbb { E } _ { z \\sim \\nu _ { \\omega } } \\left[ f ( g _ { \\eta } ( z ) ) \\right] = J ( \\omega , \\eta )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            377,
+            141,
+            620,
+            160
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Therefore, the initial objective can be rewritten as the expected value of samples drawn from the latent distribution, under the objective $f \\circ g _ { \\eta }$ - that is, the representation of the objective function $f$ in the latent space. If $\\nu _ { \\omega }$ is a standard distribution (i.e efficiently trainable with the natural gradient) and $f \\circ g _ { \\eta }$ is a well structured function (i.e one for which $\\nu _ { \\omega }$ is an efficient search distribution), then the single optimization of $\\omega$ by classical methods (such as the natural gradient) should avoid the limitations discussed in 2.2. This new representation motivates the design of a new training algorithm that optimizes the parameters $\\omega$ and $\\eta$ separately. ",
+        "bbox": [
+            173,
+            167,
+            825,
+            267
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Alternating Minimization In the following, we will replace the notation $\\pi _ { \\theta }$ with $\\pi _ { \\omega , \\eta }$ to refer to the NICE distribution with parameter $\\theta = ( \\omega , \\eta )$ . We want to optimize $\\omega$ and $\\eta$ in an alternate fashion, which means performing the following updates at every step of the ES procedure: ",
+        "bbox": [
+            174,
+            285,
+            825,
+            328
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/805c5bef08c9c60bfa1727fcabc3d38ad1785db617653f7e8d85c389ce1bb501.jpg",
+        "text": "$$\n\\begin{array} { l } { \\omega _ { t + 1 } = \\underset { \\omega } { \\operatorname { a r g m i n } } J ( \\omega , \\eta _ { t } ) } \\\\ { \\eta _ { t + 1 } = \\underset { \\eta } { \\operatorname { a r g m i n } } J ( \\omega _ { t + 1 } , \\eta ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            408,
+            337,
+            589,
+            391
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "This means that at iteration $t$ , samples are drawn from $\\pi _ { \\omega _ { t } , \\eta _ { t } }$ and serve to first optimize the latent space distribution parameters $\\omega$ , and then the additive coupling layers parameters $\\eta$ . For the following iteration, the population is sampled under πωt+1,ηt+1 . ",
+        "bbox": [
+            174,
+            407,
+            825,
+            452
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The update (11a) of the latent space parameters is naturally derived from the new representation (10) of the initial objective. Indeed, $\\omega$ can be updated via natural gradient ascent of $J ( \\omega , \\eta _ { t } )$ - that is with keeping $\\eta = \\eta _ { t }$ fixed. Practically, this therefore reduces to applying a NES algorithm to the latent distribution $\\nu _ { \\omega }$ on the modified objective function $f \\circ g _ { \\eta _ { t } }$ . ",
+        "bbox": [
+            174,
+            457,
+            825,
+            513
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Once the latent space parameters updated, the coupling layers parameters should be optimized with respect to: ",
+        "bbox": [
+            173,
+            518,
+            823,
+            547
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6ee1f3122aeab8b1135eb6277e09dca80341915130cc75ce72af8dcbd498bdf3.jpg",
+        "text": "$$\nJ ( \\omega _ { t + 1 } , \\eta ) = \\mathbb { E } _ { \\pi _ { \\omega _ { t + 1 } , \\eta } } \\left[ f ( x ) \\right]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            400,
+            558,
+            598,
+            578
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "At this stage, the only available samples are drawn under $\\pi _ { \\omega _ { t } , \\eta _ { t } }$ . To estimate, based on these samples, expectations under $\\pi _ { \\omega _ { t + 1 } , \\eta _ { t } }$ one must use importance propensity scores: ",
+        "bbox": [
+            174,
+            594,
+            825,
+            625
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b3df600c032dd501889546b46edfcf535bc8910f10cb77e37cbaa41d16c112dd.jpg",
+        "text": "$$\nJ ( \\omega _ { t + 1 } , \\eta ) = \\mathbb { E } _ { \\pi _ { \\omega _ { t } , \\eta _ { t } } } \\left[ f ( x ) \\frac { \\pi _ { \\omega _ { t + 1 } , \\eta } ( x ) } { \\pi _ { \\omega _ { t } , \\eta _ { t } } ( x ) } \\right]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            362,
+            635,
+            633,
+            670
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The straightforward minimization of this off-line objective is known to lead to degeneracies (Swaminathan & Joachims, 2015, Section 4), and must therefore be regularized. For our application, it is also desirable to make sure that the update $\\eta$ does not undo the progress made in the latent space - in other words, we want to regularize the change in $f \\circ g _ { \\eta }$ . To that extent, we adopt a technique proposed in Schulman et al. (2017) and minimize a modification on the initial objective with clipped propensity weights: ",
+        "bbox": [
+            173,
+            678,
+            825,
+            763
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9aa2b0918cecdcb933d25941d6acd337bf4206360a59e55db0dd0f1bad0aa689.jpg",
+        "text": "$$\n\\eta _ { t + 1 } = \\underset { \\eta } { \\mathrm { a r g m i n } } \\quad \\mathbb { E } _ { \\pi _ { \\omega _ { t + 1 } } , \\eta _ { t } } \\left[ f ( x ) \\mathrm { c l i p } _ { \\varepsilon } \\left( \\frac { \\pi _ { \\omega _ { t + 1 } , \\eta } ( x ) } { \\pi _ { \\omega _ { t + 1 } , \\eta _ { t } } ( x ) } \\right) \\right]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            303,
+            772,
+            676,
+            809
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "${ \\mathrm { c l i p } } _ { \\varepsilon } ( x )$ clips the value of $x$ between $1 - \\epsilon$ and $1 + \\epsilon$ . The parameter $\\varepsilon$ is an hyper-parameter that controls the change in distribution, and the program (14) can be efficiently solved via a gradient descent type algorithm, such as Adam (Kingma & Ba, 2014). ",
+        "bbox": [
+            174,
+            818,
+            825,
+            861
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To sum up, we propose optimizing the latent distribution and the coupling layers separately. The latent space is optimized by natural gradient descent, and the coupling layers via an off-policy objective with clipped propensity weights. We call this algorithm GNN-ES for Generative Neural Networks Evolutionary Strategies. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Latent space optimization It turns out the GNN-ES can be readily modified to incorporate virtually any existing ES algorithms that operates on the simple distribution $\\nu _ { \\omega }$ . For instance, if $\\nu _ { \\omega }$ is set to be a multivariate Gaussian with learnable mean and covariance matrix, the latent space optimization (11a) can be performed by either xNES or CMA-ES. This holds for any standard distribution $\\nu _ { \\omega }$ and any ES algorithm operating on that distribution. This remark allows us to place GNN-ES in a more general framework and to understand it as a way to improve existing ES algorithm, by providing a principled way to learn complex, non-linear transformations on top of rather standard search distributions (like the Gaussian). In what follows, we will use the GNN prefix in front of existing ES algorithm to describe its augmented version with our algorithm, working as a plug-in. Pseudo-code for this general algorithm can be found in Appendix B. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            243
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.3 ADDITIONAL TOOLS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            260,
+            356,
+            273
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Using historic data ES algorithms typically use small populations of samples to estimate expectations. Such small sample sizes don’t allow for enough data exposure for the GNN to build a meaningful transformation $g _ { \\eta }$ . To circumvent this problem, we augment the off-line program (14) with samples for past generations thanks to the fused importance sampling estimator (Peshkin & Shelton, 2002). This technique is classical in similar settings like MDP-based reinforcement learning and counterfactual reasoning (Nedelec et al., 2017; Agarwal et al., 2017) and proves to be essential for our problem. Formally, for a given horizon $T$ that controls how far we look in the past, this amounts to storing the samples $x$ drawn from $\\pi _ { \\theta _ { t - T + 1 } } , \\ldots , \\pi _ { \\theta _ { t } }$ (as well as their respective scores) in a buffer $\\mathcal { H } _ { T }$ . The objective (13) can then be rewritten as: ",
+        "bbox": [
+            173,
+            285,
+            825,
+            411
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/acff45464ba0ddd601df29dedca3931a94c54f8f0099d81a1fa8c4572970aca1.jpg",
+        "text": "$$\n\\mathbb { E } _ { \\pi _ { \\omega _ { t } , \\eta _ { t } } } \\left[ f ( x ) \\frac { \\pi _ { \\omega _ { t + 1 } , \\eta } ( x ) } { \\pi _ { \\omega _ { t } , \\eta _ { t } } ( x ) } \\right] = T \\cdot \\mathbb { E } _ { x , f ( x ) \\in \\mathcal { H } _ { T } } \\left[ f ( x ) \\frac { \\pi _ { \\omega _ { t + 1 } , \\eta } ( x ) } { \\pi _ { \\theta _ { t - T + 1 } } ( x ) + \\dots + \\pi _ { \\theta _ { t } } ( x ) } \\right]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            232,
+            417,
+            766,
+            453
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "This technique allows to increase the data exposure of the GNN by using past samples (and therefore does not require additional function evaluations) and to reduce the variance of the off-line estimator of the original expectation (12) (Nedelec et al., 2017). To control the change in distribution, the fused propensity weights can then be clipped in a similar fashion than in the program (14). ",
+        "bbox": [
+            174,
+            458,
+            823,
+            516
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Mode preserving properties To achieve improved exploration, the search distribution should align its tails with the level sets of the objective function. This is not guaranteed when performing the update step (14) since the GNN’s update could simply move the mean of the search distribution without shaping the tails. One way to encourage the GNN’s capacity to be allocated to the tails is to impose a mode-preserving property. If $\\mu$ denotes the location of a mode of the latent distribution, then the mode of the distribution $\\pi _ { \\theta }$ generated by the NICE model is located in $g _ { \\eta } ( \\mu )$ (see Appendix A for the proof). It is therefore easy to build a map $f _ { \\eta }$ based on the initial $g _ { \\eta }$ that is mode-preserving: ",
+        "bbox": [
+            173,
+            530,
+            825,
+            642
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/da4c51102ed3f49c6193d7f8d4565a6718342ad484683c41d42cc76bf29b080e.jpg",
+        "text": "$$\nf _ { \\eta } ( z ) \\triangleq g _ { \\eta } ( z ) - g _ { \\eta } ( \\mu ) + f _ { \\eta _ { t } } ( \\mu )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            388,
+            648,
+            609,
+            669
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "where $\\mu _ { t }$ denotes the mode of the latent distribution $\\nu _ { \\omega }$ at iteration $t$ . Defined as such, $f _ { \\eta }$ preserves the mode of the previous search distribution (since $f _ { \\eta _ { t + 1 } } ( \\mu ) = f _ { \\eta _ { t } } ( \\mu ) )$ , is trivially still a bijection and remains volume preserving. Using the push-forward map $f _ { \\eta }$ instead of $g _ { \\eta }$ , we explicitly push the flexibility brought by the GNN to impact only the tails of the search distribution. As detailed in an ablation study presented in Appendix F, this additional tool turns out to be essential in order to use GNNs for ES. ",
+        "bbox": [
+            174,
+            674,
+            825,
+            758
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5 EXPERIMENTAL RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            779,
+            415,
+            795
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In all that follows, we build the NICE model with three coupling layers. Each coupling layer’s nonlinear mapping $t$ is built with a one hidden layer MLP, with 128 neurons and leaky ReLU (Maas et al., 2013) activation functions. This architecture is kept constant in all our experiments. ",
+        "bbox": [
+            174,
+            809,
+            823,
+            852
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.1 VISUALIZATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            869,
+            326,
+            883
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We present here two-dimensional visualizations of the behavior of a GNN distribution trained with GNN-xNES - the latent distribution is therefore Gaussian. Figure 3a displays the density level lines ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/73234a4420b6789f163034662822ec21c1faba1f0a0927942dab0d95c31b19fb.jpg",
+        "image_caption": [
+            "Figure 3: Rosenbrock ",
+            "Figure 4: Rastrigin "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            103,
+            810,
+            213
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Density level curves (dotted lines) in the data space and in the latent space of the resulting search distribution on the Rosenbrock function. Figure 3b displays the density level lines of the latent distribution, as well as the learned representation of the objective in the latent space. The search distribution is able to have curved density isolines, enabling better exploration. In the latent space, the global minimum can be reached without navigating a curved valley. Figures 4a and 4b provide similar visualizations on the Rastrigin function, a highly multimodal but symmetric objective. The GNN lowers the barriers between local minima, making it easier to escape a local minimum to the global minimum. ",
+        "bbox": [
+            254,
+            251,
+            741,
+            265
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            294,
+            825,
+            392
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.2 SYNTHETIC OBJECTIVES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            411,
+            385,
+            425
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Experimental set-up We present experiments on both unimodal and multimodal objectives for xNES and GNN-xNES. We use the official implementation of ${ \\bf x } { \\bf N } { \\bf E } { \\bf S } ^ { 1 }$ with default hyper-parameters (such as the population size $\\lambda$ ), both as a baseline and as an inner optimization method for GNNxNES. All experiments are run on the COmparing Continous Optimizers (COCO) (Hansen et al., 2016) platform, a popular framework for comparing black-box optimization algorithms. It namely allows to benchmark different algorithms on translated and rotated versions of the same objectives, in order to evaluate multiple configurations with different global minimum positions. We compare xNES and GNN-xNES on functions from the 2018 Black-Box Optimization Benchmark (BBOB) (Hansen et al., 2010) suite. When comparing these two algorithms, we impose that their initial search distributions are close in order to ensure fair comparison. We insist on the fact that the xNES algorithm has the exact same configuration whether it is used by itself or as an inner-optimization algorithm for GNN-xNES. Further experimental details, including additional hyper-parameters value for GNN-xNES are provided in Appendix C. ",
+        "bbox": [
+            173,
+            438,
+            825,
+            617
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Unimodal landscapes We run the different algorithms on two unimodal landscapes where we expect GNN search distributions to bring a significant improvement over the Gaussian - as discussed in 2.2. These objectives functions are the Rotated Rosenbrock function (a curved valley with high conditioning) and the Bent Cigar (an asymmetric and curved Cigar function). Extensive details on these objective functions can be found in the BBOB documentation (Hansen et al., 2010). Results on additional unimodal functions can be found in Appendix E. ",
+        "bbox": [
+            174,
+            636,
+            825,
+            718
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Performance is measured through Empirical Cumulative Distribution Functions (ECDFs) of the runtime, also known as data profiles (More & Wild, 2009). Such curves report the fraction of problems ´ solved as a function of the number of objective evaluations. For a given precision $\\Delta$ , a problem is said to be solved if the best function evaluation made so far is smaller than $f ( x ^ { * } ) + \\Delta$ . We create 200 problems, equally spaced on a log-scale from $\\Delta = 1 0 ^ { 2 }$ to $\\Delta = 1 0 ^ { - 5 }$ and, as in the COCO framework, aggregate them over 15 function instances. Results are presented in Figure 5 for the two benchmark functions and in dimensions $d = 2 , 5 , 1 0$ . ",
+        "bbox": [
+            173,
+            726,
+            825,
+            824
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Multimodal landscapes We now compare the performances of the different algorithms on a collection of three multimodal objectives: the Rastrigin function, the Griewank-Rosenbrock function and the Schwefel function. Extensive details about these objectives can be found in Hansen et al. (2010). ",
+        "bbox": [
+            174,
+            842,
+            823,
+            896
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/b10c47e6f87a4ca1484e4dbb8fb856ef523e7d90d0615d3965dadde266b9716d.jpg",
+        "image_caption": [
+            "Figure 5: ECDFs curves comparing GNN-xNES and xNES on the Rotated Rosenbrock and Bent Cigar functions, in dimensions $d { = } 2 , 5 , 1 0$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            103,
+            820,
+            386
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/c5a2dc2c1f95397fa76ee16194d3cf2e62ba52dae3659fc6be5207f67bc1c1f3.jpg",
+        "image_caption": [
+            "Figure 6: Scaling comparison of GNN-xNES and xNES on the Rastrigin, Griewank-Rosenbrock and Schwefel functions, $d { = } 2 , 5 , 1 0$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            449,
+            823,
+            589
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "When using ES algorithms to optimize multimodal functions, it is usual to augment them with restart strategies (Hansen, 2016). When convergence is detected, the search distribution is re-initialized in order to search another part of the landscape, and often the population size is increased. This allows to fairly compared algorithms that converge fast to potentially bad local minima, and algorithms that converges slower to better minima. Their exist a large variety of restart strategies (Loshchilov et al., 2012; Auger & Hansen, 2005); as the official implementation of xNES is not equipped with a default one, we trigger a restart whenever the algorithm makes no progress for more than $3 0 \\times d$ iterations. The standard deviation of the search distribution is set back to 1, and its mean sampled uniformly within the compact $\\mathcal { X }$ of interest (defined by the COCO framework). At each restart, the population size of the algorithm is multiplied by 2, as in Auger & Hansen (2005). This restart strategy is used for both xNES and GNN-xNES. ",
+        "bbox": [
+            173,
+            665,
+            825,
+            819
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We measure performance as the number of functions evaluations to find an objective value smaller than $f ( x ^ { * } ) \\stackrel { * } { + } 1 0 ^ { - 5 }$ within a budget of $d \\times 1 0 ^ { 5 }$ function evaluations, averaged over 15 function instances. When an algorithm is not able to discover the global minimum within the given budget, we use the maximum number of evaluations as its performance. For visualization purposes, this measure of performance is divided by $d ^ { 2 }$ . Results are reported in Figure 6. On all objectives, and for all dimensions, GNN-xNES discovers (in average) the global minimum faster than xNES. Additional results on others multimodal functions are presented in Appendix E. ",
+        "bbox": [
+            174,
+            827,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/3f18464dcb8a92d8644bf09066084cf2ba259edb116ef3954c7026137fe015d3.jpg",
+        "image_caption": [
+            "Figure 7: Direct Policy Search experiments "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            103,
+            823,
+            251
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5.3 REINFORCEMENT LEARNING EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            306,
+            519,
+            320
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The goal of this section is to present additional comparison between xNES and GNN-xNES on RL-based objective functions - less synthetic than the previously considered BBOB functions. ES algorithms have recently been used for direct policy search in Reinforcement Learning (RL) and shown to reach performances comparable with state-of-the-art MDP-based techniques (Liu et al., 2019; Salimans et al., 2017). Direct Policy Search ignores the MDP structure of the RL environment and rather considers it as a black-box. The search for the optimal policy is performed directly in parameter space to maximize the average reward per trajectory: ",
+        "bbox": [
+            173,
+            333,
+            825,
+            431
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "equation",
+        "img_path": "images/33c5df91c10725a19f74849fd1fb770369c283df12f61a9ba55c8d67ae4e49fc.jpg",
+        "text": "$$\nf ( \\boldsymbol { x } ) = \\mathbb { E } _ { \\tau \\sim p _ { \\boldsymbol { x } } } \\left[ \\sum _ { j \\in \\tau } \\boldsymbol { r } _ { j } \\right]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            415,
+            439,
+            581,
+            491
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "where $p _ { x }$ is the distribution of trajectories induced by the policy (the state-conditional distribution over actions) parametrized by $x$ , and $r$ the rewards generated by the environment. The objective (17) can readily be approximated from samples by simply rolling out $M$ trajectories, and optimized using ES. In our experiments2, we set $M = 1 0$ and optimize deterministic linear policies (as in Rajeswaran et al. (2017)). ",
+        "bbox": [
+            173,
+            497,
+            825,
+            568
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In Figures $\\mathrm { 7 a }$ and 7b we report results of the GNN-xNES algorithm compared to xNES, when run on the Mujoco locomotion tasks Swimmer and InvertedDoublePendulum, both from the OpenAI Gym (Brockman et al., 2016). Performance is measured by the average reward per trajectory as a function of the number of evaluations of the objective $f$ . Results are averaged over 5 random seeds (ruling the initialization of the environment and the initial distribution over the policy parameters $x$ ). In all three environments, GNN-xNES discovers behaviors of high rewards faster than xNES. ",
+        "bbox": [
+            173,
+            574,
+            825,
+            659
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            681,
+            318,
+            696
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this work, we motivate the use of GNNs for improving Evolutionary Strategies by pinpointing the limitations of classical search distributions, commonly used by standard ES algorithms. We propose a new algorithm that leverages the high flexibility of distributions generated by bijective GNNs with an ES objective. We highlight that this algorithm can be seen as a plug-in extension to existing ES algorithms, and therefore can virtually incorporate any of them. Finally, we show its empirical advantages across a diversity of synthetic objective functions, as well as from objectives coming from Reinforcement Learning. Beyond the proposal of this algorithm, we believe that our work highlights the role of expressiveness in exploration for optimization tasks. This idea could be leverage in other settings where exploration is crucial, such a MDP-based policy search methods. An interesting line of future work could focus on optimizing GNN-based conditional distribution for RL tasks - an idea already developed in Ward et al. (2019); Mazoure et al. (2019). Other possible extensions to our work could focus on investigating first-order and mixed oracles, such as in Grathwohl et al. (2017); Faury et al. (2018). ",
+        "bbox": [
+            173,
+            714,
+            825,
+            893
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES   \nAman Agarwal, Soumya Basu, Tobias Schnabel, and Thorsten Joachims. Effective evaluation using logged bandit feedback from multiple loggers. In Proceedings of the 23rd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, pp. 687–696. ACM, 2017.   \nShun-Ichi Amari. Natural gradient works efficiently in learning. Neural Computation, 10(2):251– 276, 1998.   \nAnne Auger and Nikolaus Hansen. A restart cma evolution strategy with increasing population size. In 2005 IEEE congress on evolutionary computation, volume 2, pp. 1769–1776. IEEE, 2005.   \nGreg Brockman, Vicki Cheung, Ludwig Pettersson, Jonas Schneider, John Schulman, Jie Tang, and Wojciech Zaremba. OpenAi Gym. arXiv preprint arXiv:1606.01540, 2016.   \nLaurent Dinh, David Krueger, and Yoshua Bengio. NICE: Non-Linear Independent Components Estimation. arXiv preprint arXiv:1410.8516, 2014.   \nLaurent Dinh, Jascha Sohl-Dickstein, and Samy Bengio. Density Estimation using Real NVP. arXiv preprint arXiv:1605.08803, 2016.   \nYan Duan, Xi Chen, Rein Houthooft, John Schulman, and Pieter Abbeel. Benchmarking Deep Reinforcement Learning for Continuous Control. In International Conference on Machine Learning, pp. 1329–1338, 2016.   \nLouis Faury, Flavian Vasile, Clement Calauz ´ enes, and Oliver Fercoq. Neural Generative Models for \\` Global Optimization with Gradients. arXiv preprint arXiv:1805.08594, 2018.   \nFrauke Friedrichs and Christian Igel. Evolutionary tuning of multiple SVM parameters. Neurocomputing, 64:107–117, 2005.   \nTobias Glasmachers, Tom Schaul, Sun Yi, Daan Wierstra, and Jurgen Schmidhuber. Exponential ¨ natural evolution strategies. In Proceedings of the 12th annual conference on Genetic and evolutionary computation, pp. 393–400. ACM, 2010.   \nIan Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative Adversarial Nets. In Advances in Neural Information Processing Systems, pp. 2672–2680, 2014.   \nWill Grathwohl, Dami Choi, Yuhuai Wu, Geoff Roeder, and David Duvenaud. Backpropagation through the void: Optimizing control variates for black-box gradient estimation. arXiv preprint arXiv:1711.00123, 2017.   \nNikolaus Hansen. The CMA Evolution Strategy: a tutorial. arXiv preprint arXiv:1604.00772, 2016.   \nNikolaus Hansen and Andreas Ostermeier. Completely derandomized self-adaptation in Evolution Strategies. Evolutionary Computation, 9(2):159–195, 2001.   \nNikolaus Hansen, Anne Auger, Steffen Finck, and Raymond Ros. Real-parameter black-box optimization benchmarking 2010: Experimental setup. PhD thesis, INRIA, 2010.   \nNikolaus Hansen, Anne Auger, Olaf Mersmann, Tea Tusar, and Dimo Brockhoff. Coco: A platform for comparing continuous optimizers in a black-box setting. arXiv preprint arXiv:1603.08785, 2016.   \nNikolaus Hansen, Youhei Akimoto, and Petr Baudis. CMA-ES/pycma on Github. Zenodo, DOI:10.5281/zenodo.2559634, February 2019. URL https://doi.org/10.5281/ zenodo.2559634.   \nDonald R Jones, Matthias Schonlau, and William J Welch. Efficient global optimization of expensive black-box functions. Journal of Global optimization, 13(4):455–492, 1998.   \nDiederik P Kingma and Jimmy Ba. Adam: A Method for Stochastic Optimization. arXiv preprint arXiv:1412.6980, 2014.   \nDiederik $\\mathrm { \\bf P }$ Kingma and Max Welling. Auto-encoding Variational Bayes. arXiv preprint arXiv:1312.6114, 2013. ",
+        "bbox": [
+            171,
+            77,
+            826,
+            931
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Guoqing Liu, Li Zhao, Feidiao Yang, Jiang Bian, Tao Qin, Nenghai Yu, and Tie-Yan Liu. Trust Region Evolution Strategies. Association for the Advancement of Artificial Intelligence, 2019. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            133
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ilya Loshchilov and Frank Hutter. CMA-ES for hyperparameter optimization of deep neural networks. arXiv preprint arXiv:1604.07269, 2016. ",
+        "bbox": [
+            173,
+            140,
+            821,
+            169
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ilya Loshchilov, Marc Schoenauer, and Michele Sebag. Alternative restart strategies for cma-es. In International Conference on Parallel Problem Solving from Nature, pp. 296–305. Springer, 2012. ",
+        "bbox": [
+            174,
+            176,
+            823,
+            205
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Andrew L Maas, Awni Y Hannun, and Andrew Y Ng. Rectifier nonlinearities improve neural network acoustic models. In ICML Workshop on Deep Learning for Audio, Speech and Language Processing. Citeseer, 2013. ",
+        "bbox": [
+            174,
+            212,
+            825,
+            256
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "David JC MacKay. Bayesian neural networks and density networks. Nuclear Instruments and Methods in Physics Research Section A: Accelerators, Spectrometers, Detectors and Associated Equipment, 354(1):73–80, 1995. ",
+        "bbox": [
+            174,
+            263,
+            825,
+            306
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "James Martens. Deep Learning via Hessian-free Optimization. In International Conference of Machine Learning, volume 27, pp. 735–742, 2010. ",
+        "bbox": [
+            171,
+            313,
+            825,
+            343
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Bogdan Mazoure, Thang Doan, Audrey Durand, R Devon Hjelm, and Joelle Pineau. Leveraging exploration in off-policy algorithms via normalizing flows. arXiv preprint arXiv:1905.06893, 2019. ",
+        "bbox": [
+            174,
+            351,
+            823,
+            392
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jorge J More and Stefan M Wild. Benchmarking derivative-free optimization algorithms. ´ SIAM Journal on Optimization, 20(1):172–191, 2009. ",
+        "bbox": [
+            173,
+            400,
+            823,
+            430
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Thomas Nedelec, Nicolas Le Roux, and Vianney Perchet. A Comparative Study of Counterfactual Estimators. arXiv preprint arXiv:1704.00773, 2017. ",
+        "bbox": [
+            176,
+            436,
+            821,
+            467
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "George Papamakarios, Theo Pavlakou, and Iain Murray. Masked autoregressive flow for density estimation. In Advances in Neural Information Processing Systems, pp. 2338–2347, 2017. ",
+        "bbox": [
+            174,
+            473,
+            823,
+            503
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Leonid Peshkin and Christian R Shelton. Learning from scarce experience. In Proceedings of the Nineteenth International Conference on Machine Learning, pp. 498–505. Morgan Kaufmann Publishers Inc., 2002. ",
+        "bbox": [
+            173,
+            510,
+            823,
+            553
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Aravind Rajeswaran, Kendall Lowrey, Emanuel V Todorov, and Sham M Kakade. Towards generalization and simplicity in continuous control. In Advances in Neural Information Processing Systems, pp. 6550–6561, 2017. ",
+        "bbox": [
+            173,
+            560,
+            823,
+            604
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ingo Rechenberg. Evolutionsstrategien. In Simulationsmethoden in der Medizin und Biologie, pp. 83–114. Springer, 1978. ",
+        "bbox": [
+            173,
+            611,
+            821,
+            640
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Danilo Rezende and Shakir Mohamed. Variational inference with normalizing flows. In International Conference on Machine Learning, pp. 1530–1538, 2015. ",
+        "bbox": [
+            171,
+            647,
+            823,
+            678
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Oren Rippel and Ryan Prescott Adams. High-dimensional Probability Estimation with Deep Density Models. arXiv preprint arXiv:1302.5125, 2013. ",
+        "bbox": [
+            173,
+            684,
+            821,
+            714
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Tim Salimans, Jonathan Ho, Xi Chen, Szymon Sidor, and Ilya Sutskever. Evolution Strategies as a scalable alternative to Reinforcement Learning. arXiv preprint arXiv:1703.03864, 2017. ",
+        "bbox": [
+            173,
+            720,
+            823,
+            751
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Tom Schaul, Justin Bayer, Daan Wierstra, Yi Sun, Martin Felder, Frank Sehnke, Thomas Ruckstieß, ¨ and Jurgen Schmidhuber. PyBrain. ¨ Journal of Machine Learning Research, 11:743–746, 2010. ",
+        "bbox": [
+            173,
+            757,
+            823,
+            787
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Tom Schaul, Tobias Glasmachers, and Jurgen Schmidhuber. High dimensions and heavy tails for ¨ Natural Evolution Strategies. In Proceedings of the 13th annual conference on Genetic and Evolutionary Computation, pp. 845–852. ACM, 2011. ",
+        "bbox": [
+            173,
+            794,
+            823,
+            838
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal Policy Optimization Algorithms. arXiv preprint arXiv:1707.06347, 2017. ",
+        "bbox": [
+            171,
+            844,
+            821,
+            873
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Hans-Paul Schwefel. Numerische Optimierung von Computer-Modellen mittels der Evolutionsstrategie: mit einer vergleichenden Einfuhrung in die Hill-Climbing-und Zufallsstrategie ¨ . Birkhauser, 1977. ¨ ",
+        "bbox": [
+            174,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Bobak Shahriari, Kevin Swersky, Ziyu Wang, Ryan P Adams, and Nando De Freitas. Taking the human out of the loop: A review of Bayesian Optimization. Proceedings of the IEEE, 104(1): 148–175, 2016.   \nAkash Srivastava, Lazar Valkoz, Chris Russell, Michael U Gutmann, and Charles Sutton. Veegan: Reducing mode collapse in GANs using Implicit Variational Learning. In Advances in Neural Information Processing Systems, pp. 3308–3318, 2017.   \nAdith Swaminathan and Thorsten Joachims. Counterfactual Risk Minimization: Learning from Logged Bandit Feedback. In International Conference on Machine Learning, pp. 814–823, 2015.   \nPatrick Nadeem Ward, Ariella Smofsky, and Avishek Joey Bose. Improving exploration in softactor-critic with normalizing flows policies. arXiv preprint arXiv:1906.02771, 2019.   \nDaan Wierstra, Tom Schaul, Jan Peters, and Juergen Schmidhuber. Natural Evolution Strategies. In Evolutionary omputation, 2008. CEC 2008.(IEEE World Congress on Computational Intelligence), pp. 3381–3387. IEEE, 2008.   \nRonald J Williams. Simple statistical gradient-following algorithms for connectionist Reinforcement Learning. Machine Learning, 8(3-4):229–256, 1992. ",
+        "bbox": [
+            171,
+            103,
+            826,
+            352
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A COMPUTING THE MODE OF THE SEARCH DISTRIBUTION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            671,
+            118
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We prove here the fact that if $\\mu$ denotes the location of the mode of the latent distribution $\\nu _ { \\omega }$ , then $g _ { \\eta } ( \\mu )$ is a mode for $\\pi _ { \\omega , \\eta }$ . Indeed, under reasonable smoothness assumptions, one has that $y$ is a mode for $\\pi _ { \\omega , \\eta }$ if and only if: ",
+        "bbox": [
+            174,
+            132,
+            825,
+            176
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e7d459d7568fdfb5c698ff36a8b7432bcad37ee4a3d84f69db62465920a87492.jpg",
+        "text": "$$\n\\frac { \\partial \\pi _ { \\omega , \\eta } ( x ) } { \\partial x } \\bigg | _ { x = y } = 0\n$$",
+        "text_format": "latex",
+        "bbox": [
+            434,
+            183,
+            565,
+            220
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Since $\\pi _ { \\omega , \\eta } ( x ) = \\nu _ { \\omega } ( h _ { \\eta } ( x ) )$ , this is therefore equivalent to: ",
+        "bbox": [
+            173,
+            226,
+            562,
+            242
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/755e95fef3f867ca1edfea716890b24f3aee11d13f1037e66abbea9720d5161f.jpg",
+        "text": "$$\n\\frac { \\partial h _ { \\eta } ( x ) } { \\partial x } \\bigg | _ { x = y } \\cdot \\frac { \\partial \\nu _ { \\omega } ( z ) } { \\partial z } \\bigg | _ { z = h _ { \\eta } ( y ) } = 0\n$$",
+        "text_format": "latex",
+        "bbox": [
+            380,
+            247,
+            619,
+            286
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "In the NICE model, we have that $\\begin{array} { r } { \\left| \\frac { \\partial h _ { \\eta } ( x ) } { \\partial x } \\right| = 1 } \\end{array}$ for all $x$ hence the matrix $\\left. \\frac { \\partial h _ { \\eta } ( x ) } { \\partial x } \\right| _ { x = y }$ is invertible and its kernel is reduced to the null vector. Therefore: ",
+        "bbox": [
+            171,
+            292,
+            826,
+            333
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f14d8dae3ea10653dd45cf17f3f6536ea7e8f6fcfcd12e83f7e1249afde48f2a.jpg",
+        "text": "$$\n\\frac { \\partial \\nu _ { \\omega } ( z ) } { \\partial z } \\bigg | _ { z = h _ { \\eta } ( y ) } = 0\n$$",
+        "text_format": "latex",
+        "bbox": [
+            429,
+            335,
+            571,
+            375
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "and therefore $\\mu = h _ { \\eta } ( y )$ by definition of $\\mu$ (the only critical point of $\\nu _ { \\omega }$ ). Hence since $h _ { \\eta } ^ { - 1 } = g _ { \\eta }$ , we have that $y = g _ { \\eta } ( \\mu )$ which concludes the proof. ",
+        "bbox": [
+            173,
+            381,
+            825,
+            412
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "B ALGORITHM PSEUDO-CODE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            433,
+            441,
+            449
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We provide below the pseudo-code for the generic algorithm GNN- $\\mathcal { A }$ -ES, where $\\mathcal { A }$ is a generic ES algorithm operating on a parametric distribution $\\nu _ { \\omega }$ . The additional hyper-parameters are the horizon $T$ as well as the clipping constant $\\varepsilon$ . The function ${ \\mathrm { c l i p } } ( x , l b , u b )$ clips the input $x$ between a lower-bound $l b$ and an upper-bound $u b$ . ",
+        "bbox": [
+            173,
+            463,
+            825,
+            520
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/f95eb85313ceb6ea54daa795075ff1e25cba0c0dded282646c083bb24988ba60.jpg",
+        "table_caption": [
+            "Algorithm 2: GNN-A-ES (ex: GNN-xNES, GNN-CMA-ES) "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>inputs : objective function f,distribution Vω and its related ES algorithm A hyper-parameters: clipping constant ε, NICE model architecture, initial parameters Wo, initial weights no, horizon T, population size 入 (Initialization) Initialize NICE MLPs weights and biases with 7o. Let Hbe a circular buffer of length T × 入</td></tr></table>",
+        "bbox": [
+            171,
+            554,
+            807,
+            876
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "∗The (GNN iteration) step can be performed with virtually any gradient descent solver. In all our experiments, we used Adam (Kingma & Ba, 2014) with learning rate 1e-4 for 500 epochs. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 2 does not detail the mode-preserving addition for the sake of readability and clarity. We provide additional details on this procedure here. Let $\\mu _ { t }$ be the mode of the latent distribution $\\nu _ { \\omega _ { t } }$ . At the (Initialization) step, set $\\alpha _ { 0 } = g _ { \\eta _ { 0 } } ( \\mu _ { 0 } )$ where $g _ { \\eta } ( \\cdot )$ is the push-forward map on the NICE model described in Section 3.2. For all round $t \\geq 1$ , let $\\dot { f } _ { \\eta } ( z ) = \\bar { g } _ { \\eta } ( z ) - g _ { \\eta } ( \\mu _ { t } ) \\bar { + } \\alpha _ { t }$ . The variable $\\alpha _ { t }$ represent the push forward mapping of the latent distribution’s mean under the current model. Every time the latent space is updated - the $_ { E S }$ update) step, let $\\alpha _ { t + 1 } = f _ { \\eta _ { t } } ( \\mu _ { t + 1 } )$ . Then, for the (GNN update), optimize the forward-map $f _ { \\eta } ( z ) = g _ { \\eta } ( z ) - g _ { \\eta } ( \\mu _ { t + 1 } ) + \\alpha _ { t + 1 }$ . After this update, we have $\\bar { f } _ { \\eta _ { t + 1 } } ( \\mu _ { t + 1 } ) = \\alpha _ { t + 1 } = f _ { \\eta _ { t } } ( \\mu _ { t + 1 } ) \\bar { { \\bf \\Phi } }$ , which means that the mode of the search distribution (which is the image of the latent distribution mode) has not been impacted by the GNN update. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            229
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "C EXPERIMENTAL DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            250,
+            416,
+            266
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "C.1 HYPER-PARAMETERS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            281,
+            366,
+            296
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Baselines We use xNES with its default (adapted) hyper-parameters (described in Wierstra et al. (2008)) for both its baselines versions and its inner optimization parts in GNN-xNES. The population size $\\lambda$ is one such hyper-parameters, and is therefore set to $\\lambda = 4 + \\lfloor 3 \\log ( d ) \\rfloor$ . Also, as it is classically done in ES algorithms, we use a rank-based fitness shaping, designed to make the algorithm invariant with respect to order-preserving cost transformations. We use the same fitnessshaping function as in Wierstra et al. (2008). ",
+        "bbox": [
+            174,
+            308,
+            825,
+            392
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "GNN-ES Across all experiments, we use the same hyper-parameters for GNN-xNES without fine tuning for each tasks. We use three coupling layers, each with a single hidden layer MLP with 128 hidden neurons and Leaky ReLU activations. The MLPs are initialized via Glorot initialization, and the clipping constant is set to $\\varepsilon = 0 . 0 5$ . The history size $T$ was determined experimentally, and set to $T = \\bar { \\lfloor 3 * ( 1 + \\log ( d ) ) \\rfloor }$ . When restarts are used, this history size is divided by the numbers of restart so far (as the population size grows larger). ",
+        "bbox": [
+            174,
+            409,
+            825,
+            493
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "C.2 SYNTHETIC OBJECTIVES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            511,
+            388,
+            525
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Every synthetic objective we used in this work was taken from the BBOB2019 benchmark dataset. Their expression as well as additional details on the framework can be found in Hansen et al. (2010; 2016). At the beginning of each experiment, we set the Gaussian search distribution (for xNES) and the Gaussian latent distribution (for GNN-xNES) to a standard normal, with a mean uniformly sampled within the compact $\\mathcal { X }$ of interest (defined by the COCO framework). ",
+        "bbox": [
+            174,
+            536,
+            825,
+            607
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "C.3 RL ENVIRONMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            625,
+            356,
+            638
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Table 1 provides details on the RL environment used to compare GNN-xNES and xNES, like the dimensions of the state space $s$ and action space $\\mathcal { A }$ , the number $d$ of the policy’s degrees of freedom and the maximum number of steps $m$ per trajectory. At the beginning of each experiment, we set the Gaussian search distribution (for xNES) and the Gaussian latent distribution (for GNN-xNES) to a standard normal with zero mean. In this particular case, where the function evaluations are noisy, we kept the default population size of the xNES algorithm. ",
+        "bbox": [
+            174,
+            651,
+            825,
+            736
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/29c798382ab442c8ec3018c8fd9040ffa63004e6623833d5376d1231f82eebbc.jpg",
+        "table_caption": [
+            "Table 1: Reinforcement Learning environments "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Name</td><td>|S|</td><td>|A|</td><td>d</td><td>m</td></tr><tr><td>Swimmer-v1</td><td>13</td><td>21</td><td>28</td><td>1000</td></tr><tr><td>InvertedDoublePendulum-v1</td><td>11</td><td></td><td>12</td><td>1000</td></tr><tr><td>HalfCheetah-v1</td><td>20</td><td>6</td><td>126</td><td>1000</td></tr></table>",
+        "bbox": [
+            303,
+            747,
+            694,
+            808
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "D TWO-DIMENSIONAL VISUALIZATIONS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            864,
+            522,
+            880
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "We provide in Figure 8 additional two-dimensional visualizations of the behavior of GNN-xNES, on the Rosenbrock, Rastrigin, Beale and Bent-Cigar functions. We see that the NICE distributions can ",
+        "bbox": [
+            174,
+            895,
+            825,
+            924
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/311d594c3ec6e8fb78527803e6d60d271d737b730c251be035e25006765a1219.jpg",
+        "image_caption": [
+            "(d) (Doubly asymmetric) Bent Cigar, global optimum at $( 0 , 0 )$ "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            109,
+            663,
+            199
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/da2a20cb2e51968ad3673c4e04b747ac7345cc1e02f779521621aacac09f74da.jpg",
+        "image_caption": [
+            "(a) Rosenbrock, global op- (b) Rastrigin, global opti- (c) Beale, global optimum timum at $( 1 , 1 )$ mum at $( 0 , 0 )$ at (3, 0.5) "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            661,
+            104,
+            813,
+            193
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "table",
+        "img_path": "images/d5adbb73a2df878260f9cdcde53f6875bbf3ce54a9fef534390de7898000fc03.jpg",
+        "table_caption": [
+            "Figure 8: Two-dimensional visualizations. The black dotted lines represent the isolines of the level curves of a NICE search distribution trained with GNN-xNES. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Algorithm</td><td>mean(# restarts), d=2</td><td>mean(# restarts), d=5</td><td>mean(# restarts),d=10</td></tr><tr><td>xNES</td><td>2.3</td><td>2.7</td><td>3.4</td></tr><tr><td>GNN-xNES</td><td>1.3</td><td>2.5</td><td>2.9</td></tr></table>",
+        "bbox": [
+            200,
+            291,
+            797,
+            337
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Table 2: Mean number of restarts needed to discover the global minimum on the Rastrigin function. ",
+        "bbox": [
+            173,
+            347,
+            821,
+            361
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "efficiently fit each optimization landscapes, without having to reduce its entropy like a multivariate normal would. ",
+        "bbox": [
+            176,
+            388,
+            823,
+            416
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "E ADDITIONAL RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            438,
+            395,
+            453
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "We present here some additional results on some unimodal and multimodal synthetic functions. Figure 9 present ECDFs curve obtained from the Attractive Sector function, a highly asymmetrical function around its global minimum. On such a function, GNN-xNES seems to accelerate xNES in small dimensions, however this speed-up disappears in higher dimensions. Figure 10 presents results on the Rosenbrock function (without random rotations). Again, GNN-xNES accelerates the xNES algorithm. Figure 11 present results on the multimodal functions Gallagher’s Gaussian 101 Peaks and Gallagher’s Gaussian 21 Peaks. Again, GNN-xNES discovers the global minimum faster (on average) than xNES. ",
+        "bbox": [
+            174,
+            468,
+            825,
+            580
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "In our multimodal experiments, we used simulated restarts as a fair mean of comparing different algorithm (this is common practice in order to fairly compare algorithms that converge fast to potentially bad local minima to algorithms that converge slowly to the global minimum). If the empirical results prove that GNN-xNES accelerate xNES in the discovery of the global minimum, it does not prove that GNN-xNES leverages the flexibility of the GNN to detect the global minimum when xNES misses it. In an attempt to prove that it is indeed the case, we report in Table 2 the number of restarts needed by both GNN-xNES and xNES to discover the global minimum on the Rastrigin function (averaged over the 15 randomly initialized run). For this instance, GNN-xNES consistently discovers the global minimum with less restarts than xNES. ",
+        "bbox": [
+            174,
+            587,
+            825,
+            712
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "As detailed in Section 4, one can apply Algorithm 2 as a plug-in to any ES method. So far, we empirically evaluated the benefits of our approach by comparing xNES against its GNN extension (GNN-xNES). We present in Figure 12 additional evaluations obtained by comparing CMA-ES and its GNN extension (denoted GNN-CMA-ES) on the Rosenbrock function in dimension 2,5 and 10. CMA-ES is considered to be the state-of-the-art ES algorithm, and improving its performances is a non-trivial task. On the considered example GNN-CMA-ES improves CMA-ES, highlighting the empirical benefit of our approach for a large class of ES algorithm. One can however observe that the performance boost brought by the GNN extension is milder for GNN-CMA-ES then for GNNxNES. We suspect that this is due to the use of cumulation via an evolution path in ${ \\mathrm { C M A } } – \\mathbf { E S } ^ { 3 }$ , which basically introduces a momentum-like update when optimizing the latent distribution. While using an evolution path makes a lot of sense when optimizing a stationary objective, it can be quite harmful for non-stationary ones. We therefore believe that the cumulation step in CMA-ES (for the latent distribution) and the GNN optimization (making the objective optimized by CMA-ES in the latent space non-stationary) can lead to conflicting updates and might hinder the benefits brought by the GNN’s additional flexibility. Designing a GNN update strategy complying with the use of evolution paths could therefore be a way of further improving GNN-CMA-ES, and is left for future work. ",
+        "bbox": [
+            174,
+            719,
+            825,
+            900
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/4780aff2f18f49f8bd5ac4ccf8d08c815faa7980e56dd2a9c4d6ffed6c3bb3dc.jpg",
+        "image_caption": [
+            "Figure 9: ECDFs curve for the Attractive Sector function, $d { = } 2 , 5 , 1 0$ "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            102,
+            820,
+            242
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/15d5a43dad711006f45eb3c63a9311ee94135c357e7b775f9513f021c1f1efe7.jpg",
+        "image_caption": [
+            "Figure 10: ECDFs curve for the Rosenbrock function, $\\mathrm { d } { = } 2 , 5 { , } 1 0$ "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            284,
+            821,
+            426
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            479,
+            825,
+            536
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "F ABLATION STUDY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            556,
+            356,
+            571
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "We present here an ablation study for two additional tools that we introduced after the alternating optimization view: the mode preserving (16) extension as well as the history augmentation (15). Figure 13 presents ECDFs curves on the Rosenbrock, Rotated Rosenbrock and Bent Cigar functions in 2D, for a version of GNN-xNES that doesn’t use history but only the current population. Using history and therefore exposing the GNN to larger datasets improves the procedure. Figure 14 present similar results on a version of GNN-xNES without the mode preserving property (16). Again, one can notice that ensuring that the GNN training is mode-preserving is crucial to improve experimental results. ",
+        "bbox": [
+            173,
+            588,
+            826,
+            699
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/9e572d17a157ffd117415bd0f15a63c7cb309d9c5abf2d26176f23925a1ac64f.jpg",
+        "image_caption": [
+            "Figure 11: Scaling comparison of GNN-xNES and xNES on the Gallagher’s Gaussian 101 Peaks and Gallagher’s Gaussian 21 Peaks functions, $d { = } 2 , 5 , 1 0$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            267,
+            734,
+            723,
+            873
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/68ddd1cc5a7162a527451ccc1288b466f524bac93c83284b277804ec4d168823.jpg",
+        "image_caption": [
+            "Figure 12: ECDFs curves for the Rosenbrock function, $\\mathrm { ( d } { = } 2 , 5 , 1 0 \\mathrm { ) }$ comparing the CMA-ES and GNN-CMA-ES "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            142,
+            823,
+            285
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "image",
+        "img_path": "images/ce5f379c22f570a949ae5a5c15dc76ba8c84c7e12ffc5755ca17c0d20d6b8274.jpg",
+        "image_caption": [
+            "Figure 13: ECDFs curves for xNES, GNN-xNES and GNN-xNES-no-history, for which the history size $T = 1$ . Using past populations to estimate expectations improves the optimization. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            349,
+            821,
+            555
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "image",
+        "img_path": "images/6c05e70bd63b61ad177ed55b672b85c9bdf4e56871bfb862f80ad4ae8ca57013.jpg",
+        "image_caption": [
+            "Figure 14: ECDFs curves for xNES, GNN-xNES and GNN-xNES-nmp, which is not mode preserving. Ensuring that the training of the GNN doesn’t impact the mode of the search distribution improves the optimization. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            619,
+            821,
+            827
+        ],
+        "page_idx": 17
+    }
+]

parse/train/WoLQsYU8aZ/WoLQsYU8aZ.md

@@ -0,0 +1,249 @@
+# PETTINGZOO: GYM FOR MULTI-AGENT REINFORCEMENT LEARNING
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+This paper introduces PettingZoo, a library of diverse sets of multi-agent environments under a single elegant Python API. PettingZoo was developed with the goal of accelerating research in multi-agent reinforcement learning, by creating a set of benchmark environments easily accessible to all researchers and a standardized API for the field. This goal is inspired by what OpenAI’s Gym library did for accelerating research in single-agent reinforcement learning, and PettingZoo draws heavily from Gym in terms of API and user experience. PettingZoo is unique from other multi-agent environment libraries in that it’s API is based on the model of Agent Environment Cycle (“AEC”) games, which allows for the sensible representation of all varieties of games under one API for the first time. While retaining a very simple and Gym-like API, PettingZoo still allows access to low-level environment properties required by non-traditional learning methods.
+
+# 1 INTRODUCTION
+
+Reinforcement Learning (“RL”) considers learning a policy — a function that takes in an observation from an environment and emits an action — that achieves the maximum expected discounted reward when acting in an environment, and it’s capabilities have been one of the great success of modern machine learning. Multi-Agent Reinforcement Learning (MARL) in particular has been behind many of the most publicized achievements of modern machine learning — AlphaGo Zero (Silver et al., 2017), OpenAI Five (OpenAI, 2018), AlphaStar (Vinyals et al., 2019) — and has seen a boom in recent years. However, popular benchmark environments are scattered across many different locations (or made from scratch), are based around heterogeneous APIs, and are often in unmaintained states. Because of this, highly influential research in the field is generally restricted to institutions with dedicated engineering teams, research into new methods generally aren’t compared in like environments, and progress has been slow compared to single agent reinforcement learning (though this obviously cannot be attributed to benchmarks alone).
+
+Motivated by this, we introduce PettingZoo — a Python library collecting maintained versions of all popular MARL environments under a single simple Python API similar to that of OpenAI’s Gym library. It’s available on PyPI and can be installed via pip install pettingzoo.
+
+# 2 A TALE OF TOO MANY LIBRARIES
+
+OpenAI Gym (Brockman et al., 2016) was introduced shortly after the potential of reinforcement learning became widely known with Mnih et al. (2015). At the time, doing basic research in reinforcement learning was a large engineering challenge. The most popular set of environments were Atari games as part of the Arcade Learning Environment (“ALE”) (Bellemare et al., 2013). The ALE originally was challenging to compile and install, and had an involved C API and later an unofficial fork with a Python wrapper (Goodrich, 2015). A scattering of other environments existed as independent projects, in various languages, all with unique APIs. This level of heterogeneity meant that reinforcement learning code had to be adapted to every environment (including bridging programming languages). Accordingly, standardized reinforcement learning implementations weren’t possible, comparisons against a wide variety of environments were very difficult, and doing simple research in reinforcement learning was generally restricted to organizations with software engineering divisions. Gym was created to promote research in reinforcement learning by making comprehensive benchmarking more accessible, by allowing algorithm reuse, and by letting average machine learning researchers access the environments. This last point was achieved by putting every environment that a researcher would want to benchmark with (at the time of creation) under one simple API that anyone could understand, in Python (which was just starting to be the lingua-de-franca for machine learning). This lead to a mass proliferation of reinforcement learning research (especially at smaller institutions), many environments compliant with the API (Kidzinski et al., 2018; Leurent, 2018; Zamora et al., ´ 2016), and many RL libraries based around the API (Hill et al., 2018; Liang et al., 2018; Kuhnle et al., 2017).
+
+In the multiagent space, a similar level of fragmentation currently exists. Notable heterogenous sets of environments include OpenAI’s Competitive Multi-Agent Environments for competitive robotic control (Bansal et al., 2017), Sequential Social Dilemma Games for games where cooperation is difficult in a game theoretic sense (Leibo et al., 2017), RLCard for various card games Zha et al. (2019), MAgent for huge numbers of agents (Zheng et al., 2017), Multi-Particle Environments (”MPE") for diverse agent roles (Mordatch and Abbeel, 2017; Lowe et al., 2017), the Starcraft Multi-Agent Challenge (Samvelyan et al., 2019), and dozens more.
+
+# 3 RELATED WORKS
+
+Two attempts at some level of unification in the multi-agent space have been made. The first is OpenSpiel, released by Deepmind in 2019 (Lanctot et al., 2019), which includes excellent implementations of 45 classic games under one sensible API. However, their framework is limited to supporting simple discrete games due to its modeling of games as trees (which is impractical to represent for more continuous environments such as Atari). However, in the space of discrete games it has managed to encourage high quality and fair evaluations of general game solving methods.
+
+The second is the multi-agent API of RLlib Liang et al. (2018), an ambitious distributed RL framework. While the API is powerful, it has very minimal feature support and cannot sensibly represent strictly turn based games (i.e. Hananbi or Go). However, we do maintain PettingZoo support within RLlib so that users can easily leverage the learning methods included on our environments.
+
+# 4 DESIGN PHILOSOPHY
+
+# Simplicity and Similarity to Gym
+
+The ability for the Gym API to be near instantly understood has been a large driving factor in it’s widespread adoption. While a multi-agent API will inherently add complexity, we wanted to create a similarly simple API, and one that would be instantly familiar to researchers who have worked with Gym.
+
+# Agent Environment Cycle Games Based API
+
+Most environments have APIs that model agents as all stepping at once (Lowe et al., 2017; Zheng et al., 2017; Gupta et al., 2017; Liu et al., 2019; Liang et al., 2018), based on the Partially Observable Stochastic Games (POSGs) model. It turns out this easily results in bugs (Terry et al., 2020b) and is undesirable for handling strictly turn-based games, like chess, since agents aren’t allowed to step simultaneously. We instead model our API after the new Agent Environment Cycle games model, an equivalent model where agents step sequentially. That is, an agent performs an action, the environment responds, the next agent acts, the environment responds again, and the cycle repeats. This model allows for the sensible interactions with both strictly turn based games like chess and games where agents truly step simultaneously. A POSG can be easily converted to an equivalent sequential game by having each agent take a step in a cycle, and then updating the rewards and observations of the AEC game at the end of a cycle. For a formal proof of equivalence see (Terry et al., 2020b).
+
+# Variable Number of Agents
+
+We designed our API to robustly support the widest range of multi-agent scenarios possible, including agent generation and death. No general API currently supports this, but it is such an integral feature of so many environments that this support is essential.
+
+# Sufficient Configurability
+
+We wanted to make environments that are highly configurable by arguments the norm. In Gym, environments are generally not configurable, and arguments at generation are not used at all. However, playing with various environment properties is often highly desirable, and has accordingly been embraced by Gym environments outside the official library, as this makes research easier and aids reproducibility. Accordingly, we tried to make every reasonable environment parameter an option for users in PettingZoo.
+
+This notion of configuration extends beyond environment configuration to how learning methods interact with the environment. Due to the wide diversity of optimizations and different strategies applied for MARL, we wanted our API to allow for low level access to rewards, observations, done states and other info, while still being very simple for normal applications. Cyclically expansive curriculum learning from Terry et al. (2020b) is a good example of an interesting method that requires this sort of low level access.
+
+# Quality of Life Improvements
+
+Being users of Gym ourselves, we sought to add several "quality of life" improvements in PettingZoo motivated by frustrations we faced as users. These are:
+
+• Comprehensive, production-grade continuous integration testing. Testing in Gym is arguably lacking compared to other major libraries.   
+Tests of environments for API compliance and proper functionality, both for end users and for continuous integration testing of the library. We also provide detailed recommendations for better practices, inspired by the well liked messages of the Rust compiler.   
+Good error messages and warnings. When using Gym, triggering an error yields a trace back that needs to be slowly decoded to find the actual problem. We added speciality error messages and warnings for all common errors (that we’re aware of) to make development and debugging easier. This is again inspired by the Rust compiler.   
+Detailed, comprehensive documentation. Documentation is a fundamental part of a userfriendly software library. Observation space, action space, reward schemes, and other notable environment details are something you generally need to know to begin conducting even the most basic research with an environment. One criticism of Gym is that almost all information is only found in the source code, something especially problematic when working with sets of environments. To solve this in PettingZoo, we created a user friendly wiki-styled website that clearly includes all relevant information for an environment, as well as general information for sets of environments. Our website also includes details about tests, comprehensive API documentation, and so on. This is discussed further in section 7.
+
+# 5 API
+
+# 5.1 MAIN API
+
+Per our discussion above, we sought to create a simple API that could encapsulate all games and be instantly understood to any Gym user, illustrated by comparing Figure 1 and Figure 2. We use the observation/action space objects from Gym, as well as the same seeding method because they are well designed and familiar to researchers.
+
+Figure 1: Basic Usage of Gym
+
+import gym   
+env $=$ gym.make(’CartPole-v0’)   
+observation $=$ env.reset()   
+for _ in range(1000): env.render() action $=$ policy(observation) observation, reward, done, info $=$ env.step(action)   
+env.close()
+
+Figure 2: Basic Usage of PettingZoo
+
+from pettingzoo.butterfly import pistonball_v0   
+env $=$ pistonball_v0.env()   
+env.reset()   
+for agent in env.agent_iter(1000): env.render() observation, reward, done, info $=$ env.last() action $=$ policy(observation, agent) env.step(action)   
+env.close()
+
+# 5.2 PARALLEL API
+
+In addition to our main API, for certain environments we offer a separate API based off of the POSG model. It supports games and methods that assume this model very nicely. In style, it is very similar to RLlib’s multi-agent API (Liang et al., 2018), accepting and returning dictionaries keyed on agent names. The primary motivation for including this secondary API is because in games where it’s applicable, it can allow for parallelization features which can lead to large performance improvements.
+
+# 5.3 ADDITIONAL API FEATURES
+
+While the API is elegant for simple cases, it’s still able to handle important edge cases. This is achieved through lower level API calls for specific attributes: rewards emitted at any time are included for every agent in the rewards dictionary attributes, and dones and infos dictionaries can similarly be used. We additionally have an observe(agent) function. render() and close() function identically to Gym for rendering environments being played by a policy. agents is a list of the names of all agents in the game, and due to considerations regarding variable numbers of agents possible_agents is an additional list attribute. Finally, observation_spaces and action_spaces are dictionaries of the Gym observation/action spaces for all agents in possible_agents.
+
+When an agent dies, its done is set to True, it will become the next selected agent to act, and the action taken is required to be None. After this dummy step is taken, the agent will be removed from agents and all dictionary attributes. Note than a whole environment is done if and only if agents is empty. Agent generation can be implemented by simply adding an agent to the agents list and allowing its rewards and observations to be accessed.
+
+Finally, environment configuration is handled by passing arguments to the .env() constructor, a standard that all third-party Gym environments have adapted. These arguments can fundamentally change environment behavior, such as the number of agents, the reward structure, and even its action and observation spaces. All environments in PettingZoo allow for some degree of customization in this manner, with many allowing quite a bit.
+
+# 5.4 IMPLEMENTING AN ENVIRONMENT
+
+Compliant environments inherit from a general class (AECEnv). To allow for sufficient flexibility, environments only expose lower level attributes (dictionaries of values for all agents — dones, infos, rewards) and an observe method that takes an agent. These are then wrapped to provide the more general functions you see above by the base class. This low level functionality allows for entirely new APIs to be efficiently added on top of PettingZoo environments should the need arise. We’ve done this ourselves with the secondary parallel POSG based API, which have wrappers that convert both to and from the parallel and standard APIs.
+
+# 6 ENVIRONMENTS
+
+Similar to Gym, we wanted to include popular and interesting environments within one package, in an easily usable format. Half of the environment classes we include (MPE, MAgent, and SISL),
+
+![](images/a9b02e128eced92955f661e47951b0e0b1815a7263f73d2e088a212111264a40.jpg)  
+Figure 3: Example Environments From Each Class
+
+(e) MPE: Simple Adversary
+
+despite their popularity, have previously only existed as unmaintained “research grade” code, have not been available for installation via pip, have required large amounts of maintenance to run at all, and have required large amounts of debugging, code review, code cleanup and documentation to bring to a production-grade state. The Multi-Agent Atari and Butterfly classes are new environments that we believe pose important and novel challenges to multi-agent reinforcement learning. Finally, we include the Classic class — classic board and card games popular within the RL literature.
+
+# Atari
+
+Atari games represent the single most popular and iconic class of benchmarks in reinforcement learning. Recently, a multi-agent fork of the Atari Learning Environment was created that allows programmatic control and reward collection of Atari’s iconic multi-player games (Terry and Black, 2020). As in the single player Atari environments, the observation is the rendered frame of the game, which is shared between all agents, so there is no partial observability. Most of these games have competitive or mixed reward structures, making them suitable for general study of adversarial and mixed reinforcement learning. In particular, Terry and Black (2020) categorizes the games into 7 different types: 1v1 tournament games, mixed sum survival games (Space Invaders, shown in Figure 3a. is an example of this), competitive racing games, long term strategy games, 2v2 tournament games, a four-player free-for-all game and a cooperative game. For easy ROM installation, AutoROM, a separate PyPI package, can be used to easily install the needed Atari ROMs in an automated manner.
+
+# Butterfly
+
+Of all the environments included, the majority of them are competitive. We wanted to supplement this with a set of interesting graphical cooperative environments. Pistonball, depicted in Figure 3b, where the pistons need to coordinate to move the ball to the left, while only being able to observe a local part of the screen, requires learning nontrivial emergent behavior and indirect communication to perform well. Knights Archers Zombies is a game in which players work together to defeat approaching zombies before they can reach the players. It is designed to be a fast paced graphically interesting combat game with partial observability and heterogeneous agents, where achieving good performance requires extraordinarily high levels of agent coordination. Cooperative pong, where two dissimilar paddles work together to keep the ball in play as long as possible, was intended to be a be very simple cooperative continuous control-type task, with heterogeneous agents. Prison was designed to be the simplest possible game in MARL, and to be used as a debugging tool. Prospector was included to intentionally be a very challenging game for conventional methods—it has two classes of agents, with different goals, action spaces, and observation spaces (something many current cooperative MARL algorithms struggle with), and has very sparse rewards (something all RL algorithms struggle with). It is intended to be an very difficult benchmark for MARL, in the same vein of Montezuma’s Revenge.
+
+# Classic
+
+Classical board and card games have long been some of the most popular environments in reinforcement learning (Tesauro, 1995; Silver et al., 2016; Bard et al., 2019). We include all of the standard multiplayer games in RLCard (Zha et al., 2019): Dou Dizhu, Gin Rummy, Leduc Hold’em, Limit Texas Hold’em, Mahjong, No-limit Texas Hold’em, and Uno. We additionally include all AlphaZero games, using the same observation and action spaces—Chess and Go. We finally included Backgammon, Connect Four, Checkers, Rock Paper Scissors, Rock Paper Scissors Lizard Spock, and Tic Tac Toe to add a diverse set of simple, popular games to allow for more robust benchmarking of RL methods.
+
+# MAgent
+
+The MAgent library, from Zheng et al. (2017) was introduced as a configurable and scalable environment that could support thousands of interactive agents. These environments have mostly been studied as a setting for emergent behavior (Pokle, 2018), heterogeneous agents (Subramanian et al., 2020), and efficient learning methods with many agents (Chen et al., 2019). We include a number of preset configurations, for example the Adversarial Pursuit environment shown in Figure 3d. We make a few changes to the preset configurations used in the original MAgent paper. The global "minimap" observations in the battle environment are turned off by default, requiring implicit communication between the agents for complex emergent behavior to occur. The rewards in Gather and Tiger-Deer are also slightly changed to prevent emergent behavior from being a direct result of the reward structure.
+
+# MPE
+
+The Multi-Agent Particle Environments (MPE) were introduced as part of Mordatch and Abbeel (2017) and first released as part of Lowe et al. (2017). These are 9 communication oriented environments where particle agents can (sometimes) move, communicate, see each other, push each other around, and interact with fixed landmarks. Environments are cooperative, competitive, or require team play. They have been popular in research for general MARL methods Lowe et al. (2017), emergent communication (Mordatch and Abbeel, 2017), team play (Palmer, 2020), and much more. As part of their inclusion in PettingZoo, we converted the action spaces to a discrete space which is the Cartesian product of the movement and communication action possibilities. We also added comprehensive documentation, parameterized any local reward shaping (with the default setting being the same as in Lowe et al. (2017)), and made a single render window which captures all the activities of all agents (including communication), making it easier to visualize.
+
+# SISL
+
+We finally included the three cooperative environments introduced in Gupta et al. (2017): Pursuit, Waterworld, and Multiwalker. Pursuit is a standard pursuit-evasion game Vidal et al. (2002) where pursuers and controlled in a randomly generated map. Pursuer agents are rewarded for capturing randomly generated evaders by surrounding them on all sides. Waterworld is a continuous control game where the pursuing agents cooperatively hunt down food targets while trying to avoid poison targets. Multiwalker (Figure 3f) is a more challenging continuous control task that is based on Gym’s BipedalWalker environment. In Multiwalker, a package is placed on three independently controlled robot legs. Each robot is given a small positive reward for every unit of forward horizontal movement of the package, while they receive a large penalty for dropping the package.
+
+# 7 DOCUMENTATION
+
+Documentation is a fundamental part of a user-friendly software library. There’s a tremendous amount of useful information about these environments, especially due to their diversity, so we sought to create as detailed documentation as possible, while designing it in a way to ensure it’s still useful and approachable. PettingZoo includes comprehensive documentation for the API, the continuous integration tests, and each environment. A majority of popular libraries do not have extensive documentation. For example, OpenAI’s popular Gym library only lists the observation space shape on each environment’s documentation page. PettingZoo’s documentation thoroughly explains each environment’s observation and action spaces, and includes relevant information to help researchers. The goal is to allow people to compare environments easily, and for developers to very rarely need to refer to source.
+
+Our design for displaying so much information was inspired by Wikipedia’s familiar and well-known layout. This is illustrated in Figure 4. All documentation is included in the supplemental materials to facilitate anonymous review.
+
+![](images/65c3896c46cc6a5513b1379dc1ff0e650eff5b67976670bb54346138584a2bef.jpg)  
+Figure 4: The beginning PettingZoo documentation for the Go environment, illustrating how we used the design metaphor of a Wikipedia page to include a large amount of detail in a manner that isn’t overwhelming
+
+# 8 BASELINES
+
+All environments implemented in PettingZoo include baselines to provide a general sense of the difficulty of the environment, and for something to initially compare against. We do this here for the
+
+Butterfly environments that this library introduces for the first time; similar baselines exist in the papers introducing all other environments. We used parameter sharing (Terry et al., $2 0 2 0 \mathrm { c }$ ; Gupta et al., 2017) with Ape-X DQN (Horgan et al., 2018), with RLLib (Liang et al., 2018). Our results are shown in Figure 5. Preprocessing and hyperparameter details are included in Appendix A. All preprocessing was done with the SuperSuit wrapper library (Terry et al., 2020a), which has recently added support for PettingZoo based multi-agent environments based. Code for the environments, training logs, and saved policies are available at https://github.com/pettingzoopaper/ pettingzoopaper.
+
+![](images/78f54dc3d5e43fd64d01736df70d1bcbc1373c913c6dbfeaa93b6e82297c602b.jpg)  
+Figure 5: Total reward when learning on each Butterfly environment via parameter shared Ape-X DQN (a-d) and parameter shared PPO (e).
+
+# 9 CONCLUSION
+
+This paper introduces PettingZoo, a Python library of many diverse multi-agent reinforcement learning environments under one simple API, akin to a multi-agent version of OpenAI’s Gym library.
+
+Reinforcement learning systems have two main components, the environment and the agent(s) that learn. Without a standardized environment base, research progresses by designing and building both the environment and the agent (as has been the case for MARL). The main contribution of PettingZoo is that it enables more research which focuses on agents by standardizing and democratizing the environments. We hope that this allows for research in multi-agent reinforcement learning to accelerate and flourish.
+
+We’re aware of two notable limitations of PettingZoo. The first is that games with significantly more than 10,000 agents (or potential agents) will have meaningful performance issues. This arises from needing to prespecify observation/action spaces and potential agent names. We view this as a practically acceptable limitation. The second notable limitation is that PettingZoo does not currently allow users to access the global environment state, a feature required by some centralized critic methods. We’re actively working on supporting this via a .state() method.
+
+We see three obvious directions for future work. The first is additions of more interesting environments under our API (possibly from by the community, as has happened with Gym). While we’ve included a large number of environments, there are additional sets that would be valuable to include: the open-source implementations of social sequential dilemma games (Vinitsky et al., 2019), and the StarCraft 2 Multi-Agent Challenge (“SMAC“) environments (Samvelyan et al., 2019). The second direction we envision is a service to allow different researchers’ agents to play against each other in competitive games, leveraging the standardized API and environment set. Finally, we envision the development of procedurally generated multi-agent environments to test how well methods generalize, akin to the Gym procgen environments. (Cobbe et al., 2019).
+
+# ACKNOWLEDGMENTS
+
+Thank you to Deepthi Raghunandan and Kevin Hogan for many helpful discussions surrounding what testing should look like. Thank you to Nathaniel Grammel for many helpful discussions in the early planning stages of the project. Thank you to Ross Allen and his group for reporting numerous bugs.
+
+# REFERENCES
+
+Trapit Bansal, Jakub Pachocki, Szymon Sidor, Ilya Sutskever, and Igor Mordatch. Emergent complexity via multi-agent competition. CoRR, abs/1710.03748, 2017. URL http://arxiv.org/ abs/1710.03748.
+
+Nolan Bard, Jakob N. Foerster, Sarath Chandar, Neil Burch, Marc Lanctot, H. Francis Song, Emilio Parisotto, Vincent Dumoulin, Subhodeep Moitra, Edward Hughes, Iain Dunning, Shibl Mourad, Hugo Larochelle, Marc G. Bellemare, and Michael Bowling. The hanabi challenge: A new frontier for AI research. CoRR, abs/1902.00506, 2019. URL http://arxiv.org/abs/ 1902.00506.
+
+Marc G Bellemare, Yavar Naddaf, Joel Veness, and Michael Bowling. The arcade learning environment: An evaluation platform for general agents. Journal of Artificial Intelligence Research, 47: 253–279, 2013.
+
+Greg Brockman, Vicki Cheung, Ludwig Pettersson, Jonas Schneider, John Schulman, Jie Tang, and Wojciech Zaremba. Openai gym. arXiv preprint arXiv:1606.01540, 2016.
+
+Y. Chen, M. Zhou, Ying Wen, Y. Yang, Y. Su, W. Zhang, Dell Zhang, J. Wang, and Han Liu. Factorized q-learning for large-scale multi-agent systems. In DAI ’19, 2019.
+
+Karl Cobbe, Christopher Hesse, Jacob Hilton, and John Schulman. Leveraging procedural generation to benchmark reinforcement learning. arXiv preprint arXiv:1912.01588, 2019.
+
+Ben Goodrich. ale_python_interface. https://github.com/bbitmaster/ale_python_ interface, 2015. GitHub repository.
+
+Jayesh K Gupta, Maxim Egorov, and Mykel Kochenderfer. Cooperative multi-agent control using deep reinforcement learning. In International Conference on Autonomous Agents and Multiagent Systems, pages 66–83. Springer, 2017.
+
+Ashley Hill, Antonin Raffin, Maximilian Ernestus, Adam Gleave, Anssi Kanervisto, Rene Traore, Prafulla Dhariwal, Christopher Hesse, Oleg Klimov, Alex Nichol, Matthias Plappert, Alec Radford, John Schulman, Szymon Sidor, and Yuhuai Wu. Stable baselines. https://github.com/ hill-a/stable-baselines, 2018.
+
+Dan Horgan, John Quan, David Budden, Gabriel Barth-Maron, Matteo Hessel, Hado van Hasselt, and David Silver. Distributed prioritized experience replay. CoRR, abs/1803.00933, 2018. URL http://arxiv.org/abs/1803.00933.
+
+Łukasz Kidzinski, Sharada P Mohanty, Carmichael Ong, Jennifer Hicks, Sean Francis, Sergey Levine, ´ Marcel Salathé, and Scott Delp. Learning to run challenge: Synthesizing physiologically accurate motion using deep reinforcement learning. In Sergio Escalera and Markus Weimer, editors, NIPS 2017 Competition Book. Springer, Springer, 2018.
+
+Alexander Kuhnle, Michael Schaarschmidt, and Kai Fricke. Tensorforce: a tensorflow library for applied reinforcement learning. Web page, 2017. URL https://github.com/ tensorforce/tensorforce.
+
+Marc Lanctot, Edward Lockhart, Jean-Baptiste Lespiau, Vinícius Flores Zambaldi, Satyaki Upadhyay, Julien Pérolat, Sriram Srinivasan, Finbarr Timbers, Karl Tuyls, Shayegan Omidshafiei, Daniel Hennes, Dustin Morrill, Paul Muller, Timo Ewalds, Ryan Faulkner, János Kramár, Bart De Vylder, Brennan Saeta, James Bradbury, David Ding, Sebastian Borgeaud, Matthew Lai, Julian Schrittwieser, Thomas W. Anthony, Edward Hughes, Ivo Danihelka, and Jonah Ryan-Davis. Openspiel: A framework for reinforcement learning in games. CoRR, abs/1908.09453, 2019. URL http://arxiv.org/abs/1908.09453.
+
+Joel Z. Leibo, Vinícius Flores Zambaldi, Marc Lanctot, Janusz Marecki, and Thore Graepel. Multiagent reinforcement learning in sequential social dilemmas. CoRR, abs/1702.03037, 2017. URL http://arxiv.org/abs/1702.03037.
+
+Edouard Leurent. An environment for autonomous driving decision-making. https://github. com/eleurent/highway-env, 2018.
+
+Eric Liang, Richard Liaw, Robert Nishihara, Philipp Moritz, Roy Fox, Ken Goldberg, Joseph E. Gonzalez, Michael I. Jordan, and Ion Stoica. RLlib: Abstractions for distributed reinforcement learning. In International Conference on Machine Learning (ICML), 2018.
+
+Siqi Liu, Guy Lever, Josh Merel, Saran Tunyasuvunakool, Nicolas Heess, and Thore Graepel. Emergent coordination through competition. CoRR, abs/1902.07151, 2019. URL http:// arxiv.org/abs/1902.07151.
+
+Ryan Lowe, Yi Wu, Aviv Tamar, Jean Harb, Pieter Abbeel, and Igor Mordatch. Multi-agent actorcritic for mixed cooperative-competitive environments. Neural Information Processing Systems (NIPS), 2017.
+
+Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A Rusu, Joel Veness, Marc G Bellemare, Alex Graves, Martin Riedmiller, Andreas K Fidjeland, Georg Ostrovski, et al. Human-level control through deep reinforcement learning. nature, 518(7540):529–533, 2015.
+
+Igor Mordatch and Pieter Abbeel. Emergence of grounded compositional language in multi-agent populations. arXiv preprint arXiv:1703.04908, 2017.
+
+OpenAI. Openai five. https://blog.openai.com/openai-five/, 2018.
+
+G. Palmer. Independent learning approaches: Overcoming multi-agent learning pathologies in team-games. 2020.
+
+Stefanie Anna Baby Ling Li Ashwini Pokle. Analysis of emergent behavior in multi agent environments using deep reinforcement learning. 2018.
+
+Mikayel Samvelyan, Tabish Rashid, Christian Schröder de Witt, Gregory Farquhar, Nantas Nardelli, Tim G. J. Rudner, Chia-Man Hung, Philip H. S. Torr, Jakob N. Foerster, and Shimon Whiteson. The starcraft multi-agent challenge. CoRR, abs/1902.04043, 2019. URL http://arxiv.org/ abs/1902.04043.
+
+David Silver, Aja Huang, Chris J Maddison, Arthur Guez, Laurent Sifre, George Van Den Driessche, Julian Schrittwieser, Ioannis Antonoglou, Veda Panneershelvam, Marc Lanctot, et al. Mastering the game of go with deep neural networks and tree search. nature, 529(7587):484–489, 2016.
+
+David Silver, Julian Schrittwieser, Karen Simonyan, Ioannis Antonoglou, Aja Huang, Arthur Guez, Thomas Hubert, Lucas Baker, Matthew Lai, Adrian Bolton, et al. Mastering the game of go without human knowledge. nature, 550(7676):354–359, 2017.
+
+Sriram Ganapathi Subramanian, P. Poupart, Matthew E. Taylor, and N. Hegde. Multi type mean field reinforcement learning. In AAMAS, 2020.
+
+Justin K Terry and Benjamin Black. Multiplayer support for the arcade learning environment. arXiv preprint arXiv:2009.09341, 2020.
+
+Justin K Terry, Benjamin Black, and Ananth Hari. Supersuit: Simple microwrappers for reinforcement learning environments. arXiv preprint arXiv:2008.08932, 2020a.
+
+Justin K Terry, Nathaniel Grammel, Benjamin Black, Ananth Hari, Luis Santos, and Caroline Horsch. Agent environment cycle games. arXiv preprint arXiv:2009.13051, 2020b.
+
+Justin K Terry, Nathaniel Grammel, Ananth Hari, Luis Santos, and Benjamin Black. Revisiting parameter sharing in multi-agent deep reinforcement learning. arXiv preprint arXiv:2005.13625, 2020c.
+
+Gerald Tesauro. Temporal difference learning and td-gammon. Commun. ACM, 38(3):58–68, March 1995. ISSN 0001-0782. doi: 10.1145/203330.203343. URL https://doi.org/10.1145/ 203330.203343.
+
+Rene Vidal, Omid Shakernia, H Jin Kim, David Hyunchul Shim, and Shankar Sastry. Probabilistic pursuit-evasion games: theory, implementation, and experimental evaluation. IEEE transactions on robotics and automation, 18(5):662–669, 2002.
+
+Eugene Vinitsky, Natasha Jaques, Joel Leibo, Antonio Castenada, and Edward Hughes. An open source implementation of sequential social dilemma games. https://github.com/ eugenevinitsky/sequential_social_dilemma_games/, 2019. GitHub repository.
+
+Oriol Vinyals, Igor Babuschkin, Wojciech M Czarnecki, Michaël Mathieu, Andrew Dudzik, Junyoung Chung, David H Choi, Richard Powell, Timo Ewalds, Petko Georgiev, et al. Grandmaster level in starcraft ii using multi-agent reinforcement learning. Nature, 575(7782):350–354, 2019.
+
+Iker Zamora, Nestor Gonzalez Lopez, Victor Mayoral Vilches, and Alejandro Hernandez Cordero. Extending the openai gym for robotics: a toolkit for reinforcement learning using ros and gazebo. arXiv preprint arXiv:1608.05742, 2016.
+
+Daochen Zha, Kwei-Herng Lai, Yuanpu Cao, Songyi Huang, Ruzhe Wei, Junyu Guo, and Xia Hu. Rlcard: A toolkit for reinforcement learning in card games. arXiv preprint arXiv:1910.04376, 2019.
+
+Lianmin Zheng, Jiacheng Yang, Han Cai, Weinan Zhang, Jun Wang, and Yong Yu. Magent: A many-agent reinforcement learning platform for artificial collective intelligence. arXiv preprint arXiv:1712.00600, 2017.
+
+# A BASELINE EXPERIMENT HYPERPARAMETERS AND PREPROCESSING
+
+All of the environments were preprocessed in the following way: observations were resized to 84x84 images with linear interpolation, converted to grayscale, then normalized. This preprocessing was performed with SuperSuit (Terry et al., 2020a).
+
+The graphically subtle environments (Knights Archers Zombies, Prospector and Cooperative Pong) had their observations processed with the RLlib default network: A convolutional layer with a $8 \mathrm { x } 8$ kernel, stride of 4, and 16 filters, followed by a convolutional layer with a 4x4 kernel, stride of 2, and 32 filters, followed by a convolutional layer with n 11x11 kernel, stride of 1, and 256 filters.
+
+The graphically simple environments (Prison, Pistonball) were resized to $3 2 \mathrm { x } 3 2 $ and flattened in addition to the above preprocessing. The observation was processed with a network with two hidden linear layers, 400 and 300 neurons wide, respectively.
+
+Table 1: Hyperparameters for ApeX DQN and PPO on each Butterfly environment.   
+
+<table><tr><td>RL method</td><td>Hyperparameter</td><td>Value</td></tr><tr><td>ApeX-DQN</td><td>adam_epsilon</td><td>0.00015</td></tr><tr><td></td><td>buffer_size</td><td>400000</td></tr><tr><td></td><td>double_q</td><td>True</td></tr><tr><td></td><td>dueling</td><td>True</td></tr><tr><td></td><td>epsilon_timesteps</td><td>200000</td></tr><tr><td></td><td>final_epsilon</td><td>0.01</td></tr><tr><td></td><td>final_prioritized_replay_beta</td><td>1.0</td></tr><tr><td></td><td>gamma</td><td>0.99</td></tr><tr><td></td><td>learning_starts</td><td>10000</td></tr><tr><td></td><td>lr</td><td>0.0001</td></tr><tr><td></td><td>n_step</td><td>3</td></tr><tr><td></td><td>num_atoms</td><td>1</td></tr><tr><td></td><td>num_envs_per_worker</td><td>4</td></tr><tr><td></td><td>num_gpus</td><td>1</td></tr><tr><td></td><td>num_workers</td><td>12</td></tr><tr><td></td><td>prioritized_replay</td><td>True</td></tr><tr><td></td><td>prioritized_replay_alpha</td><td>0.5</td></tr><tr><td></td><td>prioritized_replay_beta</td><td>0.4</td></tr><tr><td></td><td>prioritized_replay_beta_annealing_timesteps</td><td>2000000</td></tr><tr><td></td><td>rollout_fragment_length</td><td>32</td></tr><tr><td></td><td>target_network_update_freq</td><td>10000</td></tr><tr><td></td><td>timesteps_per_iteration</td><td>15000</td></tr><tr><td></td><td>train_batch_size</td><td>512</td></tr><tr><td>PPO</td><td>gamma</td><td>0.99</td></tr><tr><td></td><td>num_envs_per_worker</td><td>4</td></tr><tr><td></td><td>num_gpus</td><td>1</td></tr><tr><td></td><td>num_workers</td><td>12</td></tr><tr><td></td><td>compress_observations</td><td>False</td></tr><tr><td></td><td>lambda</td><td>0.95</td></tr><tr><td></td><td>kl_coeff</td><td>0.5</td></tr><tr><td></td><td>clip_rewards</td><td>True</td></tr><tr><td></td><td>clip_param</td><td>0.1</td></tr><tr><td></td><td>vf_clip_param</td><td>10.0</td></tr><tr><td></td><td>entropy_coeff</td><td>0.01</td></tr><tr><td></td><td>train_batch_size</td><td>5000</td></tr><tr><td></td><td>sample_batch_size</td><td>25</td></tr><tr><td></td><td>sgd_minibatch_size</td><td>256</td></tr><tr><td></td><td>num_sgd_iter</td><td>100</td></tr><tr><td></td><td>batch_mode</td><td>truncate_episodes</td></tr><tr><td></td><td>vf_share_layers</td><td>True</td></tr></table>

parse/train/WoLQsYU8aZ/WoLQsYU8aZ_content_list.json

@@ -0,0 +1,1379 @@
+[
+    {
+        "type": "text",
+        "text": "PETTINGZOO: GYM FOR MULTI-AGENT REINFORCEMENT LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            826,
+            145
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            170,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            234,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "This paper introduces PettingZoo, a library of diverse sets of multi-agent environments under a single elegant Python API. PettingZoo was developed with the goal of accelerating research in multi-agent reinforcement learning, by creating a set of benchmark environments easily accessible to all researchers and a standardized API for the field. This goal is inspired by what OpenAI’s Gym library did for accelerating research in single-agent reinforcement learning, and PettingZoo draws heavily from Gym in terms of API and user experience. PettingZoo is unique from other multi-agent environment libraries in that it’s API is based on the model of Agent Environment Cycle (“AEC”) games, which allows for the sensible representation of all varieties of games under one API for the first time. While retaining a very simple and Gym-like API, PettingZoo still allows access to low-level environment properties required by non-traditional learning methods. ",
+        "bbox": [
+            233,
+            265,
+            766,
+            433
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            458,
+            336,
+            474
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Reinforcement Learning (“RL”) considers learning a policy — a function that takes in an observation from an environment and emits an action — that achieves the maximum expected discounted reward when acting in an environment, and it’s capabilities have been one of the great success of modern machine learning. Multi-Agent Reinforcement Learning (MARL) in particular has been behind many of the most publicized achievements of modern machine learning — AlphaGo Zero (Silver et al., 2017), OpenAI Five (OpenAI, 2018), AlphaStar (Vinyals et al., 2019) — and has seen a boom in recent years. However, popular benchmark environments are scattered across many different locations (or made from scratch), are based around heterogeneous APIs, and are often in unmaintained states. Because of this, highly influential research in the field is generally restricted to institutions with dedicated engineering teams, research into new methods generally aren’t compared in like environments, and progress has been slow compared to single agent reinforcement learning (though this obviously cannot be attributed to benchmarks alone). ",
+        "bbox": [
+            174,
+            489,
+            825,
+            656
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Motivated by this, we introduce PettingZoo — a Python library collecting maintained versions of all popular MARL environments under a single simple Python API similar to that of OpenAI’s Gym library. It’s available on PyPI and can be installed via pip install pettingzoo. ",
+        "bbox": [
+            176,
+            664,
+            825,
+            705
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "2 A TALE OF TOO MANY LIBRARIES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            726,
+            496,
+            742
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "OpenAI Gym (Brockman et al., 2016) was introduced shortly after the potential of reinforcement learning became widely known with Mnih et al. (2015). At the time, doing basic research in reinforcement learning was a large engineering challenge. The most popular set of environments were Atari games as part of the Arcade Learning Environment (“ALE”) (Bellemare et al., 2013). The ALE originally was challenging to compile and install, and had an involved C API and later an unofficial fork with a Python wrapper (Goodrich, 2015). A scattering of other environments existed as independent projects, in various languages, all with unique APIs. This level of heterogeneity meant that reinforcement learning code had to be adapted to every environment (including bridging programming languages). Accordingly, standardized reinforcement learning implementations weren’t possible, comparisons against a wide variety of environments were very difficult, and doing simple research in reinforcement learning was generally restricted to organizations with software engineering divisions. Gym was created to promote research in reinforcement learning by making comprehensive benchmarking more accessible, by allowing algorithm reuse, and by letting average machine learning researchers access the environments. This last point was achieved by putting every environment that a researcher would want to benchmark with (at the time of creation) under one simple API that anyone could understand, in Python (which was just starting to be the lingua-de-franca for machine learning). This lead to a mass proliferation of reinforcement learning research (especially at smaller institutions), many environments compliant with the API (Kidzinski et al., 2018; Leurent, 2018; Zamora et al., ´ 2016), and many RL libraries based around the API (Hill et al., 2018; Liang et al., 2018; Kuhnle et al., 2017). ",
+        "bbox": [
+            174,
+            757,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            214
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In the multiagent space, a similar level of fragmentation currently exists. Notable heterogenous sets of environments include OpenAI’s Competitive Multi-Agent Environments for competitive robotic control (Bansal et al., 2017), Sequential Social Dilemma Games for games where cooperation is difficult in a game theoretic sense (Leibo et al., 2017), RLCard for various card games Zha et al. (2019), MAgent for huge numbers of agents (Zheng et al., 2017), Multi-Particle Environments (”MPE\") for diverse agent roles (Mordatch and Abbeel, 2017; Lowe et al., 2017), the Starcraft Multi-Agent Challenge (Samvelyan et al., 2019), and dozens more. ",
+        "bbox": [
+            174,
+            222,
+            825,
+            319
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3 RELATED WORKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            343,
+            354,
+            359
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Two attempts at some level of unification in the multi-agent space have been made. The first is OpenSpiel, released by Deepmind in 2019 (Lanctot et al., 2019), which includes excellent implementations of 45 classic games under one sensible API. However, their framework is limited to supporting simple discrete games due to its modeling of games as trees (which is impractical to represent for more continuous environments such as Atari). However, in the space of discrete games it has managed to encourage high quality and fair evaluations of general game solving methods. ",
+        "bbox": [
+            174,
+            376,
+            825,
+            460
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The second is the multi-agent API of RLlib Liang et al. (2018), an ambitious distributed RL framework. While the API is powerful, it has very minimal feature support and cannot sensibly represent strictly turn based games (i.e. Hananbi or Go). However, we do maintain PettingZoo support within RLlib so that users can easily leverage the learning methods included on our environments. ",
+        "bbox": [
+            174,
+            467,
+            825,
+            523
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "4 DESIGN PHILOSOPHY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            547,
+            385,
+            564
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Simplicity and Similarity to Gym ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            580,
+            406,
+            595
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The ability for the Gym API to be near instantly understood has been a large driving factor in it’s widespread adoption. While a multi-agent API will inherently add complexity, we wanted to create a similarly simple API, and one that would be instantly familiar to researchers who have worked with Gym. ",
+        "bbox": [
+            174,
+            602,
+            825,
+            657
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Agent Environment Cycle Games Based API ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            665,
+            485,
+            680
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Most environments have APIs that model agents as all stepping at once (Lowe et al., 2017; Zheng et al., 2017; Gupta et al., 2017; Liu et al., 2019; Liang et al., 2018), based on the Partially Observable Stochastic Games (POSGs) model. It turns out this easily results in bugs (Terry et al., 2020b) and is undesirable for handling strictly turn-based games, like chess, since agents aren’t allowed to step simultaneously. We instead model our API after the new Agent Environment Cycle games model, an equivalent model where agents step sequentially. That is, an agent performs an action, the environment responds, the next agent acts, the environment responds again, and the cycle repeats. This model allows for the sensible interactions with both strictly turn based games like chess and games where agents truly step simultaneously. A POSG can be easily converted to an equivalent sequential game by having each agent take a step in a cycle, and then updating the rewards and observations of the AEC game at the end of a cycle. For a formal proof of equivalence see (Terry et al., 2020b). ",
+        "bbox": [
+            174,
+            686,
+            825,
+            853
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Variable Number of Agents ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            859,
+            366,
+            875
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We designed our API to robustly support the widest range of multi-agent scenarios possible, including agent generation and death. No general API currently supports this, but it is such an integral feature of so many environments that this support is essential. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Sufficient Configurability ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            352,
+            118
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We wanted to make environments that are highly configurable by arguments the norm. In Gym, environments are generally not configurable, and arguments at generation are not used at all. However, playing with various environment properties is often highly desirable, and has accordingly been embraced by Gym environments outside the official library, as this makes research easier and aids reproducibility. Accordingly, we tried to make every reasonable environment parameter an option for users in PettingZoo. ",
+        "bbox": [
+            173,
+            125,
+            825,
+            208
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "This notion of configuration extends beyond environment configuration to how learning methods interact with the environment. Due to the wide diversity of optimizations and different strategies applied for MARL, we wanted our API to allow for low level access to rewards, observations, done states and other info, while still being very simple for normal applications. Cyclically expansive curriculum learning from Terry et al. (2020b) is a good example of an interesting method that requires this sort of low level access. ",
+        "bbox": [
+            174,
+            215,
+            825,
+            299
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Quality of Life Improvements ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            306,
+            383,
+            320
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Being users of Gym ourselves, we sought to add several \"quality of life\" improvements in PettingZoo motivated by frustrations we faced as users. These are: ",
+        "bbox": [
+            174,
+            328,
+            823,
+            356
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "• Comprehensive, production-grade continuous integration testing. Testing in Gym is arguably lacking compared to other major libraries.   \nTests of environments for API compliance and proper functionality, both for end users and for continuous integration testing of the library. We also provide detailed recommendations for better practices, inspired by the well liked messages of the Rust compiler.   \nGood error messages and warnings. When using Gym, triggering an error yields a trace back that needs to be slowly decoded to find the actual problem. We added speciality error messages and warnings for all common errors (that we’re aware of) to make development and debugging easier. This is again inspired by the Rust compiler.   \nDetailed, comprehensive documentation. Documentation is a fundamental part of a userfriendly software library. Observation space, action space, reward schemes, and other notable environment details are something you generally need to know to begin conducting even the most basic research with an environment. One criticism of Gym is that almost all information is only found in the source code, something especially problematic when working with sets of environments. To solve this in PettingZoo, we created a user friendly wiki-styled website that clearly includes all relevant information for an environment, as well as general information for sets of environments. Our website also includes details about tests, comprehensive API documentation, and so on. This is discussed further in section 7. ",
+        "bbox": [
+            215,
+            367,
+            825,
+            637
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "5 API ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            659,
+            240,
+            674
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "5.1 MAIN API ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            690,
+            289,
+            704
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Per our discussion above, we sought to create a simple API that could encapsulate all games and be instantly understood to any Gym user, illustrated by comparing Figure 1 and Figure 2. We use the observation/action space objects from Gym, as well as the same seeding method because they are well designed and familiar to researchers. ",
+        "bbox": [
+            174,
+            717,
+            825,
+            772
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Figure 1: Basic Usage of Gym ",
+        "bbox": [
+            398,
+            786,
+            601,
+            801
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "import gym   \nenv $=$ gym.make(’CartPole-v0’)   \nobservation $=$ env.reset()   \nfor _ in range(1000): env.render() action $=$ policy(observation) observation, reward, done, info $=$ env.step(action)   \nenv.close() ",
+        "bbox": [
+            259,
+            814,
+            735,
+            915
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Figure 2: Basic Usage of PettingZoo ",
+        "bbox": [
+            377,
+            101,
+            620,
+            116
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "from pettingzoo.butterfly import pistonball_v0   \nenv $=$ pistonball_v0.env()   \nenv.reset()   \nfor agent in env.agent_iter(1000): env.render() observation, reward, done, info $=$ env.last() action $=$ policy(observation, agent) env.step(action)   \nenv.close() ",
+        "bbox": [
+            287,
+            126,
+            709,
+            241
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "5.2 PARALLEL API ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            265,
+            321,
+            280
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In addition to our main API, for certain environments we offer a separate API based off of the POSG model. It supports games and methods that assume this model very nicely. In style, it is very similar to RLlib’s multi-agent API (Liang et al., 2018), accepting and returning dictionaries keyed on agent names. The primary motivation for including this secondary API is because in games where it’s applicable, it can allow for parallelization features which can lead to large performance improvements. ",
+        "bbox": [
+            173,
+            292,
+            825,
+            376
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "5.3 ADDITIONAL API FEATURES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            393,
+            415,
+            407
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "While the API is elegant for simple cases, it’s still able to handle important edge cases. This is achieved through lower level API calls for specific attributes: rewards emitted at any time are included for every agent in the rewards dictionary attributes, and dones and infos dictionaries can similarly be used. We additionally have an observe(agent) function. render() and close() function identically to Gym for rendering environments being played by a policy. agents is a list of the names of all agents in the game, and due to considerations regarding variable numbers of agents possible_agents is an additional list attribute. Finally, observation_spaces and action_spaces are dictionaries of the Gym observation/action spaces for all agents in possible_agents. ",
+        "bbox": [
+            174,
+            420,
+            825,
+            545
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "When an agent dies, its done is set to True, it will become the next selected agent to act, and the action taken is required to be None. After this dummy step is taken, the agent will be removed from agents and all dictionary attributes. Note than a whole environment is done if and only if agents is empty. Agent generation can be implemented by simply adding an agent to the agents list and allowing its rewards and observations to be accessed. ",
+        "bbox": [
+            174,
+            553,
+            825,
+            622
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Finally, environment configuration is handled by passing arguments to the .env() constructor, a standard that all third-party Gym environments have adapted. These arguments can fundamentally change environment behavior, such as the number of agents, the reward structure, and even its action and observation spaces. All environments in PettingZoo allow for some degree of customization in this manner, with many allowing quite a bit. ",
+        "bbox": [
+            174,
+            630,
+            825,
+            699
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "5.4 IMPLEMENTING AN ENVIRONMENT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            718,
+            455,
+            732
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Compliant environments inherit from a general class (AECEnv). To allow for sufficient flexibility, environments only expose lower level attributes (dictionaries of values for all agents — dones, infos, rewards) and an observe method that takes an agent. These are then wrapped to provide the more general functions you see above by the base class. This low level functionality allows for entirely new APIs to be efficiently added on top of PettingZoo environments should the need arise. We’ve done this ourselves with the secondary parallel POSG based API, which have wrappers that convert both to and from the parallel and standard APIs. ",
+        "bbox": [
+            174,
+            743,
+            826,
+            842
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "6 ENVIRONMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            863,
+            343,
+            878
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Similar to Gym, we wanted to include popular and interesting environments within one package, in an easily usable format. Half of the environment classes we include (MPE, MAgent, and SISL), ",
+        "bbox": [
+            174,
+            895,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/a9b02e128eced92955f661e47951b0e0b1815a7263f73d2e088a212111264a40.jpg",
+        "image_caption": [
+            "Figure 3: Example Environments From Each Class "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            256,
+            127,
+            761,
+            601
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "(e) MPE: Simple Adversary ",
+        "bbox": [
+            250,
+            613,
+            416,
+            627
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "despite their popularity, have previously only existed as unmaintained “research grade” code, have not been available for installation via pip, have required large amounts of maintenance to run at all, and have required large amounts of debugging, code review, code cleanup and documentation to bring to a production-grade state. The Multi-Agent Atari and Butterfly classes are new environments that we believe pose important and novel challenges to multi-agent reinforcement learning. Finally, we include the Classic class — classic board and card games popular within the RL literature. ",
+        "bbox": [
+            174,
+            686,
+            825,
+            770
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Atari ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            777,
+            214,
+            791
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Atari games represent the single most popular and iconic class of benchmarks in reinforcement learning. Recently, a multi-agent fork of the Atari Learning Environment was created that allows programmatic control and reward collection of Atari’s iconic multi-player games (Terry and Black, 2020). As in the single player Atari environments, the observation is the rendered frame of the game, which is shared between all agents, so there is no partial observability. Most of these games have competitive or mixed reward structures, making them suitable for general study of adversarial and mixed reinforcement learning. In particular, Terry and Black (2020) categorizes the games into 7 different types: 1v1 tournament games, mixed sum survival games (Space Invaders, shown in Figure 3a. is an example of this), competitive racing games, long term strategy games, 2v2 tournament games, a four-player free-for-all game and a cooperative game. For easy ROM installation, AutoROM, a separate PyPI package, can be used to easily install the needed Atari ROMs in an automated manner. ",
+        "bbox": [
+            174,
+            799,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Butterfly ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            140,
+            238,
+            154
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Of all the environments included, the majority of them are competitive. We wanted to supplement this with a set of interesting graphical cooperative environments. Pistonball, depicted in Figure 3b, where the pistons need to coordinate to move the ball to the left, while only being able to observe a local part of the screen, requires learning nontrivial emergent behavior and indirect communication to perform well. Knights Archers Zombies is a game in which players work together to defeat approaching zombies before they can reach the players. It is designed to be a fast paced graphically interesting combat game with partial observability and heterogeneous agents, where achieving good performance requires extraordinarily high levels of agent coordination. Cooperative pong, where two dissimilar paddles work together to keep the ball in play as long as possible, was intended to be a be very simple cooperative continuous control-type task, with heterogeneous agents. Prison was designed to be the simplest possible game in MARL, and to be used as a debugging tool. Prospector was included to intentionally be a very challenging game for conventional methods—it has two classes of agents, with different goals, action spaces, and observation spaces (something many current cooperative MARL algorithms struggle with), and has very sparse rewards (something all RL algorithms struggle with). It is intended to be an very difficult benchmark for MARL, in the same vein of Montezuma’s Revenge. ",
+        "bbox": [
+            174,
+            161,
+            825,
+            381
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Classic ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            388,
+            225,
+            404
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Classical board and card games have long been some of the most popular environments in reinforcement learning (Tesauro, 1995; Silver et al., 2016; Bard et al., 2019). We include all of the standard multiplayer games in RLCard (Zha et al., 2019): Dou Dizhu, Gin Rummy, Leduc Hold’em, Limit Texas Hold’em, Mahjong, No-limit Texas Hold’em, and Uno. We additionally include all AlphaZero games, using the same observation and action spaces—Chess and Go. We finally included Backgammon, Connect Four, Checkers, Rock Paper Scissors, Rock Paper Scissors Lizard Spock, and Tic Tac Toe to add a diverse set of simple, popular games to allow for more robust benchmarking of RL methods. ",
+        "bbox": [
+            174,
+            410,
+            826,
+            508
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "MAgent ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            515,
+            233,
+            530
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The MAgent library, from Zheng et al. (2017) was introduced as a configurable and scalable environment that could support thousands of interactive agents. These environments have mostly been studied as a setting for emergent behavior (Pokle, 2018), heterogeneous agents (Subramanian et al., 2020), and efficient learning methods with many agents (Chen et al., 2019). We include a number of preset configurations, for example the Adversarial Pursuit environment shown in Figure 3d. We make a few changes to the preset configurations used in the original MAgent paper. The global \"minimap\" observations in the battle environment are turned off by default, requiring implicit communication between the agents for complex emergent behavior to occur. The rewards in Gather and Tiger-Deer are also slightly changed to prevent emergent behavior from being a direct result of the reward structure. ",
+        "bbox": [
+            174,
+            536,
+            825,
+            675
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "MPE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            683,
+            212,
+            695
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The Multi-Agent Particle Environments (MPE) were introduced as part of Mordatch and Abbeel (2017) and first released as part of Lowe et al. (2017). These are 9 communication oriented environments where particle agents can (sometimes) move, communicate, see each other, push each other around, and interact with fixed landmarks. Environments are cooperative, competitive, or require team play. They have been popular in research for general MARL methods Lowe et al. (2017), emergent communication (Mordatch and Abbeel, 2017), team play (Palmer, 2020), and much more. As part of their inclusion in PettingZoo, we converted the action spaces to a discrete space which is the Cartesian product of the movement and communication action possibilities. We also added comprehensive documentation, parameterized any local reward shaping (with the default setting being the same as in Lowe et al. (2017)), and made a single render window which captures all the activities of all agents (including communication), making it easier to visualize. ",
+        "bbox": [
+            174,
+            704,
+            826,
+            856
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "SISL ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            864,
+            210,
+            877
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We finally included the three cooperative environments introduced in Gupta et al. (2017): Pursuit, Waterworld, and Multiwalker. Pursuit is a standard pursuit-evasion game Vidal et al. (2002) where pursuers and controlled in a randomly generated map. Pursuer agents are rewarded for capturing randomly generated evaders by surrounding them on all sides. Waterworld is a continuous control game where the pursuing agents cooperatively hunt down food targets while trying to avoid poison targets. Multiwalker (Figure 3f) is a more challenging continuous control task that is based on Gym’s BipedalWalker environment. In Multiwalker, a package is placed on three independently controlled robot legs. Each robot is given a small positive reward for every unit of forward horizontal movement of the package, while they receive a large penalty for dropping the package. ",
+        "bbox": [
+            174,
+            886,
+            825,
+            912
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            202
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "7 DOCUMENTATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            222,
+            354,
+            237
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Documentation is a fundamental part of a user-friendly software library. There’s a tremendous amount of useful information about these environments, especially due to their diversity, so we sought to create as detailed documentation as possible, while designing it in a way to ensure it’s still useful and approachable. PettingZoo includes comprehensive documentation for the API, the continuous integration tests, and each environment. A majority of popular libraries do not have extensive documentation. For example, OpenAI’s popular Gym library only lists the observation space shape on each environment’s documentation page. PettingZoo’s documentation thoroughly explains each environment’s observation and action spaces, and includes relevant information to help researchers. The goal is to allow people to compare environments easily, and for developers to very rarely need to refer to source. ",
+        "bbox": [
+            174,
+            252,
+            825,
+            391
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Our design for displaying so much information was inspired by Wikipedia’s familiar and well-known layout. This is illustrated in Figure 4. All documentation is included in the supplemental materials to facilitate anonymous review. ",
+        "bbox": [
+            174,
+            398,
+            825,
+            440
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/65c3896c46cc6a5513b1379dc1ff0e650eff5b67976670bb54346138584a2bef.jpg",
+        "image_caption": [
+            "Figure 4: The beginning PettingZoo documentation for the Go environment, illustrating how we used the design metaphor of a Wikipedia page to include a large amount of detail in a manner that isn’t overwhelming "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            334,
+            454,
+            656,
+            784
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "8 BASELINES",
+        "text_level": 1,
+        "bbox": [
+            176,
+            864,
+            300,
+            880
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "All environments implemented in PettingZoo include baselines to provide a general sense of the difficulty of the environment, and for something to initially compare against. We do this here for the ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Butterfly environments that this library introduces for the first time; similar baselines exist in the papers introducing all other environments. We used parameter sharing (Terry et al., $2 0 2 0 \\mathrm { c }$ ; Gupta et al., 2017) with Ape-X DQN (Horgan et al., 2018), with RLLib (Liang et al., 2018). Our results are shown in Figure 5. Preprocessing and hyperparameter details are included in Appendix A. All preprocessing was done with the SuperSuit wrapper library (Terry et al., 2020a), which has recently added support for PettingZoo based multi-agent environments based. Code for the environments, training logs, and saved policies are available at https://github.com/pettingzoopaper/ pettingzoopaper. ",
+        "bbox": [
+            173,
+            103,
+            826,
+            215
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/78f54dc3d5e43fd64d01736df70d1bcbc1373c913c6dbfeaa93b6e82297c602b.jpg",
+        "image_caption": [
+            "Figure 5: Total reward when learning on each Butterfly environment via parameter shared Ape-X DQN (a-d) and parameter shared PPO (e). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            227,
+            820,
+            665
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "9 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            737,
+            318,
+            753
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "This paper introduces PettingZoo, a Python library of many diverse multi-agent reinforcement learning environments under one simple API, akin to a multi-agent version of OpenAI’s Gym library. ",
+        "bbox": [
+            174,
+            768,
+            823,
+            797
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Reinforcement learning systems have two main components, the environment and the agent(s) that learn. Without a standardized environment base, research progresses by designing and building both the environment and the agent (as has been the case for MARL). The main contribution of PettingZoo is that it enables more research which focuses on agents by standardizing and democratizing the environments. We hope that this allows for research in multi-agent reinforcement learning to accelerate and flourish. ",
+        "bbox": [
+            174,
+            804,
+            825,
+            888
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We’re aware of two notable limitations of PettingZoo. The first is that games with significantly more than 10,000 agents (or potential agents) will have meaningful performance issues. This arises from needing to prespecify observation/action spaces and potential agent names. We view this as a practically acceptable limitation. The second notable limitation is that PettingZoo does not currently allow users to access the global environment state, a feature required by some centralized critic methods. We’re actively working on supporting this via a .state() method. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            159
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We see three obvious directions for future work. The first is additions of more interesting environments under our API (possibly from by the community, as has happened with Gym). While we’ve included a large number of environments, there are additional sets that would be valuable to include: the open-source implementations of social sequential dilemma games (Vinitsky et al., 2019), and the StarCraft 2 Multi-Agent Challenge (“SMAC“) environments (Samvelyan et al., 2019). The second direction we envision is a service to allow different researchers’ agents to play against each other in competitive games, leveraging the standardized API and environment set. Finally, we envision the development of procedurally generated multi-agent environments to test how well methods generalize, akin to the Gym procgen environments. (Cobbe et al., 2019). ",
+        "bbox": [
+            174,
+            166,
+            825,
+            291
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            309,
+            326,
+            321
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Thank you to Deepthi Raghunandan and Kevin Hogan for many helpful discussions surrounding what testing should look like. Thank you to Nathaniel Grammel for many helpful discussions in the early planning stages of the project. Thank you to Ross Allen and his group for reporting numerous bugs. ",
+        "bbox": [
+            176,
+            332,
+            825,
+            375
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            397,
+            285,
+            411
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Trapit Bansal, Jakub Pachocki, Szymon Sidor, Ilya Sutskever, and Igor Mordatch. Emergent complexity via multi-agent competition. CoRR, abs/1710.03748, 2017. URL http://arxiv.org/ abs/1710.03748. ",
+        "bbox": [
+            176,
+            420,
+            826,
+            462
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Nolan Bard, Jakob N. Foerster, Sarath Chandar, Neil Burch, Marc Lanctot, H. Francis Song, Emilio Parisotto, Vincent Dumoulin, Subhodeep Moitra, Edward Hughes, Iain Dunning, Shibl Mourad, Hugo Larochelle, Marc G. Bellemare, and Michael Bowling. The hanabi challenge: A new frontier for AI research. CoRR, abs/1902.00506, 2019. URL http://arxiv.org/abs/ 1902.00506. ",
+        "bbox": [
+            173,
+            472,
+            826,
+            542
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Marc G Bellemare, Yavar Naddaf, Joel Veness, and Michael Bowling. The arcade learning environment: An evaluation platform for general agents. Journal of Artificial Intelligence Research, 47: 253–279, 2013. ",
+        "bbox": [
+            173,
+            553,
+            823,
+            594
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Greg Brockman, Vicki Cheung, Ludwig Pettersson, Jonas Schneider, John Schulman, Jie Tang, and Wojciech Zaremba. Openai gym. arXiv preprint arXiv:1606.01540, 2016. ",
+        "bbox": [
+            171,
+            606,
+            825,
+            635
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Y. Chen, M. Zhou, Ying Wen, Y. Yang, Y. Su, W. Zhang, Dell Zhang, J. Wang, and Han Liu. Factorized q-learning for large-scale multi-agent systems. In DAI ’19, 2019. ",
+        "bbox": [
+            176,
+            643,
+            823,
+            674
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Karl Cobbe, Christopher Hesse, Jacob Hilton, and John Schulman. Leveraging procedural generation to benchmark reinforcement learning. arXiv preprint arXiv:1912.01588, 2019. ",
+        "bbox": [
+            174,
+            684,
+            820,
+            713
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ben Goodrich. ale_python_interface. https://github.com/bbitmaster/ale_python_ interface, 2015. GitHub repository. ",
+        "bbox": [
+            174,
+            723,
+            821,
+            752
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jayesh K Gupta, Maxim Egorov, and Mykel Kochenderfer. Cooperative multi-agent control using deep reinforcement learning. In International Conference on Autonomous Agents and Multiagent Systems, pages 66–83. Springer, 2017. ",
+        "bbox": [
+            174,
+            762,
+            825,
+            804
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ashley Hill, Antonin Raffin, Maximilian Ernestus, Adam Gleave, Anssi Kanervisto, Rene Traore, Prafulla Dhariwal, Christopher Hesse, Oleg Klimov, Alex Nichol, Matthias Plappert, Alec Radford, John Schulman, Szymon Sidor, and Yuhuai Wu. Stable baselines. https://github.com/ hill-a/stable-baselines, 2018. ",
+        "bbox": [
+            174,
+            814,
+            826,
+            869
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Dan Horgan, John Quan, David Budden, Gabriel Barth-Maron, Matteo Hessel, Hado van Hasselt, and David Silver. Distributed prioritized experience replay. CoRR, abs/1803.00933, 2018. URL http://arxiv.org/abs/1803.00933. ",
+        "bbox": [
+            176,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Łukasz Kidzinski, Sharada P Mohanty, Carmichael Ong, Jennifer Hicks, Sean Francis, Sergey Levine, ´ Marcel Salathé, and Scott Delp. Learning to run challenge: Synthesizing physiologically accurate motion using deep reinforcement learning. In Sergio Escalera and Markus Weimer, editors, NIPS 2017 Competition Book. Springer, Springer, 2018. ",
+        "bbox": [
+            174,
+            103,
+            826,
+            160
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alexander Kuhnle, Michael Schaarschmidt, and Kai Fricke. Tensorforce: a tensorflow library for applied reinforcement learning. Web page, 2017. URL https://github.com/ tensorforce/tensorforce. ",
+        "bbox": [
+            174,
+            170,
+            826,
+            212
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Marc Lanctot, Edward Lockhart, Jean-Baptiste Lespiau, Vinícius Flores Zambaldi, Satyaki Upadhyay, Julien Pérolat, Sriram Srinivasan, Finbarr Timbers, Karl Tuyls, Shayegan Omidshafiei, Daniel Hennes, Dustin Morrill, Paul Muller, Timo Ewalds, Ryan Faulkner, János Kramár, Bart De Vylder, Brennan Saeta, James Bradbury, David Ding, Sebastian Borgeaud, Matthew Lai, Julian Schrittwieser, Thomas W. Anthony, Edward Hughes, Ivo Danihelka, and Jonah Ryan-Davis. Openspiel: A framework for reinforcement learning in games. CoRR, abs/1908.09453, 2019. URL http://arxiv.org/abs/1908.09453. ",
+        "bbox": [
+            174,
+            222,
+            826,
+            319
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Joel Z. Leibo, Vinícius Flores Zambaldi, Marc Lanctot, Janusz Marecki, and Thore Graepel. Multiagent reinforcement learning in sequential social dilemmas. CoRR, abs/1702.03037, 2017. URL http://arxiv.org/abs/1702.03037. ",
+        "bbox": [
+            173,
+            328,
+            823,
+            371
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Edouard Leurent. An environment for autonomous driving decision-making. https://github. com/eleurent/highway-env, 2018. ",
+        "bbox": [
+            171,
+            380,
+            825,
+            409
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Eric Liang, Richard Liaw, Robert Nishihara, Philipp Moritz, Roy Fox, Ken Goldberg, Joseph E. Gonzalez, Michael I. Jordan, and Ion Stoica. RLlib: Abstractions for distributed reinforcement learning. In International Conference on Machine Learning (ICML), 2018. ",
+        "bbox": [
+            176,
+            417,
+            823,
+            460
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Siqi Liu, Guy Lever, Josh Merel, Saran Tunyasuvunakool, Nicolas Heess, and Thore Graepel. Emergent coordination through competition. CoRR, abs/1902.07151, 2019. URL http:// arxiv.org/abs/1902.07151. ",
+        "bbox": [
+            174,
+            469,
+            826,
+            512
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ryan Lowe, Yi Wu, Aviv Tamar, Jean Harb, Pieter Abbeel, and Igor Mordatch. Multi-agent actorcritic for mixed cooperative-competitive environments. Neural Information Processing Systems (NIPS), 2017. ",
+        "bbox": [
+            174,
+            522,
+            826,
+            564
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A Rusu, Joel Veness, Marc G Bellemare, Alex Graves, Martin Riedmiller, Andreas K Fidjeland, Georg Ostrovski, et al. Human-level control through deep reinforcement learning. nature, 518(7540):529–533, 2015. ",
+        "bbox": [
+            174,
+            573,
+            826,
+            616
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Igor Mordatch and Pieter Abbeel. Emergence of grounded compositional language in multi-agent populations. arXiv preprint arXiv:1703.04908, 2017. ",
+        "bbox": [
+            171,
+            626,
+            823,
+            654
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "OpenAI. Openai five. https://blog.openai.com/openai-five/, 2018. ",
+        "bbox": [
+            173,
+            664,
+            722,
+            679
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "G. Palmer. Independent learning approaches: Overcoming multi-agent learning pathologies in team-games. 2020. ",
+        "bbox": [
+            174,
+            688,
+            825,
+            717
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Stefanie Anna Baby Ling Li Ashwini Pokle. Analysis of emergent behavior in multi agent environments using deep reinforcement learning. 2018. ",
+        "bbox": [
+            173,
+            726,
+            825,
+            755
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Mikayel Samvelyan, Tabish Rashid, Christian Schröder de Witt, Gregory Farquhar, Nantas Nardelli, Tim G. J. Rudner, Chia-Man Hung, Philip H. S. Torr, Jakob N. Foerster, and Shimon Whiteson. The starcraft multi-agent challenge. CoRR, abs/1902.04043, 2019. URL http://arxiv.org/ abs/1902.04043. ",
+        "bbox": [
+            174,
+            763,
+            826,
+            819
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "David Silver, Aja Huang, Chris J Maddison, Arthur Guez, Laurent Sifre, George Van Den Driessche, Julian Schrittwieser, Ioannis Antonoglou, Veda Panneershelvam, Marc Lanctot, et al. Mastering the game of go with deep neural networks and tree search. nature, 529(7587):484–489, 2016. ",
+        "bbox": [
+            176,
+            829,
+            825,
+            872
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "David Silver, Julian Schrittwieser, Karen Simonyan, Ioannis Antonoglou, Aja Huang, Arthur Guez, Thomas Hubert, Lucas Baker, Matthew Lai, Adrian Bolton, et al. Mastering the game of go without human knowledge. nature, 550(7676):354–359, 2017. ",
+        "bbox": [
+            176,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sriram Ganapathi Subramanian, P. Poupart, Matthew E. Taylor, and N. Hegde. Multi type mean field reinforcement learning. In AAMAS, 2020. ",
+        "bbox": [
+            171,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Justin K Terry and Benjamin Black. Multiplayer support for the arcade learning environment. arXiv preprint arXiv:2009.09341, 2020. ",
+        "bbox": [
+            171,
+            141,
+            823,
+            170
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Justin K Terry, Benjamin Black, and Ananth Hari. Supersuit: Simple microwrappers for reinforcement learning environments. arXiv preprint arXiv:2008.08932, 2020a. ",
+        "bbox": [
+            173,
+            179,
+            823,
+            208
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Justin K Terry, Nathaniel Grammel, Benjamin Black, Ananth Hari, Luis Santos, and Caroline Horsch. Agent environment cycle games. arXiv preprint arXiv:2009.13051, 2020b. ",
+        "bbox": [
+            171,
+            215,
+            825,
+            246
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Justin K Terry, Nathaniel Grammel, Ananth Hari, Luis Santos, and Benjamin Black. Revisiting parameter sharing in multi-agent deep reinforcement learning. arXiv preprint arXiv:2005.13625, 2020c. ",
+        "bbox": [
+            173,
+            253,
+            825,
+            296
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Gerald Tesauro. Temporal difference learning and td-gammon. Commun. ACM, 38(3):58–68, March 1995. ISSN 0001-0782. doi: 10.1145/203330.203343. URL https://doi.org/10.1145/ 203330.203343. ",
+        "bbox": [
+            174,
+            306,
+            825,
+            348
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Rene Vidal, Omid Shakernia, H Jin Kim, David Hyunchul Shim, and Shankar Sastry. Probabilistic pursuit-evasion games: theory, implementation, and experimental evaluation. IEEE transactions on robotics and automation, 18(5):662–669, 2002. ",
+        "bbox": [
+            173,
+            357,
+            826,
+            400
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Eugene Vinitsky, Natasha Jaques, Joel Leibo, Antonio Castenada, and Edward Hughes. An open source implementation of sequential social dilemma games. https://github.com/ eugenevinitsky/sequential_social_dilemma_games/, 2019. GitHub repository. ",
+        "bbox": [
+            174,
+            410,
+            826,
+            452
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Oriol Vinyals, Igor Babuschkin, Wojciech M Czarnecki, Michaël Mathieu, Andrew Dudzik, Junyoung Chung, David H Choi, Richard Powell, Timo Ewalds, Petko Georgiev, et al. Grandmaster level in starcraft ii using multi-agent reinforcement learning. Nature, 575(7782):350–354, 2019. ",
+        "bbox": [
+            173,
+            460,
+            826,
+            503
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Iker Zamora, Nestor Gonzalez Lopez, Victor Mayoral Vilches, and Alejandro Hernandez Cordero. Extending the openai gym for robotics: a toolkit for reinforcement learning using ros and gazebo. arXiv preprint arXiv:1608.05742, 2016. ",
+        "bbox": [
+            176,
+            512,
+            825,
+            554
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Daochen Zha, Kwei-Herng Lai, Yuanpu Cao, Songyi Huang, Ruzhe Wei, Junyu Guo, and Xia Hu. Rlcard: A toolkit for reinforcement learning in card games. arXiv preprint arXiv:1910.04376, 2019. ",
+        "bbox": [
+            173,
+            564,
+            825,
+            606
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Lianmin Zheng, Jiacheng Yang, Han Cai, Weinan Zhang, Jun Wang, and Yong Yu. Magent: A many-agent reinforcement learning platform for artificial collective intelligence. arXiv preprint arXiv:1712.00600, 2017. ",
+        "bbox": [
+            173,
+            614,
+            825,
+            657
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A BASELINE EXPERIMENT HYPERPARAMETERS AND PREPROCESSING ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            684,
+            771,
+            700
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "All of the environments were preprocessed in the following way: observations were resized to 84x84 images with linear interpolation, converted to grayscale, then normalized. This preprocessing was performed with SuperSuit (Terry et al., 2020a). ",
+        "bbox": [
+            174,
+            715,
+            825,
+            758
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "The graphically subtle environments (Knights Archers Zombies, Prospector and Cooperative Pong) had their observations processed with the RLlib default network: A convolutional layer with a $8 \\mathrm { x } 8$ kernel, stride of 4, and 16 filters, followed by a convolutional layer with a 4x4 kernel, stride of 2, and 32 filters, followed by a convolutional layer with n 11x11 kernel, stride of 1, and 256 filters. ",
+        "bbox": [
+            174,
+            765,
+            825,
+            820
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "The graphically simple environments (Prison, Pistonball) were resized to $3 2 \\mathrm { x } 3 2 $ and flattened in addition to the above preprocessing. The observation was processed with a network with two hidden linear layers, 400 and 300 neurons wide, respectively. ",
+        "bbox": [
+            174,
+            827,
+            823,
+            871
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "table",
+        "img_path": "images/52c152e8848a769588faab322facfb3559767d7615f0fe1ae03e7afd67af5b9a.jpg",
+        "table_caption": [
+            "Table 1: Hyperparameters for ApeX DQN and PPO on each Butterfly environment. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>RL method</td><td>Hyperparameter</td><td>Value</td></tr><tr><td>ApeX-DQN</td><td>adam_epsilon</td><td>0.00015</td></tr><tr><td></td><td>buffer_size</td><td>400000</td></tr><tr><td></td><td>double_q</td><td>True</td></tr><tr><td></td><td>dueling</td><td>True</td></tr><tr><td></td><td>epsilon_timesteps</td><td>200000</td></tr><tr><td></td><td>final_epsilon</td><td>0.01</td></tr><tr><td></td><td>final_prioritized_replay_beta</td><td>1.0</td></tr><tr><td></td><td>gamma</td><td>0.99</td></tr><tr><td></td><td>learning_starts</td><td>10000</td></tr><tr><td></td><td>lr</td><td>0.0001</td></tr><tr><td></td><td>n_step</td><td>3</td></tr><tr><td></td><td>num_atoms</td><td>1</td></tr><tr><td></td><td>num_envs_per_worker</td><td>4</td></tr><tr><td></td><td>num_gpus</td><td>1</td></tr><tr><td></td><td>num_workers</td><td>12</td></tr><tr><td></td><td>prioritized_replay</td><td>True</td></tr><tr><td></td><td>prioritized_replay_alpha</td><td>0.5</td></tr><tr><td></td><td>prioritized_replay_beta</td><td>0.4</td></tr><tr><td></td><td>prioritized_replay_beta_annealing_timesteps</td><td>2000000</td></tr><tr><td></td><td>rollout_fragment_length</td><td>32</td></tr><tr><td></td><td>target_network_update_freq</td><td>10000</td></tr><tr><td></td><td>timesteps_per_iteration</td><td>15000</td></tr><tr><td></td><td>train_batch_size</td><td>512</td></tr><tr><td>PPO</td><td>gamma</td><td>0.99</td></tr><tr><td></td><td>num_envs_per_worker</td><td>4</td></tr><tr><td></td><td>num_gpus</td><td>1</td></tr><tr><td></td><td>num_workers</td><td>12</td></tr><tr><td></td><td>compress_observations</td><td>False</td></tr><tr><td></td><td>lambda</td><td>0.95</td></tr><tr><td></td><td>kl_coeff</td><td>0.5</td></tr><tr><td></td><td>clip_rewards</td><td>True</td></tr><tr><td></td><td>clip_param</td><td>0.1</td></tr><tr><td></td><td>vf_clip_param</td><td>10.0</td></tr><tr><td></td><td>entropy_coeff</td><td>0.01</td></tr><tr><td></td><td>train_batch_size</td><td>5000</td></tr><tr><td></td><td>sample_batch_size</td><td>25</td></tr><tr><td></td><td>sgd_minibatch_size</td><td>256</td></tr><tr><td></td><td>num_sgd_iter</td><td>100</td></tr><tr><td></td><td>batch_mode</td><td>truncate_episodes</td></tr><tr><td></td><td>vf_share_layers</td><td>True</td></tr></table>",
+        "bbox": [
+            173,
+            194,
+            923,
+            800
+        ],
+        "page_idx": 11
+    }
+]

parse/train/jlgCDIrAv0_/jlgCDIrAv0_.md

@@ -0,0 +1,403 @@
+# When should agents explore?
+
+Anonymous Author(s)   
+Affiliation   
+Address   
+email
+
+# Abstract
+
+1 Exploration remains a central challenge for reinforcement learning (RL). Virtually   
+2 all existing methods share the feature of a monolithic behaviour policy that changes   
+3 only gradually (at best). In contrast, the exploratory behaviours of animals and hu  
+4 mans exhibit a rich diversity, namely including forms of switching between modes.   
+5 This paper presents an initial study of mode-switching, non-monolithic exploration   
+6 for RL. We investigate different modes to switch between, at what timescales it   
+7 makes sense to switch, and what signals make for good switching triggers. We   
+8 also propose practical algorithmic components that make the switching mechanism   
+9 adaptive and robust, which enables flexibility without an accompanying hyper  
+10 parameter-tuning burden. Finally, we report a promising and detailed analysis on   
+11 Atari, using two-mode exploration and switching at sub-episodic time-scales.
+
+# 12 1 Introduction
+
+13 The trade-off between exploration and exploitation is described as the crux of learning and behaviour   
+14 across many domains, not just reinforcement learning [Sutton and Barto, 2018], but also in decision   
+15 making [Cohen et al., 2007], evolutionary biology [Cremer et al., 2019], ecology [Kembro et al.,   
+16 2019], neuroscience (e.g., focused versus diffuse search in visual attention [Wolfe et al., 1989],   
+17 dopamine regulations [Chakroun et al., 2020]), cognitive sciences [Hills et al., 2015], as well as   
+18 psychology and psychiatry [Addicott et al., 2017]. In a nutshell, exploration is about the balance   
+19 between taking the familiar choice that is known to be rewarding and learning about unfamiliar   
+20 options of uncertain reward, but which could ultimately be more valuable than the familiar options.   
+21 Ample literature has studied the question of how much to explore, that is how to set the overall   
+22 trade-off (and how to adjust it over the course of learning) [Jaksch et al., 2010, Cappé et al., 2013,   
+23 Lattimore and Szepesvári, 2020, Thrun, 1992], and the question of how to explore, namely how   
+24 to choose exploratory actions (e.g., randomly, optimistically, intrinsically motivated, or otherwise)   
+25 [Schmidhuber, 1991, Oudeyer and Kaplan, 2009, Linke et al., 2019]. In contrast, the question of when   
+26 to explore has been studied very little, possibly because it does not arise in bandit problems, where a   
+27 lot of exploration methods are rooted. The ‘when’ question and its multiple facets are the subjects of   
+28 this paper. We believe that addressing it could lead to more intentional forms of exploration.   
+29 Consider an agent that has access to two modes of behaviour, an ‘explore’ mode and an ‘exploit’   
+30 mode (e.g., a random policy and a greedy policy, as in $\varepsilon$ -greedy). Even when assuming that the   
+31 overall proportion of exploratory steps is fixed, the agent still has multiple degrees of freedom: it   
+32 can explore more at the beginning of training and less in later phases; it may take single exploratory   
+33 steps or execute prolonged periods of exploration; it may prefer exploratory steps early or late within   
+34 an episode; and it could trigger the onset (or end) of an exploratory period based on various criteria.   
+35 Animals and humans exhibit non-trivial behaviour in all of these dimensions, presumably encoding   
+36 useful inductive biases that way [Power, 1999]. Humans make use of multiple effective strategies,   
+37 such as selectively exploring options with high uncertainty (a form of directed, or information-seeking   
+38 exploration), and increasing the randomness of their choices when they are more uncertain [Gershman,   
+39 2018, Gershman and Tzovaras, 2018, Ebitz et al., 2019]. Monkeys use directed exploration to manage   
+40 explore-exploit trade-offs, and these signals are coded in motivational brain regions [Costa et al.,   
+41 2019]. Patients with schizophrenia register changes in directed exploration and experience low-grade   
+42 inflammation when shifting from exploitation to random exploration [Waltz et al., 2020, Cathomas   
+43 et al., 2021]. This diversity is what motivates us to study which of these can benefit RL agents in turn,   
+44 by expanding the class of exploratory behaviours beyond the commonly used monolithic ones (where   
+45 modes are merged homogeneously in time).
+
+# 46 2 Methods
+
+47 The objective of an RL agent is to learn a policy that maximises external reward. At the high level,   
+48 it achieves this by interleaving two processes: generating new experience by interacting with the   
+49 environment using a behaviour policy (exploration) and updating its policy using this experience   
+50 (learning). As RL is applied to increasingly ambitious tasks, the challenge for exploration becomes   
+51 to keep producing diverse experience, because if something has not been encountered, it cannot be   
+52 learned. Our central argument is therefore simple: a monolithic, time-homogeneous behaviour policy   
+53 is strictly less diverse than a heterogeneous mode-switching one, and the former may hamstring   
+54 the agent’s performance. As an illustrative example, consider a human learning how to ride a bike   
+55 (explore), while maintaining their usual happiness through food, sleep, work (exploit): there is a stark   
+56 contrast between a monolithic, time-homogeneous behaviour that interleaves a twist of the handlebar   
+57 or a turn of a pedal once every few minutes or so, and the mode-switching behaviour that dedicates   
+58 prolonged periods of time exclusively to acquiring the new skill of cycling.
+
+# 59 2.1 Exploration modes
+
+60 While the choice of behaviour in pure exploit mode is straightforward, namely the greedy pursuit   
+of external reward (or best guess thereof), denoted by $\mathcal { G }$ , there are numerous viable choices for   
+62 behaviour in a pure explore mode (denoted by $\mathcal { X }$ ). In this paper we consider two standard ones:   
+63 $\mathcal { X } _ { U }$ , the naive uniform random policy, and $\mathcal { X } _ { I }$ , an intrinsically motivated behaviour that exclusively   
+64 pursues a novelty measure based on random network distillation (RND, [Burda et al., 2018]). See   
+65 Section 4 and Appendix B for additional possibilities of $\mathcal { X }$ . In this paper we choose fixed behaviours   
+66 for these modes, and focus solely on the question of when to switch between them. In our setting,   
+67 overall proportion of exploratory steps (the how much), denoted by $p _ { \mathcal { X } }$ , is not directly controlled but   
+68 derives from the when.
+
+# 2.2 Granularity
+
+An exploration period is an uninterrupted sequence of steps in explore mode. We consider four choices of temporal granularity for exploratory periods, also illustrated on Figure 1:
+
+Step-level exploration is the most common scenario, where the decision to explore is taken independently at each step, affecting one action.1 The canonical example is $\varepsilon$ -greedy (Fig.1:C).
+
+Experiment-level exploration is the other extreme, where all behaviour during training is produced in explore mode, and learning is off-policy (the greedy policy is only used for evaluation). This scenario is also very common, with most forms of intrinsic motivation falling into this category, namely pursuing reward with an intrinsic bonus throughout training (Fig.1:A).2
+
+Episode-level exploration is the case where the mode is fixed for an entire episode at a time (e.g., training games versus tournament matches in a sport), see Fig.1:B. This has been investigated for simple cases, where the policy’s level of stochasticity is sampled at the beginning of each episode [Horgan et al., 2018, Kapturowski et al., 2019, Zha et al., 2021].
+
+Intra-episodic exploration is what falls in-between step- and episode-level exploration, where exploration periods last for multiple steps, but less than a full episode. This is the least commonly studied scenario, and will form the bulk of our investigations (Fig.1:D,E,F,G).
+
+![](images/8c0dc4b02ecfa1c683fbb2be16c7afbac87ee7c5ef3e2ee1fb1d100e51c4cb1d.jpg)  
+Figure 1: Illustration of different types of temporal structure for two-mode exploration. Left: Each line A-G depicts an excerpt of an experiment (black lines show episode boundaries, experiment continues on the right), with colour denoting the active mode (blue is exploit, magenta is explore). A is of experiment-level granularity, $\mathbf { B }$ episode-level, $\mathbf { C }$ step-level, and D-G are of intra-episodic exploration granularity. Right: The same examples, mapped onto a characteristic plot of summary statistics: overall exploratory proportion $p _ { \mathcal { X } }$ versus typical length of an exploratory period ${ \mathrm { m e d } } _ { \mathcal { X } }$ . The yellow-shaded area highlights the intra-episodic part of space studied in this paper (some points are not realisable, e.g., when $p _ { \mathcal { X } } \approx 1$ then ${ \mathrm { m e d } } _ { \mathcal { X } }$ must be large). C, D, E, F share the same $p _ { \mathscr { X } } \approx 0 . 2$ , while interleaving exploration modes in different ways. $\mathbf { D }$ and $\mathbf { E }$ share the same ${ \mathrm { m e d } } _ { \mathcal { X } }$ value, and differ only on whether exploration periods are spread out, or happen toward the end of episode.
+
+85 We denote the length of an exploratory period by $n _ { \mathcal { X } }$ (and similarly $n _ { \mathcal { G } }$ for exploit mode). To   
+86 characterise granularity, our summary statistic of choice is ${ \mathrm { m e d } } _ { \mathcal { X } } : = { \mathrm { m e d i a n } } ( n _ { \mathcal { X } } )$ . Note that there   
+87 are two possible units for these statistics: the raw steps or the proportion of the episode length $L$ .   
+88 The latter has different (relative) semantics, but may be more appropriate when episode lengths vary   
+89 widely across training. We denote it as $\mathrm { r m e d } _ { \mathcal { X } } : = \mathrm { \bar { m e d i a n } } ( n _ { \mathcal { X } } / L )$ .
+
+# 2.3 Switching for intra-episodic exploration
+
+Granularity is but the coarsest facet of the ‘when’ question, but more precise intra-episode timings (when to start and when to stop an exploratory period) are important aspects too.
+
+93 Blind switching The simplest type of switching mechanism does not take state or time into account   
+94 (thus we call it blind), and is only concerned with producing switches at some desired time resolution.   
+95 It can be implemented deterministically through a counter (e.g., enter explore mode after 100 exploit   
+96 mode steps), or probabilistically (e.g., at each step, enter explore mode with probability 0.01). Its   
+97 expected duration can be parameterised in terms of raw steps, or in terms of fractional episode length.   
+98 The opposite of blind switching is informed switching, as discussed in Section 2.4.   
+99 Asymmetry In general, the mechanism for entering the explore mode can differ from the one   
+100 for exiting it (to enter the exploit mode), and this is crucial to obtain flexible overall amounts of   
+101 exploration – if switching were symmetric, the proportion would be $p _ { \mathscr { X } } \approx 0 . 5$ .   
+102 Starting mode When periods last for a significant fraction of episode length, it also matters how   
+103 the sequence is initialised, i.e., whether an episode starts in explore or in exploit mode, or more   
+104 generally, whether the agent explores more early in an episode or more later on. It is conceivable   
+105 that the best choice among these is domain dependent (see Figure 6): in most scenarios, the states at   
+106 the beginning of an episode have been visited many times, thus starting with exploit mode can be   
+107 beneficial; in other domains however, early actions may disproportionately determine the available   
+108 future paths (e.g., build orders in StarCraft [Churchill and Buro, 2011]).
+
+# 2.4 Informed switching with triggers
+
+110 Going beyond blind switching opens up another rich set of design choices. We decompose the   
+111 mechanism into two parts. First, a scalar trigger signal is produced by the agent at each step, based on   
+112 its current information – drawing inspiration from human behaviour, the triggering signal is intended   
+113 to be a proxy for uncertainty [Schulz et al., 2019]. Second, a binary switching decision is taken based   
+114 on the trigger signal, for example by comparing it to a threshold. Again, the type of trigger and its   
+115 configuration will in general not be symmetric between entering and exiting an exploratory period.   
+116 Value promise trigger To keep this paper focused, we will look at one such trigger, dubbed ‘value   
+117 promise discrepancy’ (see Appendix B for additional competitive variants). This is an online proxy   
+118 of how much of the reward that the agent’s past value estimate promised ( $k$ steps ago) have actually   
+119 come about. The intuition is that in uncertain parts of state space, this discrepancy will generally be   
+120 larger than when everything goes as expected. Formally,
+
+$$
+D _ { \mathrm { p r o m i s e } } ( t - k , t ) : = \left| V ( s _ { t - k } ) - \sum _ { i = 0 } ^ { k - 1 } \gamma ^ { i } R _ { t - i } - V ( s _ { t } ) \right|
+$$
+
+121 where $V ( s )$ is the agent’s value estimate at state $s , R$ is the reward, and $\gamma$ is a discount factor.
+
+122 Homeostasis In practice, the scales of trigger signals may vary substantially across domains, and   
+123 across training time, for example, the magnitude of $D _ { \mathrm { p r o m i s e } }$ will depend on reward scales and   
+124 density, and can decrease over time as accuracy improves (the signals could also be noisy). This   
+125 means that naively setting a threshold hyper-parameter is impractical. For a simple remedy, we have   
+126 taken inspiration from neuroscience [Turrigiano and Nelson, 2004] to add homeostasis to the binary   
+127 switching mechanism, which tracks recent values of the signal and adapts the threshold for switching   
+128 so that a specific average target rate is obtained. This functions as an adaptive threshold, making   
+129 tuning straightforward because the target rate of switching can be configured independently of the   
+130 scales of the trigger signal. See Appendix A for the details of the implementation.
+
+# 2.5 Adaptation instead of tuning
+
+Our approach introduces additional flexibility to the exploration process, even when holding the specifics of the learning algorithm and the exploration mode fixed. The two main added dimensions are when (or how often) to enter explore mode, and when (or how quickly) to exit it. To avoid this becoming a hyper-parameter tuning burden, we propose to follow [Schaul et al., 2019] and [Badia et al., 2020a], and delegate the adaptation of these settings to a meta-controller (implemented as a non-stationary multi-armed bandit that maximises episodic return). As an added benefit, the ‘when’ of exploration can now become adaptive to both the task, and the stage of learning.
+
+# 3 Results
+
+40 The design space we propose contains a number of atypical ideas for how to structure exploration.   
+1 For this reason, we opted to keep the rest of our experimental setup very conventional, and include   
+42 multiple comparable baselines, ablations and variations.   
+143 Setup: R2D2 on Atari We conduct our investigations on a subset of games of the Atari Learning   
+144 Environment [Bellemare et al., 2013], a common benchmark for the study of exploration. All   
+145 experiments are conducted across 7 games (FROSTBITE, GRAVITAR, H.E.R.O., MONTEZUMA’S   
+146 REVENGE, MS. PAC-MAN, PHOENIX, STAR GUNNER), the first 5 of which are classified as hard   
+147 exploration games [Bellemare et al., 2016], using 3 seeds per game. For our agent, we use the R2D2   
+148 architecture [Kapturowski et al., 2019], which is a modern, distributed version of DQN [Mnih et al.,   
+149 2015] that employs a recurrent network to approximate its Q-value function. This is a common   
+150 basis used in exploration studies, e.g., [Dabney et al., 2020, Badia et al., 2020b,a]. The only major   
+151 modification to conventional R2D2 is its exploration mechanism, where instead we implement all the   
+152 variants of mode-switching introduced in Section 2. Separately from the experience collected for   
+153 learning, we run an evaluator process that assesses the performance of the current greedy policy. This   
+154 is what we report in all our performance curves (see Appendix A for more details).   
+155 Baselines There are a few simple baselines worth comparing to, namely the pure explore mode   
+156 $\boldsymbol { p } _ { \mathcal { X } } = 1$ , Fig.1:A) and the pure exploit mode $p _ { \mathscr { X } } = 0 .$ ), as well as the step-wise interleaved $\varepsilon$ -greedy   
+157 execution (Fig.1:C), where $p _ { \mathcal { X } } = 0 . 0 1 = \varepsilon$ (without additional episodic or intra-episodic structure).   
+158 Given its wide adoption in well-tuned prior work, we expect the latter to perform well overall.   
+159 The fourth baseline picks a mode for an entire episode at a time (Fig.1:B), with the probability of   
+160 picking $\mathcal { X }$ being adapted by a bandit meta-controller. We denote these as experiment-level-X,   
+161 experiment-level-G, step-level-0.01 and episode-level- $^ *$ respectively. For each of these,   
+162 we have a version with uniform $( \mathcal { X } _ { U } )$ and intrinsic $( \mathcal { X } _ { I } )$ explore mode.
+
+![](images/0ec10c7a43b0585750463f161deba6cba9e93ea6199ed2845db7df67e8dd8c6b.jpg)  
+Figure 2: Illustrating the space of design decisions for intra-episodic exploration.
+
+# 63 3.1 Variants of intra-episodic exploration
+
+As discussed in Section 2, there are multiple dimensions along which two-mode intra-episodic exploration can vary. The concrete ones for our experiments are:
+
+• Explore mode: uniform random $\mathcal { X } _ { U }$ , or RND intrinsic reward $\mathcal { X } _ { I }$ (denoted XU and XI). • Explore duration $( n _ { \mathcal { X } } )$ : this can be a fixed number of steps $( 1 , 1 0 , 1 0 0 )$ , or one of these is adaptively picked by a bandit (denoted by $^ *$ ), or the switching is symmetric between entering end exiting explore mode (denoted by $\ c =$ ). • Trigger type: either blind or informed (based on value promise, see Section 2.4). • Exploit duration $( n g )$ : for blind triggers, the exploit duration can be parameterised by fixed number of steps (10, 100, 1000, 10000), indirectly defined by a probability of terminating $( 0 . 1 , 0 . 0 1 , 0 . 0 0 1 , 0 . 0 0 0 1 )$ , or adaptively picked by a bandit over these choices (denoted by $^ { \mathtt { n * } }$ or $\mathtt { p } ^ { * }$ , respectively). For informed triggers, the exploit duration is indirectly parameterised by a target rate in $( 0 . 1 , 0 . 0 1 , 0 . 0 0 1 , 0 . 0 0 0 1 )$ , or a bandit over them $\left( \mathtt { p } \ast \right)$ , which is in turn transformed into an adaptive switching threshold by homeostasis (Section 2.4). • Starting mode: $\mathcal { G }$ greedy (default) or $\mathcal { X }$ explore (denoted by G or X).
+
+178 We can concisely refer to a particular instance by a tuple that lists these choices. For example,   
+179 XU-intra(100,informed, $\mathtt { p } ^ { * } , \mathtt { X } )$ denotes uniform random exploration $\mathcal { X } _ { U }$ , with fixed 100-step   
+180 explore periods, triggered by the value-promise signal at a bandit-determined rate, and starting in   
+181 explore mode. See Figure 2 for an illustration.
+
+# 3.2 Performance results
+
+We start by reporting overall performance results, to reassure the reader that our method is viable (and convince them to keep reading the more detailed and qualitative results in the following sections). Figure 3 shows performance across 7 Atari games according to two human-normalised aggregation metrics (mean and median), comparing one form of intra-episodic exploration to all the baselines, separately for each explore mode ( $\mathcal { X } _ { U }$ and $\mathcal { X } _ { I }$ ). The headline result is that intra-episodic exploration improves over both step-level and episode-level baselines (as well as the pure experiment-level modes that we would not expect to be very competitive). The full learning curves per game are found in the appendix, and show scores on hard exploration games like MONTEZUMA’S REVENGE or PHOENIX that are also competitive in absolute terms (at our compute budget of 1B frames).
+
+192 Note that there is a subtle difference to the learning setups between $\mathcal { X } _ { U }$ and $\mathcal { X } _ { I }$ , as the latter requires   
+193 training a separate head to estimate intrinsic reward values. This is present even in pure exploit mode,   
+194 where it acts as an auxiliary task only [Jaderberg et al., 2016], hence the differences in pure greedy   
+195 curves in Figure 3. For details, see Appendix A.
+
+# 3.3 Diversity results
+
+197 In a study like ours, the emphasis is not on measuring raw performance, but rather on characterising   
+198 the diversity of behaviours arising from the spectrum of proposed variants. A starting point is to   
+199 return to Figure 1 (right), and assess how much of the previously untouched space is now filled   
+200 by intra-episodic variants, and how the ‘when’ characteristics translate into performance. Figure 4   
+201 answers these questions, and raises some new ones. First off, the raw amount of exploration $p _ { \mathcal { X } }$ is   
+202 not a sufficient predictor of performance, implying that the temporal structure matters. It also shows   
+203 substantial bandit adaptation at work: compare the exploration statistics at the start (squares) and   
+204 end-points of training (crosses), and how these trajectories differ per game; a common pattern is   
+205 that reducing $p _ { \mathcal { X } }$ far below 0.5 is needed for high performance. Interestingly, these adaptations are   
+206 similar between $\mathcal { X } _ { U }$ and $\mathcal { X } _ { I }$ , despite very different explore modes (and differing performance results).   
+207 We would expect prolonged intrinsic exploration periods to be more useful than prolonged random   
+208 ones, and indeed, comparing the high- $\mathrm { . r m e d } _ { \mathcal { X } }$ variant (purple) across $\mathcal { X } _ { U }$ and $\mathcal { X } _ { I }$ , it appears more
+
+![](images/2e3e37231674973ebcfbecf615bc11913d4ac4465daae0f9c09bf8fc8413fcf3.jpg)  
+Figure 3: Human-normalized performance results aggregated over 7 Atari games and 3 seeds, comparing the four levels of exploration granularity. Left two: uniform explore mode $\mathcal { X } _ { U }$ . Right two: RND intrinsic reward explore mode $\mathcal { X } _ { I }$ . In each case, the baselines are pure modes $\mathcal { X }$ and $\mathcal { G }$ , step-level switching with $\varepsilon$ -greedy, and episodic switching (with a bandit-adapted proportion). In each setting, intra-episodic exploration is on par or better than the baselines.
+
+![](images/8f6e5d185b2080f29e74ac904d04b9a9f6735ca50f8ae6f064d2ba15008aedb0.jpg)  
+Figure 4: Rows 1 and 3: Summary characteristics $p _ { \mathcal { X } }$ and $\operatorname { r m e d } _ { \mathcal { X } }$ of induced exploration behaviour, for different variants of intra-episodic exploration (and an episodic baseline for comparison), on a subset of 4 Atari games. Bandit adaptation can change these statistics over time, hence square and cross markers show averages over first and last $1 0 \%$ of training, respectively. Rows 2 and 4: Corresponding final scores (averaged over final $1 0 \%$ of training). Error bars show the span between min and max performance across 3 seeds. Note how different variants cover different parts of characteristic space, and how the bandit adaptation shifts the statistics into different directions for different games. See main text for further discussion of these results and Appendix C for other games and variants.
+
+![](images/2e7c30f208d9c226fb1e5e9eb9b24f286f74936c543f1b7382dbf958faf30b28.jpg)  
+Figure 5: Left and center: Illustration of detailed temporal structure within individual episodes, on FROSTBITE (top) and GRAVITAR (bottom), contrasting two trigger mechanisms. Each subplot shows 15 randomly selected episodes (one per row) that share the same overall exploration amount $p _ { \mathscr { X } } = 0 . 1$ . Each vertical bar (magenta) represents an exploration period of fixed length $n _ { \mathscr { X } } = 1 0$ ; each blue chunk represents an exploitation period. Left: blind, step-based trigger leads to equally spaced exploration periods. Center: a trigger signal informed by value promise leads to very different within-episode patterns, with some parts being densely explored, and others remaining in exploit mode for very long. Right: the corresponding learning curves show a clear performance benefit for the informed trigger variant (orange) in this particular setting. Appendix C has similar plots for many more variants and games.
+
+![](images/439eb6c39b354c86c38a420c9ee49d921703f16114f8271a6ea288b2d3c28870.jpg)  
+Figure 6: Starting mode effect. Final mean episode return for two blind intra-episode experiments that differ only in start mode, greedy (blue) or explore (orange). Scores are normalised so that 1 is the maximum result across the two start modes. Either choice can reliably boost or harm performance, depending on the game. Left: uniform explore mode $\mathcal { X } _ { U }$ . Right: intrinsic reward explore mode $\mathcal { X } _ { I }$ .
+
+beneficial for the latter. Zooming in on specific games, a few results stand out: in $\mathcal { X } _ { U }$ mode, the only variant that escapes the inherent local optimum of PHOENIX is the blind, doubly adaptive one (purple), with the bandits radically shifting the exploration statistics over the course of training. In contrast, the best results on MONTEZUMA’S REVENGE are produced by the symmetric trigger variant (blue), which is forced to retain a high $p _ { \mathcal { X } }$ . Finally, FROSTBITE is the one game where an informed trigger (red) clearly outperforms its blind equivalent (purple).
+
+215 These insights are still limited to summary statistics, so Figure 5 looks in more depth at the detailed   
+216 temporal structure within episodes (as in Figure 1, left). Here the main comparison is between blind   
+217 and informed triggers, illustrating that the characteristics of the fine-grained within-episode structure   
+218 can differ massively, despite attaining the same high-level statistics $p _ { \mathcal { X } }$ and ${ \mathrm { m e d } } _ { \mathcal { X } }$ . We can see quite   
+219 a lot of variation in the trigger structure – the moments we enter exploration are not evenly spaced   
+220 anymore. As a bonus, the less rigid structure of the informed trigger (and possibly the more carefully   
+221 chosen switch points) end up producing better performance too.
+
+![](images/af30d1598c7b4e0b9f2642ac65952ee36cf9f32080b93083bfa4069313aec9ed.jpg)  
+Figure 7: Left and center: Contrasting the behavioural characteristics between two forms of blind switching, step-based (left) and probabilistic (center), on the example of FROSTBITE. Each point is an actor episode, with colour indicating time in training (blue for early, red for late). Note the higher diversity of $p _ { \mathcal { X } }$ when switching probabilistically. Right: Corresponding performance curves indicate that the probabilistic switching (red) has a performance benefit, possibly because it creates the opportunity for ‘lucky’ episodes with much less randomness in a game where random actions can easily kill the agent. For more games, please see the Appendix C.
+
+Figure 6 sheds light on a complementary dimension, differentiating the effects of starting in explore or exploit mode. In brief, each of these can be consistently beneficial in some games, and consistently harmful in others. Another observation here is the dynamics of the bandit adaptation: when starting in exploit mode, it exhibits a preference for long initial exploit periods in many games (up to 10000 steps), but that effect vanishes when starting in explore mode (see also Appendix C). More subtle effects arise from the choice of parameterisation of switching rates. Figure 7 shows a stark qualitative difference on how probabilistic switching differs from step-count based switching, with the former spanning a much wider diversity of outcomes, which improves performance.
+
+# 3.4 Take-aways
+
+Summarising the empirical results in this section, two messages stand out. First, there seems to be a sweet spot in terms of temporal granularity, and intra-episodic exploration is the right step towards finding it. Second, the vastly increased design space of our proposed family of methods gives rise to a large diversity of behavioural characteristics; and this diversity is not superficial, it also translates to meaningful performance differences, with different effects in different games, which cannot be reduced to simplistic metrics, such as $p _ { \mathcal { X } }$ . In addition, we provide some sensible rules-of-thumb for practitioners willing to join us on the journey of intra-episodic exploration. In general, it is useful to let a bandit figure out the precise settings, but it is worth curating its choices to at most a handful. Jointly using two bandits across factored dimensions is very adaptive, but can sometimes be harmful when they decrease the signal-to-noise ratio in each other’s learning signal. Finally, the choice of the uncertainty-based trigger should be informed by the switching modes (see Appendix B for details).
+
+# 242 4 Discussion
+
+Time-based exploration control The emphasis of our paper has been on the potential benefits of heterogeneous temporal structure in mode-switching exploration. But there is another, more mundane potential advantage over monolithic approaches: it may be easier and more natural to tune hyper-parameters related to an explicit exploration budget (e.g., via $p _ { \mathcal { X } }$ ) than to tune an intrinsic reward coefficient, especially if extrinsic reward scales change across tasks or across time, and if the non-stationarity of the intrinsic reward affects its overall scale.
+
+249 Diversity for diversity’s sake One role of a general-purpose exploration method is to allow an   
+250 agent to get off the ground in a wide variety of domains. While this may clash with sample-efficient
+
+learning on specific domains, we believe that the former objective will come to dominate in the long 2 run. In this light, methods that exhibit more diverse behaviour are preferable for that reason alone, 3 because they are more likely to escape local optima or misaligned priors.
+
+Related work While not the most common approach to exploration in RL, we are aware of some notable work that has investigated non-trivial temporal structure. The $\epsilon z$ -greedy algorithm [Dabney et al., 2020] is inspired by Levy flights in nature [Baronchelli and Radicchi, 2013] and initiates contiguous chunks of directed behaviour (‘flights’) with the length sampled from a heavy-tailed distribution. In contrast to our proposal, these flights act with a single constant action, instead of invoking an explore mode. [Campos et al., 2021] pursue a similar idea, but with flights along pre-trained coverage policies, while [Ecoffet et al., 2021] chain a ‘return-to-state’ policy to an explore mode. Maybe closest to our $\mathcal { X } _ { I }$ setting is [Bagot et al., 2020], where periods of intrinsic reward pursuit are explicitly invoked by the agent. Exploration with gradual change instead of abrupt mode switches, appears generally at long time-scales, such as when pursuing intrinsic rewards [Schmidhuber, 2010, Oudeyer and Kaplan, 2009], but can also be effective at shorter time-scales e.g., Never-Give-Up [Badia et al., 2020b]. Related work on the question of which states to prefer for exploratory decisions [Tokic, 2010] tends to not consider starting prolonged exploratory periods.
+
+267 Relation to options Ideas related to switching behaviours at intra-episodic time-scales are well  
+268 known outside of the context of exploration, the best-known framework being options in hierarchical   
+269 RL, where the goal is to chain together a sequence of sub-behaviours into a reward-maximising   
+270 policy [Sutton et al., 1999, Mankowitz et al., 2016]; but some work has looked at using options for   
+271 exploration too [Jinnai et al., 2019a, Bougie and Ichise, 2021]. In its full generality, the options   
+272 framework is a substantially more ambitious endeavour than our proposal, as it requires learning a   
+273 full state-dependent hierarchical policy that picks which option to start (and when), as well as jointly   
+274 learning the options themselves.
+
+Limitations Our proposed approach inherits many of the challenges that are typical for exploration methods, such as sample efficiency or trading off risk. An aspect that is particular to the intra-episode switching case is the different nature of the off-policy-ness. The resulting effective policy can produce state distributions that differ substantially from those of either of the two base mode behaviours that are being interleaved. It can potentially visit parts of the state space that neither base policy would reach if followed from the beginning of the episode. While a boon for exploration, this might pose a challenge to learning, as it could require off-policy corrections that treat those states differently and do not only correct for differences in action space. We leave this as an intriguing consideration for future work; this paper does not use any non-trivial off-policy correction (see Appendix A).
+
+Future work With the dimensions laid out in Section 2, it should be clear that this paper can but scratch the surface. We see numerous opportunities for future work, on some of which we already carried out initial investigations, see Appendix B. For starters, there is no inherent need to restrict the mechanism to just two modes: A richer form of exploration could switch between exploit, explore, novelty and mastery [Thomaz and Breazeal, 2008], or between many diverse forms of exploration (such as different levels of optimism [Derman et al., 2020, Moskovitz et al., 2021]). It is also conceivable to switch less abruptly; for example, if both exploit- and explore-mode behaviours are induced by a reward function, a Q-value-based agent with successor features [Barreto et al., 2017, Borsa et al., 2019] could interpolate between them to make switching more gradual [Barreto et al., 2019]. Triggers are another aspect that could be expanded or refined: there are different candidates for estimating uncertainty, such as ensemble discrepancy [Wiering and Van Hasselt, 2008, Buckman et al., 2018], amortised value errors [Flennerhag et al., 2020], or density models [Bellemare et al., 2016, Ostrovski et al., 2017]; also, triggers could be based on other signals that are not derived from uncertainty, such as salience [Downar et al., 2002], minimal coverage [Jinnai et al., 2019a,b], or empowerment [Klyubin et al., 2005, Gregor et al., 2016, Houthooft et al., 2016].
+
+299 Conclusion We have presented an initial study of intra-episodic exploration, centred on the scenario   
+300 of switching between an explore and an exploit mode. We hope this has broadened the available   
+301 forms of temporal structure in behaviour, leading to more diverse, adaptive and intentional forms of   
+302 exploration, in turn enabling RL to scale to ever more complex domains.   
+304 M. A. Addicott, J. M. Pearson, M. M. Sweitzer, D. L. Barack, and M. L. Platt. A Primer on Foraging   
+305 and the Explore/Exploit Trade-Off for Psychiatry Research. Neuropsychopharmacology, 42(10):   
+306 1931–1939, Sep 2017.   
+307 A. P. Badia, B. Piot, S. Kapturowski, P. Sprechmann, A. Vitvitskyi, D. Guo, and C. Blundell. Agent57:   
+308 Outperforming the Atari human benchmark, 2020a.   
+309 A. P. Badia, P. Sprechmann, A. Vitvitskyi, D. Guo, B. Piot, S. Kapturowski, O. Tieleman, M. Arjovsky,   
+310 A. Pritzel, A. Bolt, and C. Blundell. Never give up: Learning directed exploration strategies,   
+311 2020b.   
+312 L. Bagot, K. Mets, and S. Latré. Learning intrinsically motivated options to stimulate policy   
+313 exploration, 2020.   
+314 A. Baronchelli and F. Radicchi. Lévy flights in human behavior and cognition. Chaos, Solitons &   
+315 Fractals, 56:101–105, 2013.   
+316 A. Barreto, W. Dabney, R. Munos, J. J. Hunt, T. Schaul, H. P. van Hasselt, and D. Silver. Successor   
+317 features for transfer in reinforcement learning. In Advances in neural information processing   
+318 systems, pages 4055–4065, 2017.   
+319 A. Barreto, D. Borsa, S. Hou, G. Comanici, E. Aygün, P. Hamel, D. Toyama, J. hunt, S. Mourad,   
+320 D. Silver, and D. Precup. The option keyboard: Combining skills in reinforcement learning. In   
+321 Advances in Neural Information Processing Systems 32, pages 13052–13062, 2019.   
+322 M. G. Bellemare, Y. Naddaf, J. Veness, and M. Bowling. The arcade learning environment: An   
+323 evaluation platform for general agents. Journal of Artificial Intelligence Research, 47:253–279,   
+324 2013.   
+325 M. G. Bellemare, S. Srinivasan, G. Ostrovski, T. Schaul, D. Saxton, and R. Munos. Unifying   
+326 count-based exploration and intrinsic motivation. In Neural Information Processing Systems, 2016.   
+327 D. Borsa, A. Barreto, J. Quan, D. J. Mankowitz, H. van Hasselt, R. Munos, D. Silver, and T. Schaul.   
+328 Universal successor features approximators. In International Conference on Learning Representa  
+329 tions, 2019.   
+330 N. Bougie and R. Ichise. Fast and slow curiosity for high-level exploration in reinforcement learning.   
+331 Applied Intelligence, 51(2):1086–1107, 2021.   
+332 J. Bradbury, R. Frostig, P. Hawkins, M. J. Johnson, C. Leary, D. Maclaurin, G. Necula, A. Paszke,   
+333 J. VanderPlas, S. Wanderman-Milne, and Q. Zhang. JAX: composable transformations of   
+334 Python+NumPy programs, 2018. URL http://github.com/google/jax.   
+335 J. Buckman, D. Hafner, G. Tucker, E. Brevdo, and H. Lee. Sample-efficient reinforcement learning   
+336 with stochastic ensemble value expansion. arXiv preprint arXiv:1807.01675, 2018.   
+337 D. Budden, M. Hessel, I. Kemaev, S. Spencer, and F. Viola. Chex: Testing made fun, in jax!, 2020a.   
+338 URL http://github.com/deepmind/chex.   
+339 D. Budden, M. Hessel, J. Quan, S. Kapturowski, K. Baumli, S. Bhupatiraju, A. Guy, and M. King.   
+340 RLax: Reinforcement Learning in JAX, 2020b. URL http://github.com/deepmind/rlax.   
+341 Y. Burda, H. Edwards, A. J. Storkey, and O. Klimov. Exploration by random network distillation.   
+342 CoRR, abs/1810.12894, 2018.   
+343 V. Campos, P. Sprechmann, S. Hansen, A. Barreto, S. Kapturowski, A. Vitvitskyi, A. P. Badia,   
+344 and C. Blundell. Coverage as a principle for discovering transferable behavior in reinforcement   
+345 learning. arXiv preprint arXiv:2102.13515, 2021.   
+346 O. Cappé, A. Garivier, O.-A. Maillard, R. Munos, G. Stoltz, et al. Kullback–leibler upper confidence   
+347 bounds for optimal sequential allocation. Annals of Statistics, 41(3):1516–1541, 2013.
+
+348 A. Cassirer, G. Barth-Maron, T. Sottiaux, M. Kroiss, and E. Brevdo. Reverb: An efficient data storage and transport system for ml research, 2020. URL https://github.com/deepmind/reverb.   
+350 F. Cathomas, F. Klaus, K. Guetter, H.-K. Chung, A. Raja Beharelle, T. R. Spiller, R. Schlegel, E. Seifritz, M. N. Hartmann-Riemer, P. N. Tobler, and S. Kaiser. Increased random exploration in schizophrenia is associated with inflammation. npj Schizophrenia, 7(1):6, Feb 2021.   
+353 K. Chakroun, D. Mathar, A. Wiehler, F. Ganzer, and J. Peters. Dopaminergic modulation of the exploration/exploitation trade-off in human decision-making. Elife, 9, 06 2020.   
+355 D. Churchill and M. Buro. Build order optimization in starcraft. In Proceedings of the AAAI Conference on Artificial Intelligence and Interactive Digital Entertainment, volume 6(1), 2011. J. D. Cohen, S. M. McClure, and A. J. Yu. Should I stay or should I go? How the human brain manages the trade-off between exploitation and exploration. Philosophical Transactions of the Royal Society B: Biological Sciences, 362(1481):933–942, 2007.   
+360 V. D. Costa, A. R. Mitz, and B. B. Averbeck. Subcortical substrates of explore-exploit decisions in primates. Neuron, 103(3):533–545.e5, Aug. 2019.   
+362 J. Cremer, T. Honda, Y. Tang, J. Wong-Ng, M. Vergassola, and T. Hwa. Chemotaxis as a navigation strategy to boost range expansion. Nature, 575(7784):658–663, 11 2019.   
+364 W. Dabney, G. Ostrovski, and A. Barreto. Temporally-extended $\epsilon$ -greedy exploration, 2020.   
+365 E. Derman, D. Mankowitz, T. Mann, and S. Mannor. A bayesian approach to robust reinforcement learning. In Uncertainty in Artificial Intelligence, pages 648–658. PMLR, 2020.   
+367 J. Downar, A. P. Crawley, D. J. Mikulis, and K. D. Davis. A cortical network sensitive to stimulus salience in a neutral behavioral context across multiple sensory modalities. Journal of neurophysiology, 87(1):615–620, 2002.   
+370 R. B. Ebitz, B. J. Sleezer, H. P. Jedema, C. W. Bradberry, and B. Y. Hayden. Tonic exploration governs both flexibility and lapses. PLOS Computational Biology, 15(11):e1007475, Nov. 2019.   
+372 A. Ecoffet, J. Huizinga, J. Lehman, K. O. Stanley, and J. Clune. Go-explore: a new approach for hard-exploration problems, 2021.   
+374 S. Flennerhag, J. X. Wang, P. Sprechmann, F. Visin, A. Galashov, S. Kapturowski, D. L. Borsa, N. Heess, A. Barreto, and R. Pascanu. Temporal difference uncertainties as a signal for exploration. arXiv preprint arXiv:2010.02255, 2020.   
+377 S. J. Gershman. Deconstructing the human algorithms for exploration. Cognition, 173:34–42, 2018. ISSN 0010-0277.   
+379 S. J. Gershman and B. G. Tzovaras. Dopaminergic genes are associated with both directed and random exploration. bioRxiv, 2018.   
+381 K. Gregor, D. J. Rezende, and D. Wierstra. Variational intrinsic control. arXiv preprint arXiv:1611.07507, 2016.   
+383 T. Hennigan, T. Cai, T. Norman, and I. Babuschkin. Haiku: Sonnet for JAX, 2020. URL http: //github.com/deepmind/dm-haiku.   
+385 M. Hessel, D. Budden, F. Viola, M. Rosca, E. Sezener, and T. Hennigan. Optax: Composable gradient transformation and optimisation, in JAX!, 2020. URL http://github.com/deepmind/optax. T. T. Hills, P. M. Todd, D. Lazer, A. D. Redish, and I. D. Couzin. Exploration versus exploitation in space, mind, and society. Trends Cogn Sci, 19(1):46–54, Jan 2015.   
+389 S. Hochreiter and J. Schmidhuber. Long short-term memory. Neural computation, 9(8):1735–1780, 1997.   
+391 D. Horgan, J. Quan, D. Budden, G. Barth-Maron, M. Hessel, H. Van Hasselt, and D. Silver. Distributed prioritized experience replay. arXiv preprint arXiv:1803.00933, 2018.   
+393 R. Houthooft, X. Chen, Y. Duan, J. Schulman, F. De Turck, and P. Abbeel. Vime: Variational information maximizing exploration. arXiv preprint arXiv:1605.09674, 2016.   
+395 M. Jaderberg, V. Mnih, W. M. Czarnecki, T. Schaul, J. Z. Leibo, D. Silver, and K. Kavukcuoglu. Reinforcement learning with unsupervised auxiliary tasks. arXiv preprint arXiv:1611.05397, 2016. T. Jaksch, R. Ortner, and P. Auer. Near-optimal regret bounds for reinforcement learning. Journal of Machine Learning Research, 11(4), 2010.   
+399 Y. Jinnai, J. W. Park, D. Abel, and G. Konidaris. Discovering options for exploration by minimizing cover time. In International Conference on Machine Learning, pages 3130–3139. PMLR, 2019a. Y. Jinnai, J. W. Park, M. C. Machado, and G. Konidaris. Exploration in reinforcement learning with deep covering options. In International Conference on Learning Representations, 2019b.   
+403 S. Kapturowski, G. Ostrovski, W. Dabney, J. Quan, and R. Munos. Recurrent experience replay in distributed reinforcement learning. In International Conference on Learning Representations, 2019.   
+406 J. M. Kembro, M. Lihoreau, J. Garriga, E. P. Raposo, and F. Bartumeus. Bumblebees learn foraging routes through exploitation-exploration cycles. J R Soc Interface, 16(156):20190103, 07 2019.   
+408 D. P. Kingma and J. Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.   
+410 A. S. Klyubin, D. Polani, and C. L. Nehaniv. Empowerment: A universal agent-centric measure of control. In 2005 IEEE Congress on Evolutionary Computation, volume 1, pages 128–135. IEEE, 2005.   
+413 T. Lattimore and C. Szepesvári. Bandit algorithms. Cambridge University Press, 2020.   
+414 C. Linke, N. M. Ady, M. White, T. Degris, and A. White. Adapting behaviour via intrinsic reward: A survey and empirical study, 2019.   
+416 M. C. Machado, M. G. Bellemare, E. Talvitie, J. Veness, M. Hausknecht, and M. Bowling. Revisiting the arcade learning environment: Evaluation protocols and open problems for general agents. Journal of Artificial Intelligence Research, 61:523–562, 2018.   
+419 D. J. Mankowitz, T. A. Mann, and S. Mannor. Adaptive skills adaptive partitions (ASAP). In Neural Information Processing Systems, 2016. V. Mnih, K. Kavukcuoglu, D. Silver, A. A. Rusu, J. Veness, M. G. Bellemare, A. Graves, M. Riedmiller, A. K. Fidjeland, G. Ostrovski, S. Petersen, C. Beattie, A. Sadik, I. Antonoglou, H. King, D. Kumaran, D. Wierstra, S. Legg, and D. Hassabis. Human-level control through deep reinforcement learning. Nature, 518(7540):529–533, 2015.   
+425 T. Moskovitz, J. Parker-Holder, A. Pacchiano, and M. Arbel. Deep reinforcement learning with dynamic optimism. arXiv preprint arXiv:2102.03765, 2021.   
+427 G. Ostrovski, M. G. Bellemare, A. van den Oord, and R. Munos. Count-based exploration with neural density models. CoRR, abs/1703.01310, 2017.   
+429 P.-Y. Oudeyer and F. Kaplan. What is intrinsic motivation? a typology of computational approaches. Frontiers in neurorobotics, 1:6, 2009. T. G. Power. Play and exploration in children and animals. Psychology Press, 1999.   
+432 T. Schaul, J. Quan, I. Antonoglou, and D. Silver. Prioritized experience replay. In International Conference on Learning Representations, Puerto Rico, 2016.   
+434 T. Schaul, D. Borsa, D. Ding, D. Szepesvari, G. Ostrovski, W. Dabney, and S. Osindero. Adapting behaviour for learning progress, 2019.   
+436 T. Schaul, G. Ostrovski, I. Kemaev, and D. Borsa. Return-based scaling: Yet another normalisation trick for deep RL. arXiv preprint arXiv:2105.05347, 2021.   
+8 J. Schmidhuber. Curious model-building control systems. In Proc. international joint conference on neural networks, pages 1458–1463, 1991.   
+0 J. Schmidhuber. Formal theory of creativity, fun, and intrinsic motivation (1990–2010). IEEE Transactions on Autonomous Mental Development, 2(3):230–247, 2010. E. Schulz, R. Bhui, B. C. Love, B. Brier, M. T. Todd, and S. J. Gershman. Structured, uncertaintydriven exploration in real-world consumer choice. Proceedings of the National Academy of Sciences, 116(28):13903–13908, June 2019. R. S. Sutton and A. G. Barto. Reinforcement learning: An introduction. MIT press, 2018.   
+6 R. S. Sutton, D. Precup, and S. Singh. Between MDPs and semi-MDPs: A framework for temporal abstraction in reinforcement learning. Artificial intelligence, 112(1-2):181–211, 1999.   
+8 A. L. Thomaz and C. Breazeal. Experiments in socially guided exploration: Lessons learned in building robots that learn with and without human teachers. Connection Science, 20(2-3):91–110, 2008. S. B. Thrun. Efficient exploration in reinforcement learning, 1992. M. Tokic. Adaptive $\varepsilon$ -greedy exploration in reinforcement learning based on value differences. In Annual Conference on Artificial Intelligence, pages 203–210. Springer, 2010. G. G. Turrigiano and S. B. Nelson. Homeostatic plasticity in the developing nervous system. Nature reviews neuroscience, 5(2):97–107, 2004.   
+6 J. A. Waltz, R. C. Wilson, M. A. Albrecht, M. J. Frank, and J. M. Gold. Differential effects of psychotic illness on directed and random exploration. Computational Psychiatry, 4(0):18, Aug. 2020. Z. Wang, T. Schaul, M. Hessel, H. Hasselt, M. Lanctot, and N. Freitas. Dueling network architectures for deep reinforcement learning. In M. F. Balcan and K. Q. Weinberger, editors, Proceedings of The 33rd International Conference on Machine Learning, volume 48 of Proceedings of Machine Learning Research, pages 1995–2003, New York, New York, USA, 20–22 Jun 2016. PMLR. M. A. Wiering and H. Van Hasselt. Ensemble algorithms in reinforcement learning. IEEE Transactions on Systems, Man, and Cybernetics, Part B (Cybernetics), 38(4):930–936, 2008.   
+5 J. M. Wolfe, K. R. Cave, and S. L. Franzel. Guided search: an alternative to the feature integration model for visual search. J Exp Psychol Hum Percept Perform, 15(3):419–433, 1989.   
+67 D. Zha, W. Ma, L. Yuan, X. Hu, and J. Liu. Rank the episodes: A simple approach for exploration in procedurally-generated environments. In International Conference on Learning Representations, 2021.
+
+1. For all authors...
+
+(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   
+(b) Did you describe the limitations of your work? [Yes] See Section 4   
+(c) Did you discuss any potential negative societal impacts of your work? [N/A]   
+(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes]
+
+2. If you are including theoretical results...
+
+(a) Did you state the full set of assumptions of all theoretical results? [N/A] (b) Did you include complete proofs of all theoretical results? [N/A]
+
+3. If you ran experiments...
+
+(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [No] We did not include code, but described the specifics of our methods in sufficient detail to reproduce results.   
+(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] See Appendix A.   
+(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [Yes] See Appendix A.   
+(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [Yes] See Appendix A.
+
+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 cite all opensource libraries used, see Appendix A.   
+(b) Did you mention the license of the assets? [N/A]   
+(c) Did you include any new assets either in the supplemental material or as a URL? [N/A]   
+(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A]   
+(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A]
+
+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/jlgCDIrAv0_/jlgCDIrAv0__content_list.json

@@ -0,0 +1,982 @@
+[
+    {
+        "type": "text",
+        "text": "When should agents explore? ",
+        "text_level": 1,
+        "bbox": [
+            321,
+            123,
+            676,
+            147
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous Author(s)   \nAffiliation   \nAddress   \nemail ",
+        "bbox": [
+            423,
+            200,
+            580,
+            256
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            292,
+            535,
+            309
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Exploration remains a central challenge for reinforcement learning (RL). Virtually   \n2 all existing methods share the feature of a monolithic behaviour policy that changes   \n3 only gradually (at best). In contrast, the exploratory behaviours of animals and hu  \n4 mans exhibit a rich diversity, namely including forms of switching between modes.   \n5 This paper presents an initial study of mode-switching, non-monolithic exploration   \n6 for RL. We investigate different modes to switch between, at what timescales it   \n7 makes sense to switch, and what signals make for good switching triggers. We   \n8 also propose practical algorithmic components that make the switching mechanism   \n9 adaptive and robust, which enables flexibility without an accompanying hyper  \n10 parameter-tuning burden. Finally, we report a promising and detailed analysis on   \n11 Atari, using two-mode exploration and switching at sub-episodic time-scales. ",
+        "bbox": [
+            148,
+            321,
+            767,
+            476
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "12 1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            500,
+            312,
+            516
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "13 The trade-off between exploration and exploitation is described as the crux of learning and behaviour   \n14 across many domains, not just reinforcement learning [Sutton and Barto, 2018], but also in decision   \n15 making [Cohen et al., 2007], evolutionary biology [Cremer et al., 2019], ecology [Kembro et al.,   \n16 2019], neuroscience (e.g., focused versus diffuse search in visual attention [Wolfe et al., 1989],   \n17 dopamine regulations [Chakroun et al., 2020]), cognitive sciences [Hills et al., 2015], as well as   \n18 psychology and psychiatry [Addicott et al., 2017]. In a nutshell, exploration is about the balance   \n19 between taking the familiar choice that is known to be rewarding and learning about unfamiliar   \n20 options of uncertain reward, but which could ultimately be more valuable than the familiar options.   \n21 Ample literature has studied the question of how much to explore, that is how to set the overall   \n22 trade-off (and how to adjust it over the course of learning) [Jaksch et al., 2010, Cappé et al., 2013,   \n23 Lattimore and Szepesvári, 2020, Thrun, 1992], and the question of how to explore, namely how   \n24 to choose exploratory actions (e.g., randomly, optimistically, intrinsically motivated, or otherwise)   \n25 [Schmidhuber, 1991, Oudeyer and Kaplan, 2009, Linke et al., 2019]. In contrast, the question of when   \n26 to explore has been studied very little, possibly because it does not arise in bandit problems, where a   \n27 lot of exploration methods are rooted. The ‘when’ question and its multiple facets are the subjects of   \n28 this paper. We believe that addressing it could lead to more intentional forms of exploration.   \n29 Consider an agent that has access to two modes of behaviour, an ‘explore’ mode and an ‘exploit’   \n30 mode (e.g., a random policy and a greedy policy, as in $\\varepsilon$ -greedy). Even when assuming that the   \n31 overall proportion of exploratory steps is fixed, the agent still has multiple degrees of freedom: it   \n32 can explore more at the beginning of training and less in later phases; it may take single exploratory   \n33 steps or execute prolonged periods of exploration; it may prefer exploratory steps early or late within   \n34 an episode; and it could trigger the onset (or end) of an exploratory period based on various criteria.   \n35 Animals and humans exhibit non-trivial behaviour in all of these dimensions, presumably encoding   \n36 useful inductive biases that way [Power, 1999]. Humans make use of multiple effective strategies,   \n37 such as selectively exploring options with high uncertainty (a form of directed, or information-seeking   \n38 exploration), and increasing the randomness of their choices when they are more uncertain [Gershman,   \n39 2018, Gershman and Tzovaras, 2018, Ebitz et al., 2019]. Monkeys use directed exploration to manage   \n40 explore-exploit trade-offs, and these signals are coded in motivational brain regions [Costa et al.,   \n41 2019]. Patients with schizophrenia register changes in directed exploration and experience low-grade   \n42 inflammation when shifting from exploitation to random exploration [Waltz et al., 2020, Cathomas   \n43 et al., 2021]. This diversity is what motivates us to study which of these can benefit RL agents in turn,   \n44 by expanding the class of exploratory behaviours beyond the commonly used monolithic ones (where   \n45 modes are merged homogeneously in time). ",
+        "bbox": [
+            147,
+            530,
+            825,
+            641
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            647,
+            825,
+            758
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            763,
+            825,
+            902
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            92,
+            825,
+            189
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "46 2 Methods ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            208,
+            279,
+            224
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "47 The objective of an RL agent is to learn a policy that maximises external reward. At the high level,   \n48 it achieves this by interleaving two processes: generating new experience by interacting with the   \n49 environment using a behaviour policy (exploration) and updating its policy using this experience   \n50 (learning). As RL is applied to increasingly ambitious tasks, the challenge for exploration becomes   \n51 to keep producing diverse experience, because if something has not been encountered, it cannot be   \n52 learned. Our central argument is therefore simple: a monolithic, time-homogeneous behaviour policy   \n53 is strictly less diverse than a heterogeneous mode-switching one, and the former may hamstring   \n54 the agent’s performance. As an illustrative example, consider a human learning how to ride a bike   \n55 (explore), while maintaining their usual happiness through food, sleep, work (exploit): there is a stark   \n56 contrast between a monolithic, time-homogeneous behaviour that interleaves a twist of the handlebar   \n57 or a turn of a pedal once every few minutes or so, and the mode-switching behaviour that dedicates   \n58 prolonged periods of time exclusively to acquiring the new skill of cycling. ",
+        "bbox": [
+            147,
+            239,
+            825,
+            405
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "59 2.1 Exploration modes ",
+        "text_level": 1,
+        "bbox": [
+            150,
+            421,
+            344,
+            436
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "60 While the choice of behaviour in pure exploit mode is straightforward, namely the greedy pursuit   \nof external reward (or best guess thereof), denoted by $\\mathcal { G }$ , there are numerous viable choices for   \n62 behaviour in a pure explore mode (denoted by $\\mathcal { X }$ ). In this paper we consider two standard ones:   \n63 $\\mathcal { X } _ { U }$ , the naive uniform random policy, and $\\mathcal { X } _ { I }$ , an intrinsically motivated behaviour that exclusively   \n64 pursues a novelty measure based on random network distillation (RND, [Burda et al., 2018]). See   \n65 Section 4 and Appendix B for additional possibilities of $\\mathcal { X }$ . In this paper we choose fixed behaviours   \n66 for these modes, and focus solely on the question of when to switch between them. In our setting,   \n67 overall proportion of exploratory steps (the how much), denoted by $p _ { \\mathcal { X } }$ , is not directly controlled but   \n68 derives from the when. ",
+        "bbox": [
+            153,
+            446,
+            825,
+            571
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.2 Granularity ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            588,
+            297,
+            603
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "An exploration period is an uninterrupted sequence of steps in explore mode. We consider four choices of temporal granularity for exploratory periods, also illustrated on Figure 1: ",
+        "bbox": [
+            165,
+            613,
+            823,
+            642
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Step-level exploration is the most common scenario, where the decision to explore is taken independently at each step, affecting one action.1 The canonical example is $\\varepsilon$ -greedy (Fig.1:C). ",
+        "bbox": [
+            166,
+            654,
+            823,
+            681
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Experiment-level exploration is the other extreme, where all behaviour during training is produced in explore mode, and learning is off-policy (the greedy policy is only used for evaluation). This scenario is also very common, with most forms of intrinsic motivation falling into this category, namely pursuing reward with an intrinsic bonus throughout training (Fig.1:A).2 ",
+        "bbox": [
+            174,
+            685,
+            825,
+            742
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Episode-level exploration is the case where the mode is fixed for an entire episode at a time (e.g., training games versus tournament matches in a sport), see Fig.1:B. This has been investigated for simple cases, where the policy’s level of stochasticity is sampled at the beginning of each episode [Horgan et al., 2018, Kapturowski et al., 2019, Zha et al., 2021]. ",
+        "bbox": [
+            176,
+            746,
+            825,
+            801
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Intra-episodic exploration is what falls in-between step- and episode-level exploration, where exploration periods last for multiple steps, but less than a full episode. This is the least commonly studied scenario, and will form the bulk of our investigations (Fig.1:D,E,F,G). ",
+        "bbox": [
+            158,
+            806,
+            821,
+            848
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/8c0dc4b02ecfa1c683fbb2be16c7afbac87ee7c5ef3e2ee1fb1d100e51c4cb1d.jpg",
+        "image_caption": [
+            "Figure 1: Illustration of different types of temporal structure for two-mode exploration. Left: Each line A-G depicts an excerpt of an experiment (black lines show episode boundaries, experiment continues on the right), with colour denoting the active mode (blue is exploit, magenta is explore). A is of experiment-level granularity, $\\mathbf { B }$ episode-level, $\\mathbf { C }$ step-level, and D-G are of intra-episodic exploration granularity. Right: The same examples, mapped onto a characteristic plot of summary statistics: overall exploratory proportion $p _ { \\mathcal { X } }$ versus typical length of an exploratory period ${ \\mathrm { m e d } } _ { \\mathcal { X } }$ . The yellow-shaded area highlights the intra-episodic part of space studied in this paper (some points are not realisable, e.g., when $p _ { \\mathcal { X } } \\approx 1$ then ${ \\mathrm { m e d } } _ { \\mathcal { X } }$ must be large). C, D, E, F share the same $p _ { \\mathscr { X } } \\approx 0 . 2$ , while interleaving exploration modes in different ways. $\\mathbf { D }$ and $\\mathbf { E }$ share the same ${ \\mathrm { m e d } } _ { \\mathcal { X } }$ value, and differ only on whether exploration periods are spread out, or happen toward the end of episode. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            79,
+            826,
+            250
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "85 We denote the length of an exploratory period by $n _ { \\mathcal { X } }$ (and similarly $n _ { \\mathcal { G } }$ for exploit mode). To   \n86 characterise granularity, our summary statistic of choice is ${ \\mathrm { m e d } } _ { \\mathcal { X } } : = { \\mathrm { m e d i a n } } ( n _ { \\mathcal { X } } )$ . Note that there   \n87 are two possible units for these statistics: the raw steps or the proportion of the episode length $L$ .   \n88 The latter has different (relative) semantics, but may be more appropriate when episode lengths vary   \n89 widely across training. We denote it as $\\mathrm { r m e d } _ { \\mathcal { X } } : = \\mathrm { \\bar { m e d i a n } } ( n _ { \\mathcal { X } } / L )$ . ",
+        "bbox": [
+            147,
+            415,
+            825,
+            484
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.3 Switching for intra-episodic exploration ",
+        "text_level": 1,
+        "bbox": [
+            165,
+            502,
+            490,
+            516
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Granularity is but the coarsest facet of the ‘when’ question, but more precise intra-episode timings (when to start and when to stop an exploratory period) are important aspects too. ",
+        "bbox": [
+            158,
+            527,
+            823,
+            556
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "93 Blind switching The simplest type of switching mechanism does not take state or time into account   \n94 (thus we call it blind), and is only concerned with producing switches at some desired time resolution.   \n95 It can be implemented deterministically through a counter (e.g., enter explore mode after 100 exploit   \n96 mode steps), or probabilistically (e.g., at each step, enter explore mode with probability 0.01). Its   \n97 expected duration can be parameterised in terms of raw steps, or in terms of fractional episode length.   \n98 The opposite of blind switching is informed switching, as discussed in Section 2.4.   \n99 Asymmetry In general, the mechanism for entering the explore mode can differ from the one   \n100 for exiting it (to enter the exploit mode), and this is crucial to obtain flexible overall amounts of   \n101 exploration – if switching were symmetric, the proportion would be $p _ { \\mathscr { X } } \\approx 0 . 5$ .   \n102 Starting mode When periods last for a significant fraction of episode length, it also matters how   \n103 the sequence is initialised, i.e., whether an episode starts in explore or in exploit mode, or more   \n104 generally, whether the agent explores more early in an episode or more later on. It is conceivable   \n105 that the best choice among these is domain dependent (see Figure 6): in most scenarios, the states at   \n106 the beginning of an episode have been visited many times, thus starting with exploit mode can be   \n107 beneficial; in other domains however, early actions may disproportionately determine the available   \n108 future paths (e.g., build orders in StarCraft [Churchill and Buro, 2011]). ",
+        "bbox": [
+            147,
+            571,
+            825,
+            655
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            143,
+            671,
+            825,
+            713
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            729,
+            825,
+            825
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.4 Informed switching with triggers ",
+        "text_level": 1,
+        "bbox": [
+            161,
+            843,
+            442,
+            858
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "110 Going beyond blind switching opens up another rich set of design choices. We decompose the   \n111 mechanism into two parts. First, a scalar trigger signal is produced by the agent at each step, based on   \n112 its current information – drawing inspiration from human behaviour, the triggering signal is intended   \n113 to be a proxy for uncertainty [Schulz et al., 2019]. Second, a binary switching decision is taken based   \n114 on the trigger signal, for example by comparing it to a threshold. Again, the type of trigger and its   \n115 configuration will in general not be symmetric between entering and exiting an exploratory period.   \n116 Value promise trigger To keep this paper focused, we will look at one such trigger, dubbed ‘value   \n117 promise discrepancy’ (see Appendix B for additional competitive variants). This is an online proxy   \n118 of how much of the reward that the agent’s past value estimate promised ( $k$ steps ago) have actually   \n119 come about. The intuition is that in uncertain parts of state space, this discrepancy will generally be   \n120 larger than when everything goes as expected. Formally, ",
+        "bbox": [
+            142,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            143,
+            90,
+            828,
+            133
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            147,
+            825,
+            218
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ca3a183e428b23d3ec88910ab8e1738975d80f883aab79d1fb6f8d67d8b35d08.jpg",
+        "text": "$$\nD _ { \\mathrm { p r o m i s e } } ( t - k , t ) : = \\left| V ( s _ { t - k } ) - \\sum _ { i = 0 } ^ { k - 1 } \\gamma ^ { i } R _ { t - i } - V ( s _ { t } ) \\right|\n$$",
+        "text_format": "latex",
+        "bbox": [
+            313,
+            223,
+            684,
+            268
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "121 where $V ( s )$ is the agent’s value estimate at state $s , R$ is the reward, and $\\gamma$ is a discount factor. ",
+        "bbox": [
+            142,
+            273,
+            784,
+            290
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "122 Homeostasis In practice, the scales of trigger signals may vary substantially across domains, and   \n123 across training time, for example, the magnitude of $D _ { \\mathrm { p r o m i s e } }$ will depend on reward scales and   \n124 density, and can decrease over time as accuracy improves (the signals could also be noisy). This   \n125 means that naively setting a threshold hyper-parameter is impractical. For a simple remedy, we have   \n126 taken inspiration from neuroscience [Turrigiano and Nelson, 2004] to add homeostasis to the binary   \n127 switching mechanism, which tracks recent values of the signal and adapts the threshold for switching   \n128 so that a specific average target rate is obtained. This functions as an adaptive threshold, making   \n129 tuning straightforward because the target rate of switching can be configured independently of the   \n130 scales of the trigger signal. See Appendix A for the details of the implementation. ",
+        "bbox": [
+            143,
+            304,
+            825,
+            429
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.5 Adaptation instead of tuning ",
+        "text_level": 1,
+        "bbox": [
+            169,
+            445,
+            413,
+            459
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Our approach introduces additional flexibility to the exploration process, even when holding the specifics of the learning algorithm and the exploration mode fixed. The two main added dimensions are when (or how often) to enter explore mode, and when (or how quickly) to exit it. To avoid this becoming a hyper-parameter tuning burden, we propose to follow [Schaul et al., 2019] and [Badia et al., 2020a], and delegate the adaptation of these settings to a meta-controller (implemented as a non-stationary multi-armed bandit that maximises episodic return). As an added benefit, the ‘when’ of exploration can now become adaptive to both the task, and the stage of learning. ",
+        "bbox": [
+            158,
+            470,
+            825,
+            568
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 Results ",
+        "text_level": 1,
+        "bbox": [
+            171,
+            587,
+            266,
+            603
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "40 The design space we propose contains a number of atypical ideas for how to structure exploration.   \n1 For this reason, we opted to keep the rest of our experimental setup very conventional, and include   \n42 multiple comparable baselines, ablations and variations.   \n143 Setup: R2D2 on Atari We conduct our investigations on a subset of games of the Atari Learning   \n144 Environment [Bellemare et al., 2013], a common benchmark for the study of exploration. All   \n145 experiments are conducted across 7 games (FROSTBITE, GRAVITAR, H.E.R.O., MONTEZUMA’S   \n146 REVENGE, MS. PAC-MAN, PHOENIX, STAR GUNNER), the first 5 of which are classified as hard   \n147 exploration games [Bellemare et al., 2016], using 3 seeds per game. For our agent, we use the R2D2   \n148 architecture [Kapturowski et al., 2019], which is a modern, distributed version of DQN [Mnih et al.,   \n149 2015] that employs a recurrent network to approximate its Q-value function. This is a common   \n150 basis used in exploration studies, e.g., [Dabney et al., 2020, Badia et al., 2020b,a]. The only major   \n151 modification to conventional R2D2 is its exploration mechanism, where instead we implement all the   \n152 variants of mode-switching introduced in Section 2. Separately from the experience collected for   \n153 learning, we run an evaluator process that assesses the performance of the current greedy policy. This   \n154 is what we report in all our performance curves (see Appendix A for more details).   \n155 Baselines There are a few simple baselines worth comparing to, namely the pure explore mode   \n156 $\\boldsymbol { p } _ { \\mathcal { X } } = 1$ , Fig.1:A) and the pure exploit mode $p _ { \\mathscr { X } } = 0 .$ ), as well as the step-wise interleaved $\\varepsilon$ -greedy   \n157 execution (Fig.1:C), where $p _ { \\mathcal { X } } = 0 . 0 1 = \\varepsilon$ (without additional episodic or intra-episodic structure).   \n158 Given its wide adoption in well-tuned prior work, we expect the latter to perform well overall.   \n159 The fourth baseline picks a mode for an entire episode at a time (Fig.1:B), with the probability of   \n160 picking $\\mathcal { X }$ being adapted by a bandit meta-controller. We denote these as experiment-level-X,   \n161 experiment-level-G, step-level-0.01 and episode-level- $^ *$ respectively. For each of these,   \n162 we have a version with uniform $( \\mathcal { X } _ { U } )$ and intrinsic $( \\mathcal { X } _ { I } )$ explore mode. ",
+        "bbox": [
+            153,
+            618,
+            826,
+            660
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            674,
+            825,
+            840
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            856,
+            825,
+            911
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/0ec10c7a43b0585750463f161deba6cba9e93ea6199ed2845db7df67e8dd8c6b.jpg",
+        "image_caption": [
+            "Figure 2: Illustrating the space of design decisions for intra-episodic exploration. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            209,
+            79,
+            789,
+            179
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            218,
+            826,
+            273
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "63 3.1 Variants of intra-episodic exploration ",
+        "text_level": 1,
+        "bbox": [
+            156,
+            290,
+            473,
+            305
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "As discussed in Section 2, there are multiple dimensions along which two-mode intra-episodic exploration can vary. The concrete ones for our experiments are: ",
+        "bbox": [
+            160,
+            315,
+            825,
+            344
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "• Explore mode: uniform random $\\mathcal { X } _ { U }$ , or RND intrinsic reward $\\mathcal { X } _ { I }$ (denoted XU and XI). • Explore duration $( n _ { \\mathcal { X } } )$ : this can be a fixed number of steps $( 1 , 1 0 , 1 0 0 )$ , or one of these is adaptively picked by a bandit (denoted by $^ *$ ), or the switching is symmetric between entering end exiting explore mode (denoted by $\\ c =$ ). • Trigger type: either blind or informed (based on value promise, see Section 2.4). • Exploit duration $( n g )$ : for blind triggers, the exploit duration can be parameterised by fixed number of steps (10, 100, 1000, 10000), indirectly defined by a probability of terminating $( 0 . 1 , 0 . 0 1 , 0 . 0 0 1 , 0 . 0 0 0 1 )$ , or adaptively picked by a bandit over these choices (denoted by $^ { \\mathtt { n * } }$ or $\\mathtt { p } ^ { * }$ , respectively). For informed triggers, the exploit duration is indirectly parameterised by a target rate in $( 0 . 1 , 0 . 0 1 , 0 . 0 0 1 , 0 . 0 0 0 1 )$ , or a bandit over them $\\left( \\mathtt { p } \\ast \\right)$ , which is in turn transformed into an adaptive switching threshold by homeostasis (Section 2.4). • Starting mode: $\\mathcal { G }$ greedy (default) or $\\mathcal { X }$ explore (denoted by G or X). ",
+        "bbox": [
+            215,
+            356,
+            825,
+            546
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "178 We can concisely refer to a particular instance by a tuple that lists these choices. For example,   \n179 XU-intra(100,informed, $\\mathtt { p } ^ { * } , \\mathtt { X } )$ denotes uniform random exploration $\\mathcal { X } _ { U }$ , with fixed 100-step   \n180 explore periods, triggered by the value-promise signal at a bandit-determined rate, and starting in   \n181 explore mode. See Figure 2 for an illustration. ",
+        "bbox": [
+            143,
+            555,
+            825,
+            611
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 Performance results ",
+        "text_level": 1,
+        "bbox": [
+            169,
+            628,
+            352,
+            642
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We start by reporting overall performance results, to reassure the reader that our method is viable (and convince them to keep reading the more detailed and qualitative results in the following sections). Figure 3 shows performance across 7 Atari games according to two human-normalised aggregation metrics (mean and median), comparing one form of intra-episodic exploration to all the baselines, separately for each explore mode ( $\\mathcal { X } _ { U }$ and $\\mathcal { X } _ { I }$ ). The headline result is that intra-episodic exploration improves over both step-level and episode-level baselines (as well as the pure experiment-level modes that we would not expect to be very competitive). The full learning curves per game are found in the appendix, and show scores on hard exploration games like MONTEZUMA’S REVENGE or PHOENIX that are also competitive in absolute terms (at our compute budget of 1B frames). ",
+        "bbox": [
+            158,
+            654,
+            825,
+            779
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "192 Note that there is a subtle difference to the learning setups between $\\mathcal { X } _ { U }$ and $\\mathcal { X } _ { I }$ , as the latter requires   \n193 training a separate head to estimate intrinsic reward values. This is present even in pure exploit mode,   \n194 where it acts as an auxiliary task only [Jaderberg et al., 2016], hence the differences in pure greedy   \n195 curves in Figure 3. For details, see Appendix A. ",
+        "bbox": [
+            142,
+            785,
+            825,
+            840
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.3 Diversity results ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            858,
+            326,
+            872
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "197 In a study like ours, the emphasis is not on measuring raw performance, but rather on characterising   \n198 the diversity of behaviours arising from the spectrum of proposed variants. A starting point is to   \n199 return to Figure 1 (right), and assess how much of the previously untouched space is now filled   \n200 by intra-episodic variants, and how the ‘when’ characteristics translate into performance. Figure 4   \n201 answers these questions, and raises some new ones. First off, the raw amount of exploration $p _ { \\mathcal { X } }$ is   \n202 not a sufficient predictor of performance, implying that the temporal structure matters. It also shows   \n203 substantial bandit adaptation at work: compare the exploration statistics at the start (squares) and   \n204 end-points of training (crosses), and how these trajectories differ per game; a common pattern is   \n205 that reducing $p _ { \\mathcal { X } }$ far below 0.5 is needed for high performance. Interestingly, these adaptations are   \n206 similar between $\\mathcal { X } _ { U }$ and $\\mathcal { X } _ { I }$ , despite very different explore modes (and differing performance results).   \n207 We would expect prolonged intrinsic exploration periods to be more useful than prolonged random   \n208 ones, and indeed, comparing the high- $\\mathrm { . r m e d } _ { \\mathcal { X } }$ variant (purple) across $\\mathcal { X } _ { U }$ and $\\mathcal { X } _ { I }$ , it appears more ",
+        "bbox": [
+            147,
+            883,
+            825,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/2e3e37231674973ebcfbecf615bc11913d4ac4465daae0f9c09bf8fc8413fcf3.jpg",
+        "image_caption": [
+            "Figure 3: Human-normalized performance results aggregated over 7 Atari games and 3 seeds, comparing the four levels of exploration granularity. Left two: uniform explore mode $\\mathcal { X } _ { U }$ . Right two: RND intrinsic reward explore mode $\\mathcal { X } _ { I }$ . In each case, the baselines are pure modes $\\mathcal { X }$ and $\\mathcal { G }$ , step-level switching with $\\varepsilon$ -greedy, and episodic switching (with a bandit-adapted proportion). In each setting, intra-episodic exploration is on par or better than the baselines. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            77,
+            823,
+            222
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/8f6e5d185b2080f29e74ac904d04b9a9f6735ca50f8ae6f064d2ba15008aedb0.jpg",
+        "image_caption": [
+            "Figure 4: Rows 1 and 3: Summary characteristics $p _ { \\mathcal { X } }$ and $\\operatorname { r m e d } _ { \\mathcal { X } }$ of induced exploration behaviour, for different variants of intra-episodic exploration (and an episodic baseline for comparison), on a subset of 4 Atari games. Bandit adaptation can change these statistics over time, hence square and cross markers show averages over first and last $1 0 \\%$ of training, respectively. Rows 2 and 4: Corresponding final scores (averaged over final $1 0 \\%$ of training). Error bars show the span between min and max performance across 3 seeds. Note how different variants cover different parts of characteristic space, and how the bandit adaptation shifts the statistics into different directions for different games. See main text for further discussion of these results and Appendix C for other games and variants. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            308,
+            826,
+            618
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            772,
+            825,
+            912
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/2e7c30f208d9c226fb1e5e9eb9b24f286f74936c543f1b7382dbf958faf30b28.jpg",
+        "image_caption": [
+            "Figure 5: Left and center: Illustration of detailed temporal structure within individual episodes, on FROSTBITE (top) and GRAVITAR (bottom), contrasting two trigger mechanisms. Each subplot shows 15 randomly selected episodes (one per row) that share the same overall exploration amount $p _ { \\mathscr { X } } = 0 . 1$ . Each vertical bar (magenta) represents an exploration period of fixed length $n _ { \\mathscr { X } } = 1 0$ ; each blue chunk represents an exploitation period. Left: blind, step-based trigger leads to equally spaced exploration periods. Center: a trigger signal informed by value promise leads to very different within-episode patterns, with some parts being densely explored, and others remaining in exploit mode for very long. Right: the corresponding learning curves show a clear performance benefit for the informed trigger variant (orange) in this particular setting. Appendix C has similar plots for many more variants and games. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            205,
+            75,
+            792,
+            381
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/439eb6c39b354c86c38a420c9ee49d921703f16114f8271a6ea288b2d3c28870.jpg",
+        "image_caption": [
+            "Figure 6: Starting mode effect. Final mean episode return for two blind intra-episode experiments that differ only in start mode, greedy (blue) or explore (orange). Scores are normalised so that 1 is the maximum result across the two start modes. Either choice can reliably boost or harm performance, depending on the game. Left: uniform explore mode $\\mathcal { X } _ { U }$ . Right: intrinsic reward explore mode $\\mathcal { X } _ { I }$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            532,
+            818,
+            714
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "beneficial for the latter. Zooming in on specific games, a few results stand out: in $\\mathcal { X } _ { U }$ mode, the only variant that escapes the inherent local optimum of PHOENIX is the blind, doubly adaptive one (purple), with the bandits radically shifting the exploration statistics over the course of training. In contrast, the best results on MONTEZUMA’S REVENGE are produced by the symmetric trigger variant (blue), which is forced to retain a high $p _ { \\mathcal { X } }$ . Finally, FROSTBITE is the one game where an informed trigger (red) clearly outperforms its blind equivalent (purple). ",
+        "bbox": [
+            156,
+            794,
+            825,
+            877
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "215 These insights are still limited to summary statistics, so Figure 5 looks in more depth at the detailed   \n216 temporal structure within episodes (as in Figure 1, left). Here the main comparison is between blind   \n217 and informed triggers, illustrating that the characteristics of the fine-grained within-episode structure   \n218 can differ massively, despite attaining the same high-level statistics $p _ { \\mathcal { X } }$ and ${ \\mathrm { m e d } } _ { \\mathcal { X } }$ . We can see quite   \n219 a lot of variation in the trigger structure – the moments we enter exploration are not evenly spaced   \n220 anymore. As a bonus, the less rigid structure of the informed trigger (and possibly the more carefully   \n221 chosen switch points) end up producing better performance too. ",
+        "bbox": [
+            142,
+            883,
+            825,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/af30d1598c7b4e0b9f2642ac65952ee36cf9f32080b93083bfa4069313aec9ed.jpg",
+        "image_caption": [
+            "Figure 7: Left and center: Contrasting the behavioural characteristics between two forms of blind switching, step-based (left) and probabilistic (center), on the example of FROSTBITE. Each point is an actor episode, with colour indicating time in training (blue for early, red for late). Note the higher diversity of $p _ { \\mathcal { X } }$ when switching probabilistically. Right: Corresponding performance curves indicate that the probabilistic switching (red) has a performance benefit, possibly because it creates the opportunity for ‘lucky’ episodes with much less randomness in a game where random actions can easily kill the agent. For more games, please see the Appendix C. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            202,
+            77,
+            794,
+            227
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            348,
+            825,
+            417
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Figure 6 sheds light on a complementary dimension, differentiating the effects of starting in explore or exploit mode. In brief, each of these can be consistently beneficial in some games, and consistently harmful in others. Another observation here is the dynamics of the bandit adaptation: when starting in exploit mode, it exhibits a preference for long initial exploit periods in many games (up to 10000 steps), but that effect vanishes when starting in explore mode (see also Appendix C). More subtle effects arise from the choice of parameterisation of switching rates. Figure 7 shows a stark qualitative difference on how probabilistic switching differs from step-count based switching, with the former spanning a much wider diversity of outcomes, which improves performance. ",
+        "bbox": [
+            173,
+            424,
+            825,
+            535
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "3.4 Take-aways ",
+        "text_level": 1,
+        "bbox": [
+            168,
+            553,
+            294,
+            568
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Summarising the empirical results in this section, two messages stand out. First, there seems to be a sweet spot in terms of temporal granularity, and intra-episodic exploration is the right step towards finding it. Second, the vastly increased design space of our proposed family of methods gives rise to a large diversity of behavioural characteristics; and this diversity is not superficial, it also translates to meaningful performance differences, with different effects in different games, which cannot be reduced to simplistic metrics, such as $p _ { \\mathcal { X } }$ . In addition, we provide some sensible rules-of-thumb for practitioners willing to join us on the journey of intra-episodic exploration. In general, it is useful to let a bandit figure out the precise settings, but it is worth curating its choices to at most a handful. Jointly using two bandits across factored dimensions is very adaptive, but can sometimes be harmful when they decrease the signal-to-noise ratio in each other’s learning signal. Finally, the choice of the uncertainty-based trigger should be informed by the switching modes (see Appendix B for details). ",
+        "bbox": [
+            173,
+            579,
+            825,
+            731
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "242 4 Discussion ",
+        "text_level": 1,
+        "bbox": [
+            150,
+            751,
+            292,
+            768
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Time-based exploration control The emphasis of our paper has been on the potential benefits of heterogeneous temporal structure in mode-switching exploration. But there is another, more mundane potential advantage over monolithic approaches: it may be easier and more natural to tune hyper-parameters related to an explicit exploration budget (e.g., via $p _ { \\mathcal { X } }$ ) than to tune an intrinsic reward coefficient, especially if extrinsic reward scales change across tasks or across time, and if the non-stationarity of the intrinsic reward affects its overall scale. ",
+        "bbox": [
+            173,
+            784,
+            823,
+            867
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "249 Diversity for diversity’s sake One role of a general-purpose exploration method is to allow an   \n250 agent to get off the ground in a wide variety of domains. While this may clash with sample-efficient ",
+        "bbox": [
+            148,
+            883,
+            823,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "learning on specific domains, we believe that the former objective will come to dominate in the long 2 run. In this light, methods that exhibit more diverse behaviour are preferable for that reason alone, 3 because they are more likely to escape local optima or misaligned priors. ",
+        "bbox": [
+            156,
+            92,
+            823,
+            133
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Related work While not the most common approach to exploration in RL, we are aware of some notable work that has investigated non-trivial temporal structure. The $\\epsilon z$ -greedy algorithm [Dabney et al., 2020] is inspired by Levy flights in nature [Baronchelli and Radicchi, 2013] and initiates contiguous chunks of directed behaviour (‘flights’) with the length sampled from a heavy-tailed distribution. In contrast to our proposal, these flights act with a single constant action, instead of invoking an explore mode. [Campos et al., 2021] pursue a similar idea, but with flights along pre-trained coverage policies, while [Ecoffet et al., 2021] chain a ‘return-to-state’ policy to an explore mode. Maybe closest to our $\\mathcal { X } _ { I }$ setting is [Bagot et al., 2020], where periods of intrinsic reward pursuit are explicitly invoked by the agent. Exploration with gradual change instead of abrupt mode switches, appears generally at long time-scales, such as when pursuing intrinsic rewards [Schmidhuber, 2010, Oudeyer and Kaplan, 2009], but can also be effective at shorter time-scales e.g., Never-Give-Up [Badia et al., 2020b]. Related work on the question of which states to prefer for exploratory decisions [Tokic, 2010] tends to not consider starting prolonged exploratory periods. ",
+        "bbox": [
+            171,
+            148,
+            825,
+            328
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "267 Relation to options Ideas related to switching behaviours at intra-episodic time-scales are well  \n268 known outside of the context of exploration, the best-known framework being options in hierarchical   \n269 RL, where the goal is to chain together a sequence of sub-behaviours into a reward-maximising   \n270 policy [Sutton et al., 1999, Mankowitz et al., 2016]; but some work has looked at using options for   \n271 exploration too [Jinnai et al., 2019a, Bougie and Ichise, 2021]. In its full generality, the options   \n272 framework is a substantially more ambitious endeavour than our proposal, as it requires learning a   \n273 full state-dependent hierarchical policy that picks which option to start (and when), as well as jointly   \n274 learning the options themselves. ",
+        "bbox": [
+            140,
+            342,
+            825,
+            453
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Limitations Our proposed approach inherits many of the challenges that are typical for exploration methods, such as sample efficiency or trading off risk. An aspect that is particular to the intra-episode switching case is the different nature of the off-policy-ness. The resulting effective policy can produce state distributions that differ substantially from those of either of the two base mode behaviours that are being interleaved. It can potentially visit parts of the state space that neither base policy would reach if followed from the beginning of the episode. While a boon for exploration, this might pose a challenge to learning, as it could require off-policy corrections that treat those states differently and do not only correct for differences in action space. We leave this as an intriguing consideration for future work; this paper does not use any non-trivial off-policy correction (see Appendix A). ",
+        "bbox": [
+            161,
+            468,
+            825,
+            593
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Future work With the dimensions laid out in Section 2, it should be clear that this paper can but scratch the surface. We see numerous opportunities for future work, on some of which we already carried out initial investigations, see Appendix B. For starters, there is no inherent need to restrict the mechanism to just two modes: A richer form of exploration could switch between exploit, explore, novelty and mastery [Thomaz and Breazeal, 2008], or between many diverse forms of exploration (such as different levels of optimism [Derman et al., 2020, Moskovitz et al., 2021]). It is also conceivable to switch less abruptly; for example, if both exploit- and explore-mode behaviours are induced by a reward function, a Q-value-based agent with successor features [Barreto et al., 2017, Borsa et al., 2019] could interpolate between them to make switching more gradual [Barreto et al., 2019]. Triggers are another aspect that could be expanded or refined: there are different candidates for estimating uncertainty, such as ensemble discrepancy [Wiering and Van Hasselt, 2008, Buckman et al., 2018], amortised value errors [Flennerhag et al., 2020], or density models [Bellemare et al., 2016, Ostrovski et al., 2017]; also, triggers could be based on other signals that are not derived from uncertainty, such as salience [Downar et al., 2002], minimal coverage [Jinnai et al., 2019a,b], or empowerment [Klyubin et al., 2005, Gregor et al., 2016, Houthooft et al., 2016]. ",
+        "bbox": [
+            169,
+            608,
+            825,
+            815
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "299 Conclusion We have presented an initial study of intra-episodic exploration, centred on the scenario   \n300 of switching between an explore and an exploit mode. We hope this has broadened the available   \n301 forms of temporal structure in behaviour, leading to more diverse, adaptive and intentional forms of   \n302 exploration, in turn enabling RL to scale to ever more complex domains.   \n304 M. A. Addicott, J. M. Pearson, M. M. Sweitzer, D. L. Barack, and M. L. Platt. A Primer on Foraging   \n305 and the Explore/Exploit Trade-Off for Psychiatry Research. Neuropsychopharmacology, 42(10):   \n306 1931–1939, Sep 2017.   \n307 A. P. Badia, B. Piot, S. Kapturowski, P. Sprechmann, A. Vitvitskyi, D. Guo, and C. Blundell. Agent57:   \n308 Outperforming the Atari human benchmark, 2020a.   \n309 A. P. Badia, P. Sprechmann, A. Vitvitskyi, D. Guo, B. Piot, S. Kapturowski, O. Tieleman, M. Arjovsky,   \n310 A. Pritzel, A. Bolt, and C. Blundell. Never give up: Learning directed exploration strategies,   \n311 2020b.   \n312 L. Bagot, K. Mets, and S. Latré. Learning intrinsically motivated options to stimulate policy   \n313 exploration, 2020.   \n314 A. Baronchelli and F. Radicchi. Lévy flights in human behavior and cognition. Chaos, Solitons &   \n315 Fractals, 56:101–105, 2013.   \n316 A. Barreto, W. Dabney, R. Munos, J. J. Hunt, T. Schaul, H. P. van Hasselt, and D. Silver. Successor   \n317 features for transfer in reinforcement learning. In Advances in neural information processing   \n318 systems, pages 4055–4065, 2017.   \n319 A. Barreto, D. Borsa, S. Hou, G. Comanici, E. Aygün, P. Hamel, D. Toyama, J. hunt, S. Mourad,   \n320 D. Silver, and D. Precup. The option keyboard: Combining skills in reinforcement learning. In   \n321 Advances in Neural Information Processing Systems 32, pages 13052–13062, 2019.   \n322 M. G. Bellemare, Y. Naddaf, J. Veness, and M. Bowling. The arcade learning environment: An   \n323 evaluation platform for general agents. Journal of Artificial Intelligence Research, 47:253–279,   \n324 2013.   \n325 M. G. Bellemare, S. Srinivasan, G. Ostrovski, T. Schaul, D. Saxton, and R. Munos. Unifying   \n326 count-based exploration and intrinsic motivation. In Neural Information Processing Systems, 2016.   \n327 D. Borsa, A. Barreto, J. Quan, D. J. Mankowitz, H. van Hasselt, R. Munos, D. Silver, and T. Schaul.   \n328 Universal successor features approximators. In International Conference on Learning Representa  \n329 tions, 2019.   \n330 N. Bougie and R. Ichise. Fast and slow curiosity for high-level exploration in reinforcement learning.   \n331 Applied Intelligence, 51(2):1086–1107, 2021.   \n332 J. Bradbury, R. Frostig, P. Hawkins, M. J. Johnson, C. Leary, D. Maclaurin, G. Necula, A. Paszke,   \n333 J. VanderPlas, S. Wanderman-Milne, and Q. Zhang. JAX: composable transformations of   \n334 Python+NumPy programs, 2018. URL http://github.com/google/jax.   \n335 J. Buckman, D. Hafner, G. Tucker, E. Brevdo, and H. Lee. Sample-efficient reinforcement learning   \n336 with stochastic ensemble value expansion. arXiv preprint arXiv:1807.01675, 2018.   \n337 D. Budden, M. Hessel, I. Kemaev, S. Spencer, and F. Viola. Chex: Testing made fun, in jax!, 2020a.   \n338 URL http://github.com/deepmind/chex.   \n339 D. Budden, M. Hessel, J. Quan, S. Kapturowski, K. Baumli, S. Bhupatiraju, A. Guy, and M. King.   \n340 RLax: Reinforcement Learning in JAX, 2020b. URL http://github.com/deepmind/rlax.   \n341 Y. Burda, H. Edwards, A. J. Storkey, and O. Klimov. Exploration by random network distillation.   \n342 CoRR, abs/1810.12894, 2018.   \n343 V. Campos, P. Sprechmann, S. Hansen, A. Barreto, S. Kapturowski, A. Vitvitskyi, A. P. Badia,   \n344 and C. Blundell. Coverage as a principle for discovering transferable behavior in reinforcement   \n345 learning. arXiv preprint arXiv:2102.13515, 2021.   \n346 O. Cappé, A. Garivier, O.-A. Maillard, R. Munos, G. Stoltz, et al. Kullback–leibler upper confidence   \n347 bounds for optimal sequential allocation. Annals of Statistics, 41(3):1516–1541, 2013. ",
+        "bbox": [
+            142,
+            829,
+            825,
+            886
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            137,
+            94,
+            828,
+            916
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "348 A. Cassirer, G. Barth-Maron, T. Sottiaux, M. Kroiss, and E. Brevdo. Reverb: An efficient data storage and transport system for ml research, 2020. URL https://github.com/deepmind/reverb.   \n350 F. Cathomas, F. Klaus, K. Guetter, H.-K. Chung, A. Raja Beharelle, T. R. Spiller, R. Schlegel, E. Seifritz, M. N. Hartmann-Riemer, P. N. Tobler, and S. Kaiser. Increased random exploration in schizophrenia is associated with inflammation. npj Schizophrenia, 7(1):6, Feb 2021.   \n353 K. Chakroun, D. Mathar, A. Wiehler, F. Ganzer, and J. Peters. Dopaminergic modulation of the exploration/exploitation trade-off in human decision-making. Elife, 9, 06 2020.   \n355 D. Churchill and M. Buro. Build order optimization in starcraft. In Proceedings of the AAAI Conference on Artificial Intelligence and Interactive Digital Entertainment, volume 6(1), 2011. J. D. Cohen, S. M. McClure, and A. J. Yu. Should I stay or should I go? How the human brain manages the trade-off between exploitation and exploration. Philosophical Transactions of the Royal Society B: Biological Sciences, 362(1481):933–942, 2007.   \n360 V. D. Costa, A. R. Mitz, and B. B. Averbeck. Subcortical substrates of explore-exploit decisions in primates. Neuron, 103(3):533–545.e5, Aug. 2019.   \n362 J. Cremer, T. Honda, Y. Tang, J. Wong-Ng, M. Vergassola, and T. Hwa. Chemotaxis as a navigation strategy to boost range expansion. Nature, 575(7784):658–663, 11 2019.   \n364 W. Dabney, G. Ostrovski, and A. Barreto. Temporally-extended $\\epsilon$ -greedy exploration, 2020.   \n365 E. Derman, D. Mankowitz, T. Mann, and S. Mannor. A bayesian approach to robust reinforcement learning. In Uncertainty in Artificial Intelligence, pages 648–658. PMLR, 2020.   \n367 J. Downar, A. P. Crawley, D. J. Mikulis, and K. D. Davis. A cortical network sensitive to stimulus salience in a neutral behavioral context across multiple sensory modalities. Journal of neurophysiology, 87(1):615–620, 2002.   \n370 R. B. Ebitz, B. J. Sleezer, H. P. Jedema, C. W. Bradberry, and B. Y. Hayden. Tonic exploration governs both flexibility and lapses. PLOS Computational Biology, 15(11):e1007475, Nov. 2019.   \n372 A. Ecoffet, J. Huizinga, J. Lehman, K. O. Stanley, and J. Clune. Go-explore: a new approach for hard-exploration problems, 2021.   \n374 S. Flennerhag, J. X. Wang, P. Sprechmann, F. Visin, A. Galashov, S. Kapturowski, D. L. Borsa, N. Heess, A. Barreto, and R. Pascanu. Temporal difference uncertainties as a signal for exploration. arXiv preprint arXiv:2010.02255, 2020.   \n377 S. J. Gershman. Deconstructing the human algorithms for exploration. Cognition, 173:34–42, 2018. ISSN 0010-0277.   \n379 S. J. Gershman and B. G. Tzovaras. Dopaminergic genes are associated with both directed and random exploration. bioRxiv, 2018.   \n381 K. Gregor, D. J. Rezende, and D. Wierstra. Variational intrinsic control. arXiv preprint arXiv:1611.07507, 2016.   \n383 T. Hennigan, T. Cai, T. Norman, and I. Babuschkin. Haiku: Sonnet for JAX, 2020. URL http: //github.com/deepmind/dm-haiku.   \n385 M. Hessel, D. Budden, F. Viola, M. Rosca, E. Sezener, and T. Hennigan. Optax: Composable gradient transformation and optimisation, in JAX!, 2020. URL http://github.com/deepmind/optax. T. T. Hills, P. M. Todd, D. Lazer, A. D. Redish, and I. D. Couzin. Exploration versus exploitation in space, mind, and society. Trends Cogn Sci, 19(1):46–54, Jan 2015.   \n389 S. Hochreiter and J. Schmidhuber. Long short-term memory. Neural computation, 9(8):1735–1780, 1997.   \n391 D. Horgan, J. Quan, D. Budden, G. Barth-Maron, M. Hessel, H. Van Hasselt, and D. Silver. Distributed prioritized experience replay. arXiv preprint arXiv:1803.00933, 2018.   \n393 R. Houthooft, X. Chen, Y. Duan, J. Schulman, F. De Turck, and P. Abbeel. Vime: Variational information maximizing exploration. arXiv preprint arXiv:1605.09674, 2016.   \n395 M. Jaderberg, V. Mnih, W. M. Czarnecki, T. Schaul, J. Z. Leibo, D. Silver, and K. Kavukcuoglu. Reinforcement learning with unsupervised auxiliary tasks. arXiv preprint arXiv:1611.05397, 2016. T. Jaksch, R. Ortner, and P. Auer. Near-optimal regret bounds for reinforcement learning. Journal of Machine Learning Research, 11(4), 2010.   \n399 Y. Jinnai, J. W. Park, D. Abel, and G. Konidaris. Discovering options for exploration by minimizing cover time. In International Conference on Machine Learning, pages 3130–3139. PMLR, 2019a. Y. Jinnai, J. W. Park, M. C. Machado, and G. Konidaris. Exploration in reinforcement learning with deep covering options. In International Conference on Learning Representations, 2019b.   \n403 S. Kapturowski, G. Ostrovski, W. Dabney, J. Quan, and R. Munos. Recurrent experience replay in distributed reinforcement learning. In International Conference on Learning Representations, 2019.   \n406 J. M. Kembro, M. Lihoreau, J. Garriga, E. P. Raposo, and F. Bartumeus. Bumblebees learn foraging routes through exploitation-exploration cycles. J R Soc Interface, 16(156):20190103, 07 2019.   \n408 D. P. Kingma and J. Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.   \n410 A. S. Klyubin, D. Polani, and C. L. Nehaniv. Empowerment: A universal agent-centric measure of control. In 2005 IEEE Congress on Evolutionary Computation, volume 1, pages 128–135. IEEE, 2005.   \n413 T. Lattimore and C. Szepesvári. Bandit algorithms. Cambridge University Press, 2020.   \n414 C. Linke, N. M. Ady, M. White, T. Degris, and A. White. Adapting behaviour via intrinsic reward: A survey and empirical study, 2019.   \n416 M. C. Machado, M. G. Bellemare, E. Talvitie, J. Veness, M. Hausknecht, and M. Bowling. Revisiting the arcade learning environment: Evaluation protocols and open problems for general agents. Journal of Artificial Intelligence Research, 61:523–562, 2018.   \n419 D. J. Mankowitz, T. A. Mann, and S. Mannor. Adaptive skills adaptive partitions (ASAP). In Neural Information Processing Systems, 2016. V. Mnih, K. Kavukcuoglu, D. Silver, A. A. Rusu, J. Veness, M. G. Bellemare, A. Graves, M. Riedmiller, A. K. Fidjeland, G. Ostrovski, S. Petersen, C. Beattie, A. Sadik, I. Antonoglou, H. King, D. Kumaran, D. Wierstra, S. Legg, and D. Hassabis. Human-level control through deep reinforcement learning. Nature, 518(7540):529–533, 2015.   \n425 T. Moskovitz, J. Parker-Holder, A. Pacchiano, and M. Arbel. Deep reinforcement learning with dynamic optimism. arXiv preprint arXiv:2102.03765, 2021.   \n427 G. Ostrovski, M. G. Bellemare, A. van den Oord, and R. Munos. Count-based exploration with neural density models. CoRR, abs/1703.01310, 2017.   \n429 P.-Y. Oudeyer and F. Kaplan. What is intrinsic motivation? a typology of computational approaches. Frontiers in neurorobotics, 1:6, 2009. T. G. Power. Play and exploration in children and animals. Psychology Press, 1999.   \n432 T. Schaul, J. Quan, I. Antonoglou, and D. Silver. Prioritized experience replay. In International Conference on Learning Representations, Puerto Rico, 2016.   \n434 T. Schaul, D. Borsa, D. Ding, D. Szepesvari, G. Ostrovski, W. Dabney, and S. Osindero. Adapting behaviour for learning progress, 2019.   \n436 T. Schaul, G. Ostrovski, I. Kemaev, and D. Borsa. Return-based scaling: Yet another normalisation trick for deep RL. arXiv preprint arXiv:2105.05347, 2021.   \n8 J. Schmidhuber. Curious model-building control systems. In Proc. international joint conference on neural networks, pages 1458–1463, 1991.   \n0 J. Schmidhuber. Formal theory of creativity, fun, and intrinsic motivation (1990–2010). IEEE Transactions on Autonomous Mental Development, 2(3):230–247, 2010. E. Schulz, R. Bhui, B. C. Love, B. Brier, M. T. Todd, and S. J. Gershman. Structured, uncertaintydriven exploration in real-world consumer choice. Proceedings of the National Academy of Sciences, 116(28):13903–13908, June 2019. R. S. Sutton and A. G. Barto. Reinforcement learning: An introduction. MIT press, 2018.   \n6 R. S. Sutton, D. Precup, and S. Singh. Between MDPs and semi-MDPs: A framework for temporal abstraction in reinforcement learning. Artificial intelligence, 112(1-2):181–211, 1999.   \n8 A. L. Thomaz and C. Breazeal. Experiments in socially guided exploration: Lessons learned in building robots that learn with and without human teachers. Connection Science, 20(2-3):91–110, 2008. S. B. Thrun. Efficient exploration in reinforcement learning, 1992. M. Tokic. Adaptive $\\varepsilon$ -greedy exploration in reinforcement learning based on value differences. In Annual Conference on Artificial Intelligence, pages 203–210. Springer, 2010. G. G. Turrigiano and S. B. Nelson. Homeostatic plasticity in the developing nervous system. Nature reviews neuroscience, 5(2):97–107, 2004.   \n6 J. A. Waltz, R. C. Wilson, M. A. Albrecht, M. J. Frank, and J. M. Gold. Differential effects of psychotic illness on directed and random exploration. Computational Psychiatry, 4(0):18, Aug. 2020. Z. Wang, T. Schaul, M. Hessel, H. Hasselt, M. Lanctot, and N. Freitas. Dueling network architectures for deep reinforcement learning. In M. F. Balcan and K. Q. Weinberger, editors, Proceedings of The 33rd International Conference on Machine Learning, volume 48 of Proceedings of Machine Learning Research, pages 1995–2003, New York, New York, USA, 20–22 Jun 2016. PMLR. M. A. Wiering and H. Van Hasselt. Ensemble algorithms in reinforcement learning. IEEE Transactions on Systems, Man, and Cybernetics, Part B (Cybernetics), 38(4):930–936, 2008.   \n5 J. M. Wolfe, K. R. Cave, and S. L. Franzel. Guided search: an alternative to the feature integration model for visual search. J Exp Psychol Hum Percept Perform, 15(3):419–433, 1989.   \n67 D. Zha, W. Ma, L. Yuan, X. Hu, and J. Liu. Rank the episodes: A simple approach for exploration in procedurally-generated environments. In International Conference on Learning Representations, 2021. ",
+        "bbox": [
+            143,
+            80,
+            828,
+            922
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            80,
+            830,
+            919
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            155,
+            83,
+            828,
+            670
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "1. For all authors... ",
+        "bbox": [
+            214,
+            116,
+            339,
+            131
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   \n(b) Did you describe the limitations of your work? [Yes] See Section 4   \n(c) Did you discuss any potential negative societal impacts of your work? [N/A]   \n(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes] ",
+        "bbox": [
+            238,
+            135,
+            825,
+            227
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "2. If you are including theoretical results... ",
+        "bbox": [
+            214,
+            231,
+            493,
+            244
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you state the full set of assumptions of all theoretical results? [N/A] (b) Did you include complete proofs of all theoretical results? [N/A] ",
+        "bbox": [
+            236,
+            248,
+            738,
+            280
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "3. If you ran experiments... ",
+        "bbox": [
+            212,
+            285,
+            393,
+            299
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [No] We did not include code, but described the specifics of our methods in sufficient detail to reproduce results.   \n(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] See Appendix A.   \n(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [Yes] See Appendix A.   \n(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [Yes] See Appendix A. ",
+        "bbox": [
+            238,
+            303,
+            825,
+            449
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... ",
+        "bbox": [
+            217,
+            453,
+            823,
+            468
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "(a) If your work uses existing assets, did you cite the creators? [Yes] We cite all opensource libraries used, see Appendix A.   \n(b) Did you mention the license of the assets? [N/A]   \n(c) Did you include any new assets either in the supplemental material or as a URL? [N/A]   \n(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A]   \n(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A] ",
+        "bbox": [
+            238,
+            472,
+            825,
+            607
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "5. If you used crowdsourcing or conducted research with human subjects... ",
+        "bbox": [
+            212,
+            611,
+            705,
+            626
+        ],
+        "page_idx": 13
+    },
+    {
+        "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,
+            630,
+            825,
+            719
+        ],
+        "page_idx": 13
+    }
+]

parse/train/rJxcBpNKPr/rJxcBpNKPr.md

@@ -0,0 +1,321 @@
+# OVA-INN: CONTINUAL LEARNING WITH INVERTIBLE NEURAL NETWORKS
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+In the field of Continual Learning, the objective is to learn several tasks one after the other without access to the data from previous tasks. Several solutions have been proposed to tackle this problem but they usually assume that the user knows which of the tasks to perform at test time on a particular sample, or rely on small samples from previous data and most of them suffer of a substantial drop in accuracy when updated with batches of only one class at a time. In this article, we propose a new method, OvA-INN, which is able to learn one class at a time and without storing any of the previous data. To achieve this, for each class, we train a specific Invertible Neural Network to extract the relevant features to compute the likelihood on this class. At test time, we can predict the class of a sample by identifying the network which predicted the highest likelihood. With this method, we show that we can take advantage of pretrained models by stacking an Invertible Network on top of a features extractor. This way, we are able to outperform stateof-the-art approaches that rely on features learning for the Continual Learning of MNIST and CIFAR-100 datasets. In our experiments, we reach $72 \%$ accuracy on CIFAR-100 after training our model one class at a time.
+
+# 1 INTRODUCTION
+
+A typical Deep Learning workflow consists in gathering data, training a model on this data and finally deploying the model in the real world (Goodfellow et al., 2016). If one would need to update the model with new data, it would require to merge the old and new data and process a training from scratch on this new dataset. Nevertheless, there are circumstances where this method may not apply. For example, it may not be possible to store the old data because of privacy issues (health records, sensible data) or memory limitations (embedded systems, very large datasets). In order to address those limitations, recent works propose a variety of approaches in a setting called Continual Learning (Parisi et al., 2018).
+
+In Continual Learning, we aim to learn the parameters $w$ of a model on a sequence of datasets $\mathcal { D } _ { i } = \{ ( x _ { i } ^ { j } , y _ { i } ^ { j } ) \} _ { j = 1 } ^ { n _ { i } }$ with the inputs $x _ { i } ^ { j } \in \mathcal { X } ^ { i }$ and the labels $y _ { i } ^ { j } \in \mathcal { V } ^ { i }$ , to predict $p ( y ^ { * } | w , x ^ { * } )$ for an unseen pair $( x ^ { * } , y ^ { * } )$ . The training has to be done on each dataset, one after the other, without the possibility to reuse previous datasets. The performance of a Continual Learning algorithm can then be measured with two protocols : multi-head or single-head. In the multi-head scenario, the task identifier $i$ is known at test time. For evaluating performances on task $i$ , the set of all possible labels is then $\mathcal { V } = \mathcal { V } ^ { i }$ . Whilst in the single-head scenario, the task identifier is unknown, in that case we have $\mathcal { V } = \cup _ { i = 1 } ^ { N } \mathcal { V } ^ { i }$ with $N$ the number of tasks learned so far. For example, let us say that the goal is to learn MNIST sequentially with two batches: using only the data from the first five classes and then only the data from the remaining five other classes. In multi-head learning, one asks at test time to be able to recognize samples of 0-4 among the classes 0-4 and samples of 5-9 among classes 5-9. On the other hand, in single-head learning, one can not assume from which batch a sample is coming from, hence the need to be able to recognize any samples of 0-9 among classes 0-9. Although the former one has received the most attention from researchers, the last one fits better to the desiderata of a Continual Learning system as expressed in Farquhar & Gal (2018) and (van de Ven & Tolias, 2019). The single-head scenario is also notoriously harder than its multi-head counterpart (Chaudhry et al., 2018) and is the focus of the present work.
+
+Updating the parameters with data from a new dataset exposes the model to drastically deteriorate its performance on previous data, a phenomenon known as catastrophic forgetting (McCloskey & Cohen, 1989). To alleviate this problem, researchers have proposed a variety of approaches such as storing a few samples from previous datasets (Rebuffi et al., 2017), adding distillation regularization (Li & Hoiem, 2018), updating the parameters according to their usefulness on previous datasets (Kirkpatrick et al., 2017), using a generative model to produce samples from previous datasets (Kemker & Kanan, 2017). Despite those efforts toward a more realistic setting of Continual Learning, one can notice that, most of the time, results are proposed in the case of a sequence of batches of multiple classes. This scenario often ends up with better accuracy (because the learning procedure highly benefits of the diversity of classes to find the best tuning of parameters) but it does not illustrate the behavior of those methods in the worst case scenario. In fact, Continual Learning algorithms should be robust in the size of the batch of classes.
+
+In this work, we propose to implement a method specially designed to handle the case where each task consists of only one class. It will therefore be evaluated in the single-head scenario. Our approach, named One-versus-All Invertible Neural Networks (OvA-INN), is based on an invertible neural network architecture proposed by Dinh et al. (2014). We use it in a One-versus-All strategy : each network is trained to make a prediction of a class and the most confident one on a sample is used to identify the class of the sample. In contrast to most other methods, the training phase of each class can be independently executed from one another.
+
+The contributions of our work are : (i) a new approach for Continual Learning with one class per batch; (ii) a neural architecture based on Invertible Networks that does not require to store any of the previous data; (iii) state-of-the-art results on several tasks of Continual Learning for Computer Vision (CIFAR-100, MNIST) in this setting.
+
+We start by reviewing the closest methods to our approach in Section 2, then explain our method in Section 3, analyse its performances in Section 4 and identify limitations and possible extensions in Section 5.
+
+# 2 RELATED WORK
+
+Generative models Inspired by biological mechanisms such as the hippocampal system that rapidly encodes recent experiences and the memory of the neocortex that is consolidated during sleep phases, a natural approach is to produce samples of previous data that can be added to the new data to learn a new task. FearNet (Kemker & Kanan, 2017) relies on an architecture based on an autoencoder, whereas Deep Generative Replay (Shin et al., 2017) and Parameter Generation and Model Adaptation (Hu et al., 2018) propose to use a generative adversarial network. Those methods present good results but require complex models to be able to generate reliable data. Furthermore, it is difficult to assess the relevance of the generated data to conduct subsequent training iterations.
+
+Coreset-based models These approaches alleviate the constraint on the availability of data by allowing the storage of a few samples from previous data (which are called coreset). iCaRL (Rebuffi et al., 2017) and End-to-end IL (Castro et al., 2018) store 2000 samples from previous batches and rely on respectively a distillation loss and a mixture of cross-entropy and distillation loss to alleviate forgetting. The authors of SupportNet (Li et al., 2018) have also proposed a strategy to select relevant samples for the coreset. Gradient Episodic Memory (Lopez-Paz et al., 2017) ensures that gradients computed on new tasks do not interfere with the loss of previous tasks. Those approaches give the best results for single-head learning. But, similarly to generated data, it is not clear which data may be useful to conduct further training iterations. In this paper, we are challenging the need of the coreset for single-head learning.
+
+Distance-based models These methods propose to embed the data in a space which can be used to identify the class of a sample by computing a distance between the embedding of the sample and a reference for each class. Among the most popular, we can cite Matching Networks (Vinyals et al., 2016) and Prototypical Networks (Snell et al., 2017), but these methods have been mostly applied to few-shot learning scenarios rather than continual.
+
+Regularization-based approaches These approaches present an attempt to mitigate the effect of catastrophic forgetting by imposing some constraints on the loss function when training subsequent classes. Elastic Weight Consolidation (Kirkpatrick et al., 2017), Synaptic Intelligence (Zenke et al., 2017) and Memory Aware Synapses (Aljundi et al., 2018) all seek to prevent the update of weights that were the most useful to discriminate between previous classes. Hence, it is possible to constrain the learning of a new task in such a way that the most relevant weights for the previous tasks are less susceptible to be updated. Learning without forgetting (Li & Hoiem, 2018) proposes to use knowledge distillation to preserve previous performances. The network is divided in two parts : the shared weights and the dedicated weights for each task. When learning a new task A, the data of A get assigned “soft” labels by computing the output by the network with the dedicated weight for each previous task. Then the network is trained with the loss of task A and is also constrained to reproduce the recorded output for each other tasks. In Rannen et al. (2017), the authors propose to use an autoencoder to reconstruct the extracted features for each task. When learning a new task, the features extractor is adapted but has to make sure that the autoencoder of the other tasks are still able to reconstruct the extracted features from the current samples. While these methods obtain good results for learning one new task, they become limited when it comes to learn several new tasks, especially in the one class per batch setting.
+
+Expandable models In the case of the multi-head setting, it has been proposed to use the previously learned layers and complete them with new layers trained on a new task. This strategy is presented in Progressive Networks (Rusu et al., 2016). In order to reduce the growth in memory caused by the new layers, the authors of Dynamically Expandable Networks (Yoon et al., 2018) proposed an hybrid method which retrains some of the previous weights and add new ones when necessary. Although these approaches work very well in the case of multi-head learning, they can not be adapted to single-head and are therefore not included in benchmarks with OvA-INN.
+
+# 3 CLASS-BY-CLASS CONTINUAL LEARNING WITH INVERTIBLE NETWORKS
+
+# 3.1 MOTIVATIONS AND CHALLENGE
+
+We investigate the problem of training several datasets in a sequential fashion with batches of only one class at a time. Most approaches of the state-of-the-art rely on updating a features extractor when data from a new class is available. But this strategy is unreliable in the special case we are interested in, namely batches of data from only one class. With few or no sample of negative data, it is very inefficient to update the weights of a network because the setting of deep learning normally involves vast amounts of data to be able to learn to extract valuable features. Without enough negative samples, the training is prone to overfit the new class. Recent works have proposed to rely on generative models to overcome this lack of data by generating samples of old classes. Nevertheless, updating a network with sampled data is not as efficient as with real data and, on the long run, the generative quality of early classes suffer from the multiple updates.
+
+# 3.2 OUT-OF-DISTRIBUTION DETECTION FOR CONTINUAL LEARNING
+
+Our approach consists in interpreting a Continual Learning problem as several out-of-distribution (OOD) detection problems. OOD detection has already been studied for neural networks and can be formulated as a binary classification problem which consists in predicting if an input $x$ was sampled from the same distribution as the training data or from a different distribution (Lee et al., 2017; Liang et al., 2017). Hence, for each class, we can train a network to predict if an input $x$ is likely to have been sampled from the distribution of this class. The class with the highest confidence can be used as the prediction of the class of $x$ . This training procedure is particularly suitable for Continual Learning since the training of each network does not require any negative sample.
+
+Using the same protocol as NICE (Dinh et al., 2014), for a class $i$ , it is possible to train a neural network $f _ { i }$ to fit a prior distribution $p$ and compute the exact log-likelihood $l _ { i }$ on a sample $x$ :
+
+$$
+l _ { i } ( x ) = \log ( p ( f _ { i } ( x ) )
+$$
+
+To obtain the formulation of log-likelihood as expressed in Equation 1, the network $f _ { i }$ has to respect some constraints discussed in Section 3.3. Keeping the same hypothesis as NICE, we consider the
+
+![](images/456f595d06cc297885c00ffc2d7ac7a9d223257fc4e9981da6bb6f6b36e45733.jpg)  
+Figure 1: Forward pass in an invertible block. $x$ is split in $x _ { 0 : n / 2 }$ and $x _ { n / 2 : n }$ . $f _ { 1 }$ and $f _ { 2 }$ can be any type of Neural Networks as long as the dimension of their output dimension is the same as their input dimension. In our experiments, we stack two of these blocks one after the other and use fully-connected feedforward layers for $f _ { 1 }$ and $f _ { 2 }$ .
+
+case where $p$ is a distribution with independent components $p _ { d }$
+
+$$
+p ( f _ { i } ( x ) ) = \prod _ { d } p _ { d } ( f _ { i , d } ( x ) )
+$$
+
+In our experiments, we considered $p _ { d }$ to be standard normal distributions. Although, it is possible to learn the parameters of the distributions, we found experimentally that doing so decreases the results. Under these design choices, the computation of the log-likelihood becomes :
+
+$$
+l _ { i } ( x ) = \sum _ { d } \log ( p _ { d } ( f _ { i , d } ( x ) ) = - \sum _ { d } \frac { 1 } { 2 } f _ { i , d } ( x ) ^ { 2 } + \sum _ { d } \log \left( \frac { 1 } { \sqrt { 2 \pi } } \right) = - \frac { 1 } { 2 } \| f _ { i } ( x ) \| _ { 2 } ^ { 2 } + \beta
+$$
+
+where $\beta = - n \log \left( { \sqrt { 2 \pi } } \right)$ is a constant term.
+
+Hence, identifying the network with the highest log-likelihood is equivalent to find the network with the smallest output norm.
+
+# 3.3 INVERTIBLE NEURAL NETWORKS
+
+The neural network architecture proposed by NICE is designed to operate a change of variables between two density functions. This assumes that the network is invertible and respect some constraints to make it efficiently computable.
+
+An invertible block (see Figure 1) consists in splitting the input $x$ into two subvectors $x _ { 1 }$ and $x _ { 2 }$ of equal size; then successively applying two (non necessarily invertible) networks $f _ { 1 }$ and $f _ { 2 }$ following the equation :
+
+$$
+\left\{ \begin{array} { l l } { y _ { 1 } = f _ { 1 } ( x _ { 2 } ) + x _ { 1 } } \\ { y _ { 2 } = f _ { 2 } ( y _ { 1 } ) + x _ { 2 } , } \end{array} \right.
+$$
+
+and finally, concatenate $y _ { 1 }$ and $y _ { 2 }$ . The inverse operation can be computed with :
+
+$$
+\left\{ \begin{array} { l l } { x _ { 2 } = y _ { 2 } - f _ { 2 } ( y _ { 1 } ) } \\ { x _ { 1 } = y _ { 1 } - f _ { 1 } ( x _ { 2 } ) . } \end{array} \right.
+$$
+
+These invertible equations illustrate how Invertible Networks operate a bijection between their input and their output.
+
+# 3.4 CONTINUAL LEARNING SETTING
+
+We propose to specialize each Invertible Network to a specific class by training them to output a vector with small norm when presented with data samples from their class. Given a dataset $\mathcal { X } _ { i }$ of class $i$ and an Invertible Network $f _ { i }$ , our objective is to minimize the loss $\mathcal { L }$ :
+
+$$
+\mathcal { L } ( \mathcal { X } _ { i } ) = \frac { 1 } { \vert \mathcal { X } _ { i } \vert } \sum _ { x \in \mathcal { X } _ { i } } \Vert f _ { i } ( x ) \Vert _ { 2 } ^ { 2 }
+$$
+
+Once the training has converged, the weights of this network won’t be updated when new classes will be added. At inference time, after learning $t$ classes, the predicted class $y ^ { * }$ for a sample $x$ is obtained by running each network and identifying the one with the smallest output :
+
+$$
+\boldsymbol { y } ^ { * } = \underset { \boldsymbol { y } = 1 , \ldots t } { \arg \operatorname* { m i n } } \| \boldsymbol { f } _ { \boldsymbol { y } } ( \boldsymbol { x } ) \| _ { 2 } ^ { 2 }
+$$
+
+As it is common practice in image processing, one can also use a preprocessing step by applying a fixed pretrained features extractor beforehand.
+
+# 4 EXPERIMENTAL RESULTS
+
+We compare our method against several state-of-the-art baselines for single-head learning on MNIST and CIFAR-100 datasets.
+
+# 4.1 IMPLEMENTATION DETAILS
+
+Topology of OvA-INN Due to the bijective nature of Invertible Networks, their output size is the same as their input size, hence the only way to change their size is by changing the depth or by compressing the parameters of the intermediate networks $f _ { 1 }$ and $f _ { 2 }$ . In our experiments, these networks are fully connected layers. To reduce memory footprint, we replace the square matrix of parameters $W$ of size $n \times n$ by a product of matrices $A B$ of sizes $n \times m$ and $m \times n$ (with a compressing factor for the first and second block $m = 1 6$ for MNIST and $m = 3 2$ for CIFAR-100). More details on the memory cost can be found in Appendix A.
+
+Regularization When performing learning one class at a time, the amount of training data can be highly reduced: only 500 training samples per class for CIFAR-100. To avoid overfitting the training set, we found that adding a weight decay regularization could increase the validation accuracy. More details on the hyperparameters choices can be found in Appendix B.
+
+Rescaling As ResNet has been trained on images of size $2 2 4 \times 2 2 4$ , we rescale CIFAR-100 images to match the size of images from Imagenet.
+
+# 4.2 EVALUATION ON MNIST
+
+We start by considering the MNIST dataset (LeCun et al., 1998), as it is a common benchmark that remains challenging in the case of single-head Continual Learning.
+
+# Baselines
+
+Generative models: - Parameter Generation and Model Adaptation (PGMA) (Hu et al., 2018) - Deep Generative Replay (DGR) (Shin et al., 2017)
+
+Coreset-based models: - iCaRL (Rebuffi et al., 2017) - SupportNet (Li et al., 2018)
+
+For Parameter Generation and Model Adaptation (PGMA) (Hu et al., 2018) and Deep Generative Replay (DGR) (Shin et al., 2017), we report the results from the original papers; whereas we use the provided code of SupportNet to compute the results for iCaRL and SupportNet with the conventional architecture of two layers of convolutions with poolings and a fully connected last layer. We have also set the coreset size to $s = 8 0 0$ samples.
+
+Table 1: Comparison of accuracy and memory cost in number of parameters (and memory usage for storing samples if relevant) of different approaches on MNIST at the end of the Continual Learning. The Learning type column indicates the number of classes used at each training step.   
+
+<table><tr><td>Model</td><td>Accuracy (%)</td><td>Memory cost</td><td>Learning type</td></tr><tr><td>PGMA (Hu et al., 2018)</td><td>81.7</td><td>6.000k</td><td>2 by 2</td></tr><tr><td>SupportNet (Li et al.,2018)</td><td>89.9</td><td>940k</td><td>2 by2</td></tr><tr><td>DGR (Shin et al., 2017)</td><td>95.8</td><td>12.700k</td><td>2 by 2</td></tr><tr><td>iCaRL (Rebuffi et al., 2017)</td><td>96.0</td><td>940k</td><td>2 by2</td></tr><tr><td>OvA-INN (this work)</td><td>96.4</td><td>520k</td><td>1by1</td></tr></table>
+
+# Analysis
+
+We report the average accuracy over all the classes after the networks have been trained on all batches (See Table 1). Our architecture does not use any pretrained features extractor common to every classes (contrarily to our CIFAR-100 experiment) : each sample is processed through an Invertible Network, composed of two stacked invertible blocks.
+
+Our approach presents better results than all the other reference methods while having a smaller cost in memory (see Appendix A) and being trained by batches of only one class. Also, our architecture relies on simple fully-connected layers (as parts of invertible layers) whilst the other baselines implement convolutional layers.
+
+# 4.3 EVALUATION ON CIFAR-100
+
+We now consider a more complex image dataset with a greater number of classes. This allows us to make comparisons in the case of a long sequence of data batches and to illustrate the value of using a pretrained features extractor for Continual Learning.
+
+# Baselines
+
+Distance-based model:
+
+- Nearest prototype : our implementation of the method consisting in computing the mean vector (prototype) of the output of a pretrained ResNet32 for each class at train time. Inference is performed by finding the closest prototype to the ResNet output of a given sample.
+
+Generative model:
+
+- FearNet (Kemker & Kanan, 2017) : uses a pretrained ResNet48 features extractor. FearNet is trained with a warm-up phase. Namely, the network is first trained with the all the first 50 classes of CIFAR-100, and subsequently learns the next 50 classes one by one in a continual fashion.
+
+Coreset-based models:
+
+- iCaRL (Rebuffi et al., 2017) : retrains a ResNet32 architecture on new data with a distillation loss. - End-to-end IL (Castro et al., 2018) $:$ retrains a ResNet32 architecture on new data with a crossentropy together with distillation loss.
+
+# Analysis
+
+The data is provided by batch of classes. When the training on a batch $( \mathcal { D } _ { i } )$ is completed, the accuracy of the classifier is evaluated on the test data of classes from all previous batches $( \mathcal { D } _ { 1 } , . . . , \mathcal { D } _ { i } )$ . We report the results from the literature with various size of batch when they are available.
+
+OvA-INN uses the weights of a ResNet32 pretrained on ImageNet and never update them. FearNet also uses pretrained weights from a ResNet. iCaRL and End-to-End IL use this architecture but retrain it from scratch at the beginning and fine-tune it with each new batch.
+
+The performance of the Nearest prototype baseline proves that there is high benefit in using pretrained features extractor on this kind of dataset. FearNet shows better performance by taking advantage of a warm-up phase with 50 classes. Still, we can see that OvA-INN is able to clearly outperform all the other approaches, reaching $72 \%$ accuracy after training on 100 classes. We can see that the performances of methods retraining ResNet from scratch (iCaRL and End-to-End IL)
+
+![](images/1ba544fef104c5dd97354bd844d1fe64150594f8aa4df798546373c629f875ae.jpg)  
+Figure 2: Comparison of the accuracy of several Continual Learning methods on CIFAR-100 with various batches of classes. FearNet’s curve has no point before 50 classes because the first 50 classes are learned in a non-continous fashion.
+
+quickly deteriorate compared to those using pretrained parameters. Even with larger batches of classes, the gap is still present.
+
+It can be surpising that at the end of its warm-up phase, FearNet still has an accuracy bellow OvAINN, even though it has been trained on all the data available at this point. It should be noted that FearNet is training an autoencoder and uses its encoding part as a features extractor (stacked on the ResNet) before classifying a sample. This can diminish the discriminative power of the network since it is also constrained to reproduce its input (only a single autoencoder is used for all classes).
+
+To further understand the effect of an Invertible Network on the feature space of a sample, we propose to project the different features spaces in 2D using t-SNE (Maaten & Hinton, 2008). We project the features of the five first classes of CIFAR-100 test set (see Figure 3). Classes that are already well represented in a cluster with ResNet features (like violet class) are clearly separated from the clusters of Invertible Networks. Classes represented with ambiguity with ResNet features (like light green and red) are better clustered in the Invertible Network space.
+
+# 5 DISCUSSION
+
+A limiting factor in our approach is the necessity to add a new network each time one wants to learn a new class. This makes the memory and computational cost of OvA-INN linear with the number of classes. Recent works in networks merging could alleviate the memory issue by sharing weights (Chou et al., 2018) or relying on weights superposition (Cheung et al., 2019). This being said, we showed that Ova-INN was able to achieve superior accuracy on CIFAR-100 class-by-class training than approaches reported in the literature, while using less parameters.
+
+Another constraint of using Invertible Networks is to keep the size of the output equal to the size of the input. When one wants to apply a features extractor with a high number of output channels, it can have a very negative impact on the memory consumption of the invertible layers. Feature Selection or Feature Aggregation techniques may help to alleviate this issue (Tang et al., 2014).
+
+![](images/8240c52921b53eac8428576bec9b09b1519e4387d4ff5ef7cd1dcc1943ce5920.jpg)  
+Figure 3: t-SNE projections of features spaces for five classes from CIFAR-100 test set (colors are given by the ground truth). (a): features space before applying Invertible Networks (black crosses are the clusters centers). $( b ) , ( c ) , ( d ) , ( e ) , ( f )$ : each features space after the Invertible Network of each class. The samples of a class represented by a network are clustered around the zero vector (black cross) whilst the samples from other classes appear further away from the cluster. Another visualization highlighting the differences between OvA-INN and Nearest Prototype is presented in Appendix D.
+
+Finally, we can notice that our approach is highly dependent on the quality of the pretrained features extractor. In our CIFAR-100, we had to rescale the input to make it compatible with ResNet. Nonetheless, recent research works show promising results in training features extractors in very efficient ways (Asano et al., 2019). Because it does not require to retrain its features extractor, we can foresee better performance in class-by-class learning with OvA-INN as new and more efficient features extractors are discovered.
+
+As a future research direction, one could try to incorporate our method in a Reinforcement Learning scenario where various situations can be learned separately in a first phase (each situation with its own Invertible Network). Then during a second phase where any situation can appear without the agent explicitly told in which situation it is in, the agent could rely on previously trained Invertible Networks to improve its policy. This setting is closely related to Options in Reinforcement Learning. Also, in a regression setting, one can add a fully connected layer after an intermediate layer of an Invertible Network and use it to predict the output for the trained class. At test time, one only need to read the output from the regression layer of the Invertible Network that had the highest confidence.
+
+# 6 CONCLUSION
+
+In this paper, we proposed a new approach for the challenging problem of single-head Continual Learning without storing any of the previous data. On top of a fixed pretrained neural network, we trained for each class an Invertible Network to refine the extracted features and maximize the loglikelihood on samples from its class. This way, we show that we can predict the class of a sample by running each Invertible Network and identifying the one with the highest log-likelihood. This setting allows us to take full benefit of pretrained models, which results in very good performances on the class-by-class training of CIFAR-100 compared to prior works.
+
+# REFERENCES
+
+Rahaf Aljundi, Francesca Babiloni, Mohamed Elhoseiny, Marcus Rohrbach, and Tinne Tuytelaars. Memory aware synapses: Learning what (not) to forget. In Proceedings of the European Conference on Computer Vision (ECCV), pp. 139–154, 2018.
+
+Yuki M Asano, Christian Rupprecht, and Andrea Vedaldi. Surprising effectiveness of few-image unsupervised feature learning. arXiv preprint arXiv:1904.13132, 2019.
+
+Francisco M Castro, Manuel J Mar´ın-Jimenez, Nicol ´ as Guil, Cordelia Schmid, and Karteek Alahari.´ End-to-end incremental learning. In Proceedings of the European Conference on Computer Vision (ECCV), pp. 233–248, 2018.
+
+Arslan Chaudhry, Puneet K Dokania, Thalaiyasingam Ajanthan, and Philip HS Torr. Riemannian walk for incremental learning: Understanding forgetting and intransigence. arXiv preprint arXiv:1801.10112, 2018.
+
+Brian Cheung, Alex Terekhov, Yubei Chen, Pulkit Agrawal, and Bruno A. Olshausen. Superposition of many models into one. CoRR, abs/1902.05522, 2019. URL http://arxiv.org/abs/ 1902.05522.
+
+Yi-Min Chou, Yi-Ming Chan, Jia-Hong Lee, Chih-Yi Chiu, and Chu-Song Chen. Unifying and merging well-trained deep neural networks for inference stage. In Proceedings of the Twenty-Seventh International Joint Conference on Artificial Intelligence, IJCAI-18, pp. 2049– 2056. International Joint Conferences on Artificial Intelligence Organization, 7 2018. doi: 10.24963/ijcai.2018/283. URL https://doi.org/10.24963/ijcai.2018/283.
+
+Laurent Dinh, David Krueger, and Yoshua Bengio. NICE: Non-linear independent components estimation. arXiv preprint arXiv:1410.8516, 2014.
+
+Sebastian Farquhar and Yarin Gal. Towards robust evaluations of continual learning. arXiv preprint arXiv:1805.09733, 2018.
+
+Ian Goodfellow, Yoshua Bengio, and Aaron Courville. Deep learning. 2016.
+
+Wenpeng Hu, Zhou Lin, Bing Liu, Chongyang Tao, Zhengwei Tao, Jinwen Ma, Dongyan Zhao, and Rui Yan. Overcoming catastrophic forgetting via model adaptation. 2018.
+
+Ronald Kemker and Christopher Kanan. FearNet: Brain-inspired model for incremental learning. arXiv preprint arXiv:1711.10563, 2017.
+
+Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
+
+James Kirkpatrick, Razvan Pascanu, Neil Rabinowitz, Joel Veness, Guillaume Desjardins, Andrei A Rusu, Kieran Milan, John Quan, Tiago Ramalho, Agnieszka Grabska-Barwinska, et al. Overcoming catastrophic forgetting in neural networks. Proceedings of the national academy of sciences, pp. 201611835, 2017.
+
+Yann LeCun, Leon Bottou, Yoshua Bengio, Patrick Haffner, et al. Gradient-based learning applied to document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998.
+
+Kimin Lee, Honglak Lee, Kibok Lee, and Jinwoo Shin. Training confidence-calibrated classifiers for detecting out-of-distribution samples. arXiv preprint arXiv:1711.09325, 2017.
+
+Yu Li, Zhongxiao Li, Lizhong Ding, Peng Yang, Yuhui Hu, Wei Chen, and Xin Gao. SupportNet: solving catastrophic forgetting in class incremental learning with support data. arXiv preprint arXiv:1806.02942, 2018.
+
+Zhizhong Li and Derek Hoiem. Learning without forgetting. IEEE Transactions on Pattern Analysis and Machine Intelligence, 40(12):2935–2947, 2018.
+
+Shiyu Liang, Yixuan Li, and Rayadurgam Srikant. Enhancing the reliability of out-of-distribution image detection in neural networks. arXiv preprint arXiv:1706.02690, 2017.
+
+David Lopez-Paz et al. Gradient episodic memory for continual learning. In Advances in Neural Information Processing Systems, pp. 6467–6476, 2017.
+
+Laurens van der Maaten and Geoffrey Hinton. Visualizing data using t-SNE. Journal of machine learning research, 9(Nov):2579–2605, 2008.
+
+Michael McCloskey and Neal J Cohen. Catastrophic interference in connectionist networks: The sequential learning problem. 24:109–165, 1989.
+
+German I Parisi, Ronald Kemker, Jose L Part, Christopher Kanan, and Stefan Wermter. Continual lifelong learning with neural networks: A review. arXiv preprint arXiv:1802.07569, 2018.
+
+Adam Paszke, Sam Gross, Soumith Chintala, Gregory Chanan, Edward Yang, Zachary DeVito, Zeming Lin, Alban Desmaison, Luca Antiga, and Adam Lerer. Automatic differentiation in pytorch. 2017.
+
+Amal Rannen, Rahaf Aljundi, Matthew B Blaschko, and Tinne Tuytelaars. Encoder based lifelong learning. pp. 1320–1328, 2017.
+
+Sylvestre-Alvise Rebuffi, Alexander Kolesnikov, Georg Sperl, and Christoph H Lampert. iCaRL: Incremental classifier and representation learning. pp. 5533–5542, 2017.
+
+Andrei A Rusu, Neil C Rabinowitz, Guillaume Desjardins, Hubert Soyer, James Kirkpatrick, Koray Kavukcuoglu, Razvan Pascanu, and Raia Hadsell. Progressive neural networks. arXiv preprint arXiv:1606.04671, 2016.
+
+Hanul Shin, Jung Kwon Lee, Jaehong Kim, and Jiwon Kim. Continual learning with deep generative replay. pp. 2990–2999, 2017.
+
+Jake Snell, Kevin Swersky, and Richard Zemel. Prototypical networks for few-shot learning. pp. 4077–4087, 2017.
+
+Jiliang Tang, Salem Alelyani, and Huan Liu. Feature selection for classification: A review. Data classification: Algorithms and applications, pp. 37, 2014.
+
+Gido M. van de Ven and Andreas S. Tolias. Three scenarios for continual learning. CoRR, abs/1904.07734, 2019. URL http://arxiv.org/abs/1904.07734.
+
+Oriol Vinyals, Charles Blundell, Timothy Lillicrap, Daan Wierstra, et al. Matching networks for one shot learning. pp. 3630–3638, 2016.
+
+Jaehong Yoon, Eunho Yang, Jeongtae Lee, and Sung Ju Hwang. Lifelong learning with dynamically expandable networks. arXiv preprint arXiv:1708.01547, 2017.
+
+Jaehong Yoon, Eunho Yang, Jeongtae Lee, and Sung Ju Hwang. Lifelong learning with dynamically expandable networks. 2018.
+
+Friedemann Zenke, Ben Poole, and Surya Ganguli. Continual learning through synaptic intelligence. pp. 3987–3995, 2017.
+
+# A MEMORY USAGE
+
+A.1 MNIST
+
+OvA-INN uses 2 blocks with 2 layers ( $f _ { 1 }$ and $f _ { 2 , }$ ) for 10 classes. The weight matrix of each layer $W$ is a product of two matrices $A$ and $B$ of size $3 9 2 \times 1 6$ and $1 6 \times 3 9 2$ . The memory required for OvA-INN is :
+
+$$
+S _ { \mathrm { O v A - I N N , M N I S T } } = ( 3 9 2 \times 1 6 \times 2 + 3 9 2 ) \times 2 \times 2 \times 1 0 = 5 1 7 4 4 0
+$$
+
+We set the coreset size of iCaRL and SupportNet to $s = 8 0 0$ with each image of size $2 8 \times 2 8$ , the convolutional network is composed of a layer of 64 channels with $5 \times 5$ kernel, a layer of 32
+
+channels with $5 \times 5$ kernel, a fully-connected layer with 100 channels applied on an input of size $7 \times 7$ and a final layer of 10 channels :
+
+${ \mathfrak { H } } _ { \mathrm { i C a R , M N I S T } } = 2 8 \times 2 8 \times 8 0 0 + ( 5 \times 5 + 1 ) \times 3 2 + ( 5 \times 5 + 1 ) \times 6 4 + ( 7 \times 7 \times 6 4 + 1 ) \times 1 0 0 + ( 1 \times 1 0 0 ) \times 2 = 2 4$ $( 1 0 0 + 1 ) \times 1 0 = 9 4 4 4 0 6$
+
+# A.2 CIFAR-100
+
+Since every method rely on a ResNet32 (around 20M parameters) to compute their features (except FearNet which uses ResNet48). We do not count the features extractor in the memory consumption.
+
+OvA-INN uses 2 blocks with 2 layers ( $f _ { 1 }$ and $f _ { 2 } ^ { \mathrm { ~ ~ } } ,$ ) for 100 classes. The weight matrix of each layer $W$ is a product of two matrices $A$ and $B$ of size $2 5 6 \times 3 2$ and $3 2 \times 2 5 6$ . The memory required is :
+
+$$
+S _ { \mathrm { O v A - I N N , C I F A R } } = ( 2 5 6 \times 3 2 \times 2 + 2 5 6 ) \times 2 \times 2 \times 1 0 0 = 6 6 5 6 0 0 0
+$$
+
+We use the default coreset size $s = 2 0 0 0$ of iCaRL and End-to-End $\mathrm { I L }$ with each image of size $3 2 \times 3 2$ :
+
+$$
+S _ { \mathrm { i C a R L , C I F A R } } = 3 2 \times 3 2 \times 3 \times 2 0 0 0 = 6 1 4 4 0 0 0
+$$
+
+# B HYPERPARAMETERS SETTINGS
+
+Our implementation is done with Pytorch (Paszke et al., 2017), using the Adam optimizer (Kingma & Ba, 2014) and a scheduler that reduces the learning rate by a factor of 0.5 when the loss stops improving. We use the resize transformation from torchvision with the default bilinear interpolation.
+
+Table 2: MNIST Hyperparameters   
+
+<table><tr><td>Hyperparameter</td><td>Value</td></tr><tr><td>Learning Rate</td><td>0.002</td></tr><tr><td>Number of epochs</td><td>200</td></tr><tr><td>Weight decay</td><td>0.0</td></tr><tr><td>Patience</td><td>20</td></tr></table>
+
+Table 3: CIFAR-100 Hyperparameters   
+
+<table><tr><td>Hyperparameter</td><td>Value</td></tr><tr><td></td><td></td></tr><tr><td>Learning Rate</td><td>0.002</td></tr><tr><td>Number of epochs Weight decay</td><td>1000 0.0002</td></tr><tr><td>Patience</td><td>30</td></tr></table>
+
+Table 4: t-SNE Hyperparameters   
+
+<table><tr><td>Hyperparameter</td><td>Value</td></tr><tr><td></td><td></td></tr><tr><td>Perplexity</td><td>15.0</td></tr><tr><td>Principal Components</td><td>50</td></tr><tr><td>Steps</td><td>400</td></tr></table>
+
+# C TASK-BY-TASK LEARNING
+
+We provide additional experimental results on the multi-head learning of CIFAR100 with 10 tasks of 10 classes each. The training procedure of OvA-INN does not change from the usual single-head learning but, at test time, the evaluation is processed by batches of 10 classes. The accuracy score is the average accuracy over all 10 tasks. We report the results from (Yoon et al., 2017). Although our approach is able to match state-of-the-art results in accuracy, it should be noticed that it is drastically more memory and time consuming than the other baselines.
+
+<table><tr><td>Model</td><td>Accuracy (%)</td></tr><tr><td></td><td></td></tr><tr><td>EWC(Kirkpatrick et al., 2017)</td><td>81.34</td></tr><tr><td>Progressive Networks (Rusu et al., 2016)</td><td>88.19</td></tr><tr><td>DEN (Yoon et al., 2017)</td><td>92.25</td></tr><tr><td>OvA-INN</td><td>92.58</td></tr></table>
+
+# D VISUALIZATION
+
+We highlight the differences between OvA-INN and Nearest Prototype when classifying 20 classes of CIFAR-100 in Figure 4.
+
+![](images/02e4c855ccb13188bd983f8e9f0b207a784e5a6405a1adf39e60f6c338389052.jpg)  
+Figure 4: top: t-SNE projection of the features space before applying Invertible Networks (black crosses are the clusters centers) for 20 classes from CIFAR-100 test set (colors are given by the ground truth). bottom: in blue and yellow are the samples correctly and wrongly classified by both Nearest Prototype and OvA-INN, in green the samples better classified by OvA-INN than Nearest Prototype and orange the samples better classified by Nearest Prototype than OvA-INN.

parse/train/rJxcBpNKPr/rJxcBpNKPr_content_list.json

@@ -0,0 +1,1681 @@
+[
+    {
+        "type": "text",
+        "text": "OVA-INN: CONTINUAL LEARNING WITH INVERTIBLE NEURAL NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            99,
+            823,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            171,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            236,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In the field of Continual Learning, the objective is to learn several tasks one after the other without access to the data from previous tasks. Several solutions have been proposed to tackle this problem but they usually assume that the user knows which of the tasks to perform at test time on a particular sample, or rely on small samples from previous data and most of them suffer of a substantial drop in accuracy when updated with batches of only one class at a time. In this article, we propose a new method, OvA-INN, which is able to learn one class at a time and without storing any of the previous data. To achieve this, for each class, we train a specific Invertible Neural Network to extract the relevant features to compute the likelihood on this class. At test time, we can predict the class of a sample by identifying the network which predicted the highest likelihood. With this method, we show that we can take advantage of pretrained models by stacking an Invertible Network on top of a features extractor. This way, we are able to outperform stateof-the-art approaches that rely on features learning for the Continual Learning of MNIST and CIFAR-100 datasets. In our experiments, we reach $72 \\%$ accuracy on CIFAR-100 after training our model one class at a time. ",
+        "bbox": [
+            233,
+            270,
+            764,
+            493
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            530,
+            334,
+            546
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "A typical Deep Learning workflow consists in gathering data, training a model on this data and finally deploying the model in the real world (Goodfellow et al., 2016). If one would need to update the model with new data, it would require to merge the old and new data and process a training from scratch on this new dataset. Nevertheless, there are circumstances where this method may not apply. For example, it may not be possible to store the old data because of privacy issues (health records, sensible data) or memory limitations (embedded systems, very large datasets). In order to address those limitations, recent works propose a variety of approaches in a setting called Continual Learning (Parisi et al., 2018). ",
+        "bbox": [
+            174,
+            565,
+            825,
+            676
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In Continual Learning, we aim to learn the parameters $w$ of a model on a sequence of datasets $\\mathcal { D } _ { i } = \\{ ( x _ { i } ^ { j } , y _ { i } ^ { j } ) \\} _ { j = 1 } ^ { n _ { i } }$ with the inputs $x _ { i } ^ { j } \\in \\mathcal { X } ^ { i }$ and the labels $y _ { i } ^ { j } \\in \\mathcal { V } ^ { i }$ , to predict $p ( y ^ { * } | w , x ^ { * } )$ for an unseen pair $( x ^ { * } , y ^ { * } )$ . The training has to be done on each dataset, one after the other, without the possibility to reuse previous datasets. The performance of a Continual Learning algorithm can then be measured with two protocols : multi-head or single-head. In the multi-head scenario, the task identifier $i$ is known at test time. For evaluating performances on task $i$ , the set of all possible labels is then $\\mathcal { V } = \\mathcal { V } ^ { i }$ . Whilst in the single-head scenario, the task identifier is unknown, in that case we have $\\mathcal { V } = \\cup _ { i = 1 } ^ { N } \\mathcal { V } ^ { i }$ with $N$ the number of tasks learned so far. For example, let us say that the goal is to learn MNIST sequentially with two batches: using only the data from the first five classes and then only the data from the remaining five other classes. In multi-head learning, one asks at test time to be able to recognize samples of 0-4 among the classes 0-4 and samples of 5-9 among classes 5-9. On the other hand, in single-head learning, one can not assume from which batch a sample is coming from, hence the need to be able to recognize any samples of 0-9 among classes 0-9. Although the former one has received the most attention from researchers, the last one fits better to the desiderata of a Continual Learning system as expressed in Farquhar & Gal (2018) and (van de Ven & Tolias, 2019). The single-head scenario is also notoriously harder than its multi-head counterpart (Chaudhry et al., 2018) and is the focus of the present work. ",
+        "bbox": [
+            174,
+            684,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Updating the parameters with data from a new dataset exposes the model to drastically deteriorate its performance on previous data, a phenomenon known as catastrophic forgetting (McCloskey & Cohen, 1989). To alleviate this problem, researchers have proposed a variety of approaches such as storing a few samples from previous datasets (Rebuffi et al., 2017), adding distillation regularization (Li & Hoiem, 2018), updating the parameters according to their usefulness on previous datasets (Kirkpatrick et al., 2017), using a generative model to produce samples from previous datasets (Kemker & Kanan, 2017). Despite those efforts toward a more realistic setting of Continual Learning, one can notice that, most of the time, results are proposed in the case of a sequence of batches of multiple classes. This scenario often ends up with better accuracy (because the learning procedure highly benefits of the diversity of classes to find the best tuning of parameters) but it does not illustrate the behavior of those methods in the worst case scenario. In fact, Continual Learning algorithms should be robust in the size of the batch of classes. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            270
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this work, we propose to implement a method specially designed to handle the case where each task consists of only one class. It will therefore be evaluated in the single-head scenario. Our approach, named One-versus-All Invertible Neural Networks (OvA-INN), is based on an invertible neural network architecture proposed by Dinh et al. (2014). We use it in a One-versus-All strategy : each network is trained to make a prediction of a class and the most confident one on a sample is used to identify the class of the sample. In contrast to most other methods, the training phase of each class can be independently executed from one another. ",
+        "bbox": [
+            174,
+            277,
+            825,
+            375
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The contributions of our work are : (i) a new approach for Continual Learning with one class per batch; (ii) a neural architecture based on Invertible Networks that does not require to store any of the previous data; (iii) state-of-the-art results on several tasks of Continual Learning for Computer Vision (CIFAR-100, MNIST) in this setting. ",
+        "bbox": [
+            176,
+            382,
+            825,
+            438
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We start by reviewing the closest methods to our approach in Section 2, then explain our method in Section 3, analyse its performances in Section 4 and identify limitations and possible extensions in Section 5. ",
+        "bbox": [
+            176,
+            444,
+            825,
+            486
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            516,
+            339,
+            532
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Generative models Inspired by biological mechanisms such as the hippocampal system that rapidly encodes recent experiences and the memory of the neocortex that is consolidated during sleep phases, a natural approach is to produce samples of previous data that can be added to the new data to learn a new task. FearNet (Kemker & Kanan, 2017) relies on an architecture based on an autoencoder, whereas Deep Generative Replay (Shin et al., 2017) and Parameter Generation and Model Adaptation (Hu et al., 2018) propose to use a generative adversarial network. Those methods present good results but require complex models to be able to generate reliable data. Furthermore, it is difficult to assess the relevance of the generated data to conduct subsequent training iterations. ",
+        "bbox": [
+            174,
+            553,
+            825,
+            665
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Coreset-based models These approaches alleviate the constraint on the availability of data by allowing the storage of a few samples from previous data (which are called coreset). iCaRL (Rebuffi et al., 2017) and End-to-end IL (Castro et al., 2018) store 2000 samples from previous batches and rely on respectively a distillation loss and a mixture of cross-entropy and distillation loss to alleviate forgetting. The authors of SupportNet (Li et al., 2018) have also proposed a strategy to select relevant samples for the coreset. Gradient Episodic Memory (Lopez-Paz et al., 2017) ensures that gradients computed on new tasks do not interfere with the loss of previous tasks. Those approaches give the best results for single-head learning. But, similarly to generated data, it is not clear which data may be useful to conduct further training iterations. In this paper, we are challenging the need of the coreset for single-head learning. ",
+        "bbox": [
+            174,
+            689,
+            825,
+            829
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Distance-based models These methods propose to embed the data in a space which can be used to identify the class of a sample by computing a distance between the embedding of the sample and a reference for each class. Among the most popular, we can cite Matching Networks (Vinyals et al., 2016) and Prototypical Networks (Snell et al., 2017), but these methods have been mostly applied to few-shot learning scenarios rather than continual. ",
+        "bbox": [
+            174,
+            854,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Regularization-based approaches These approaches present an attempt to mitigate the effect of catastrophic forgetting by imposing some constraints on the loss function when training subsequent classes. Elastic Weight Consolidation (Kirkpatrick et al., 2017), Synaptic Intelligence (Zenke et al., 2017) and Memory Aware Synapses (Aljundi et al., 2018) all seek to prevent the update of weights that were the most useful to discriminate between previous classes. Hence, it is possible to constrain the learning of a new task in such a way that the most relevant weights for the previous tasks are less susceptible to be updated. Learning without forgetting (Li & Hoiem, 2018) proposes to use knowledge distillation to preserve previous performances. The network is divided in two parts : the shared weights and the dedicated weights for each task. When learning a new task A, the data of A get assigned “soft” labels by computing the output by the network with the dedicated weight for each previous task. Then the network is trained with the loss of task A and is also constrained to reproduce the recorded output for each other tasks. In Rannen et al. (2017), the authors propose to use an autoencoder to reconstruct the extracted features for each task. When learning a new task, the features extractor is adapted but has to make sure that the autoencoder of the other tasks are still able to reconstruct the extracted features from the current samples. While these methods obtain good results for learning one new task, they become limited when it comes to learn several new tasks, especially in the one class per batch setting. ",
+        "bbox": [
+            174,
+            104,
+            825,
+            339
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Expandable models In the case of the multi-head setting, it has been proposed to use the previously learned layers and complete them with new layers trained on a new task. This strategy is presented in Progressive Networks (Rusu et al., 2016). In order to reduce the growth in memory caused by the new layers, the authors of Dynamically Expandable Networks (Yoon et al., 2018) proposed an hybrid method which retrains some of the previous weights and add new ones when necessary. Although these approaches work very well in the case of multi-head learning, they can not be adapted to single-head and are therefore not included in benchmarks with OvA-INN. ",
+        "bbox": [
+            174,
+            356,
+            825,
+            453
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 CLASS-BY-CLASS CONTINUAL LEARNING WITH INVERTIBLE NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            474,
+            813,
+            491
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 MOTIVATIONS AND CHALLENGE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            506,
+            437,
+            521
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We investigate the problem of training several datasets in a sequential fashion with batches of only one class at a time. Most approaches of the state-of-the-art rely on updating a features extractor when data from a new class is available. But this strategy is unreliable in the special case we are interested in, namely batches of data from only one class. With few or no sample of negative data, it is very inefficient to update the weights of a network because the setting of deep learning normally involves vast amounts of data to be able to learn to extract valuable features. Without enough negative samples, the training is prone to overfit the new class. Recent works have proposed to rely on generative models to overcome this lack of data by generating samples of old classes. Nevertheless, updating a network with sampled data is not as efficient as with real data and, on the long run, the generative quality of early classes suffer from the multiple updates. ",
+        "bbox": [
+            174,
+            532,
+            825,
+            672
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2 OUT-OF-DISTRIBUTION DETECTION FOR CONTINUAL LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            690,
+            661,
+            704
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our approach consists in interpreting a Continual Learning problem as several out-of-distribution (OOD) detection problems. OOD detection has already been studied for neural networks and can be formulated as a binary classification problem which consists in predicting if an input $x$ was sampled from the same distribution as the training data or from a different distribution (Lee et al., 2017; Liang et al., 2017). Hence, for each class, we can train a network to predict if an input $x$ is likely to have been sampled from the distribution of this class. The class with the highest confidence can be used as the prediction of the class of $x$ . This training procedure is particularly suitable for Continual Learning since the training of each network does not require any negative sample. ",
+        "bbox": [
+            174,
+            715,
+            825,
+            828
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Using the same protocol as NICE (Dinh et al., 2014), for a class $i$ , it is possible to train a neural network $f _ { i }$ to fit a prior distribution $p$ and compute the exact log-likelihood $l _ { i }$ on a sample $x$ : ",
+        "bbox": [
+            174,
+            834,
+            823,
+            863
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/43c30d9c3e00602b4e6d9c5f2e42c83430b1b11223e0a9ae91e3ed42bdc5ff13.jpg",
+        "text": "$$\nl _ { i } ( x ) = \\log ( p ( f _ { i } ( x ) )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            428,
+            871,
+            570,
+            887
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To obtain the formulation of log-likelihood as expressed in Equation 1, the network $f _ { i }$ has to respect some constraints discussed in Section 3.3. Keeping the same hypothesis as NICE, we consider the ",
+        "bbox": [
+            174,
+            895,
+            826,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/456f595d06cc297885c00ffc2d7ac7a9d223257fc4e9981da6bb6f6b36e45733.jpg",
+        "image_caption": [
+            "Figure 1: Forward pass in an invertible block. $x$ is split in $x _ { 0 : n / 2 }$ and $x _ { n / 2 : n }$ . $f _ { 1 }$ and $f _ { 2 }$ can be any type of Neural Networks as long as the dimension of their output dimension is the same as their input dimension. In our experiments, we stack two of these blocks one after the other and use fully-connected feedforward layers for $f _ { 1 }$ and $f _ { 2 }$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            236,
+            98,
+            763,
+            284
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "case where $p$ is a distribution with independent components $p _ { d }$ ",
+        "bbox": [
+            173,
+            375,
+            593,
+            390
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f4ea07454527597db7b56dd1acc9daa314cfc30cc50a250a65fbc45c3cca8023.jpg",
+        "text": "$$\np ( f _ { i } ( x ) ) = \\prod _ { d } p _ { d } ( f _ { i , d } ( x ) )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            408,
+            393,
+            589,
+            426
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In our experiments, we considered $p _ { d }$ to be standard normal distributions. Although, it is possible to learn the parameters of the distributions, we found experimentally that doing so decreases the results. Under these design choices, the computation of the log-likelihood becomes : ",
+        "bbox": [
+            174,
+            429,
+            826,
+            472
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/905404cdf9a3072485d8a7978035dbc9d5a3b0c17e8e1b7966c4b92fc16ea8c3.jpg",
+        "text": "$$\nl _ { i } ( x ) = \\sum _ { d } \\log ( p _ { d } ( f _ { i , d } ( x ) ) = - \\sum _ { d } \\frac { 1 } { 2 } f _ { i , d } ( x ) ^ { 2 } + \\sum _ { d } \\log \\left( \\frac { 1 } { \\sqrt { 2 \\pi } } \\right) = - \\frac { 1 } { 2 } \\| f _ { i } ( x ) \\| _ { 2 } ^ { 2 } + \\beta\n$$",
+        "text_format": "latex",
+        "bbox": [
+            199,
+            474,
+            779,
+            513
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\beta = - n \\log \\left( { \\sqrt { 2 \\pi } } \\right)$ is a constant term. ",
+        "bbox": [
+            173,
+            517,
+            473,
+            541
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Hence, identifying the network with the highest log-likelihood is equivalent to find the network with the smallest output norm. ",
+        "bbox": [
+            174,
+            546,
+            825,
+            577
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.3 INVERTIBLE NEURAL NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            592,
+            449,
+            607
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The neural network architecture proposed by NICE is designed to operate a change of variables between two density functions. This assumes that the network is invertible and respect some constraints to make it efficiently computable. ",
+        "bbox": [
+            173,
+            617,
+            825,
+            661
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "An invertible block (see Figure 1) consists in splitting the input $x$ into two subvectors $x _ { 1 }$ and $x _ { 2 }$ of equal size; then successively applying two (non necessarily invertible) networks $f _ { 1 }$ and $f _ { 2 }$ following the equation : ",
+        "bbox": [
+            174,
+            667,
+            825,
+            709
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0f55c08a231df525d2c774f44b2bac4db3e1882df5d041bf65b13d9085fc12c8.jpg",
+        "text": "$$\n\\left\\{ \\begin{array} { l l } { y _ { 1 } = f _ { 1 } ( x _ { 2 } ) + x _ { 1 } } \\\\ { y _ { 2 } = f _ { 2 } ( y _ { 1 } ) + x _ { 2 } , } \\end{array} \\right.\n$$",
+        "text_format": "latex",
+        "bbox": [
+            421,
+            708,
+            558,
+            744
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "and finally, concatenate $y _ { 1 }$ and $y _ { 2 }$ . The inverse operation can be computed with : ",
+        "bbox": [
+            171,
+            746,
+            700,
+            761
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e32f665b9e80973f13595fef454e73cacb83a06ba0fc89f3381cda452ef5669b.jpg",
+        "text": "$$\n\\left\\{ \\begin{array} { l l } { x _ { 2 } = y _ { 2 } - f _ { 2 } ( y _ { 1 } ) } \\\\ { x _ { 1 } = y _ { 1 } - f _ { 1 } ( x _ { 2 } ) . } \\end{array} \\right.\n$$",
+        "text_format": "latex",
+        "bbox": [
+            419,
+            763,
+            560,
+            800
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "These invertible equations illustrate how Invertible Networks operate a bijection between their input and their output. ",
+        "bbox": [
+            174,
+            810,
+            825,
+            840
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.4 CONTINUAL LEARNING SETTING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            856,
+            442,
+            871
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We propose to specialize each Invertible Network to a specific class by training them to output a vector with small norm when presented with data samples from their class. Given a dataset $\\mathcal { X } _ { i }$ of class $i$ and an Invertible Network $f _ { i }$ , our objective is to minimize the loss $\\mathcal { L }$ : ",
+        "bbox": [
+            174,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8b70135a37387263ebf0d993e8242ad9b0476bfc069ddf65ba48bc60f89e36d7.jpg",
+        "text": "$$\n\\mathcal { L } ( \\mathcal { X } _ { i } ) = \\frac { 1 } { \\vert \\mathcal { X } _ { i } \\vert } \\sum _ { x \\in \\mathcal { X } _ { i } } \\Vert f _ { i } ( x ) \\Vert _ { 2 } ^ { 2 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            403,
+            114,
+            594,
+            155
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Once the training has converged, the weights of this network won’t be updated when new classes will be added. At inference time, after learning $t$ classes, the predicted class $y ^ { * }$ for a sample $x$ is obtained by running each network and identifying the one with the smallest output : ",
+        "bbox": [
+            173,
+            166,
+            826,
+            209
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/85fc653e05e139d51c30f28ff999f84a5bba7f6be8204bf6da4a2d568368b385.jpg",
+        "text": "$$\n\\boldsymbol { y } ^ { * } = \\underset { \\boldsymbol { y } = 1 , \\ldots t } { \\arg \\operatorname* { m i n } } \\| \\boldsymbol { f } _ { \\boldsymbol { y } } ( \\boldsymbol { x } ) \\| _ { 2 } ^ { 2 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            421,
+            229,
+            578,
+            257
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "As it is common practice in image processing, one can also use a preprocessing step by applying a fixed pretrained features extractor beforehand. ",
+        "bbox": [
+            173,
+            270,
+            825,
+            297
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTAL RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            320,
+            419,
+            337
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We compare our method against several state-of-the-art baselines for single-head learning on MNIST and CIFAR-100 datasets. ",
+        "bbox": [
+            173,
+            353,
+            823,
+            381
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 IMPLEMENTATION DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            400,
+            403,
+            414
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Topology of OvA-INN Due to the bijective nature of Invertible Networks, their output size is the same as their input size, hence the only way to change their size is by changing the depth or by compressing the parameters of the intermediate networks $f _ { 1 }$ and $f _ { 2 }$ . In our experiments, these networks are fully connected layers. To reduce memory footprint, we replace the square matrix of parameters $W$ of size $n \\times n$ by a product of matrices $A B$ of sizes $n \\times m$ and $m \\times n$ (with a compressing factor for the first and second block $m = 1 6$ for MNIST and $m = 3 2$ for CIFAR-100). More details on the memory cost can be found in Appendix A. ",
+        "bbox": [
+            173,
+            426,
+            825,
+            525
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Regularization When performing learning one class at a time, the amount of training data can be highly reduced: only 500 training samples per class for CIFAR-100. To avoid overfitting the training set, we found that adding a weight decay regularization could increase the validation accuracy. More details on the hyperparameters choices can be found in Appendix B. ",
+        "bbox": [
+            174,
+            541,
+            825,
+            597
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Rescaling As ResNet has been trained on images of size $2 2 4 \\times 2 2 4$ , we rescale CIFAR-100 images to match the size of images from Imagenet. ",
+        "bbox": [
+            174,
+            614,
+            823,
+            643
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.2 EVALUATION ON MNIST ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            661,
+            390,
+            676
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We start by considering the MNIST dataset (LeCun et al., 1998), as it is a common benchmark that remains challenging in the case of single-head Continual Learning. ",
+        "bbox": [
+            174,
+            688,
+            823,
+            717
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Baselines ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            734,
+            240,
+            748
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Generative models: - Parameter Generation and Model Adaptation (PGMA) (Hu et al., 2018) - Deep Generative Replay (DGR) (Shin et al., 2017) ",
+        "bbox": [
+            173,
+            756,
+            651,
+            797
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Coreset-based models: - iCaRL (Rebuffi et al., 2017) - SupportNet (Li et al., 2018) ",
+        "bbox": [
+            173,
+            805,
+            369,
+            847
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For Parameter Generation and Model Adaptation (PGMA) (Hu et al., 2018) and Deep Generative Replay (DGR) (Shin et al., 2017), we report the results from the original papers; whereas we use the provided code of SupportNet to compute the results for iCaRL and SupportNet with the conventional architecture of two layers of convolutions with poolings and a fully connected last layer. We have also set the coreset size to $s = 8 0 0$ samples. ",
+        "bbox": [
+            174,
+            854,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/b169d333a9c7beecfeef621dc8e364f81be3aff2fa48631ec7b835a47e1db142.jpg",
+        "table_caption": [
+            "Table 1: Comparison of accuracy and memory cost in number of parameters (and memory usage for storing samples if relevant) of different approaches on MNIST at the end of the Continual Learning. The Learning type column indicates the number of classes used at each training step. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Accuracy (%)</td><td>Memory cost</td><td>Learning type</td></tr><tr><td>PGMA (Hu et al., 2018)</td><td>81.7</td><td>6.000k</td><td>2 by 2</td></tr><tr><td>SupportNet (Li et al.,2018)</td><td>89.9</td><td>940k</td><td>2 by2</td></tr><tr><td>DGR (Shin et al., 2017)</td><td>95.8</td><td>12.700k</td><td>2 by 2</td></tr><tr><td>iCaRL (Rebuffi et al., 2017)</td><td>96.0</td><td>940k</td><td>2 by2</td></tr><tr><td>OvA-INN (this work)</td><td>96.4</td><td>520k</td><td>1by1</td></tr></table>",
+        "bbox": [
+            174,
+            155,
+            813,
+            242
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Analysis ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            268,
+            235,
+            284
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We report the average accuracy over all the classes after the networks have been trained on all batches (See Table 1). Our architecture does not use any pretrained features extractor common to every classes (contrarily to our CIFAR-100 experiment) : each sample is processed through an Invertible Network, composed of two stacked invertible blocks. ",
+        "bbox": [
+            174,
+            290,
+            825,
+            345
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Our approach presents better results than all the other reference methods while having a smaller cost in memory (see Appendix A) and being trained by batches of only one class. Also, our architecture relies on simple fully-connected layers (as parts of invertible layers) whilst the other baselines implement convolutional layers. ",
+        "bbox": [
+            174,
+            353,
+            823,
+            410
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.3 EVALUATION ON CIFAR-100 ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            428,
+            418,
+            443
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We now consider a more complex image dataset with a greater number of classes. This allows us to make comparisons in the case of a long sequence of data batches and to illustrate the value of using a pretrained features extractor for Continual Learning. ",
+        "bbox": [
+            176,
+            455,
+            823,
+            497
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Baselines ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            513,
+            240,
+            529
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Distance-based model: ",
+        "bbox": [
+            174,
+            536,
+            325,
+            549
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "- Nearest prototype : our implementation of the method consisting in computing the mean vector (prototype) of the output of a pretrained ResNet32 for each class at train time. Inference is performed by finding the closest prototype to the ResNet output of a given sample. ",
+        "bbox": [
+            174,
+            550,
+            825,
+            592
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Generative model: ",
+        "bbox": [
+            174,
+            599,
+            295,
+            612
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "- FearNet (Kemker & Kanan, 2017) : uses a pretrained ResNet48 features extractor. FearNet is trained with a warm-up phase. Namely, the network is first trained with the all the first 50 classes of CIFAR-100, and subsequently learns the next 50 classes one by one in a continual fashion. ",
+        "bbox": [
+            174,
+            613,
+            825,
+            655
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Coreset-based models: ",
+        "bbox": [
+            174,
+            661,
+            323,
+            675
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "- iCaRL (Rebuffi et al., 2017) : retrains a ResNet32 architecture on new data with a distillation loss. - End-to-end IL (Castro et al., 2018) $:$ retrains a ResNet32 architecture on new data with a crossentropy together with distillation loss. ",
+        "bbox": [
+            174,
+            674,
+            825,
+            717
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Analysis ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            734,
+            235,
+            750
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The data is provided by batch of classes. When the training on a batch $( \\mathcal { D } _ { i } )$ is completed, the accuracy of the classifier is evaluated on the test data of classes from all previous batches $( \\mathcal { D } _ { 1 } , . . . , \\mathcal { D } _ { i } )$ . We report the results from the literature with various size of batch when they are available. ",
+        "bbox": [
+            174,
+            756,
+            823,
+            797
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "OvA-INN uses the weights of a ResNet32 pretrained on ImageNet and never update them. FearNet also uses pretrained weights from a ResNet. iCaRL and End-to-End IL use this architecture but retrain it from scratch at the beginning and fine-tune it with each new batch. ",
+        "bbox": [
+            176,
+            804,
+            821,
+            847
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The performance of the Nearest prototype baseline proves that there is high benefit in using pretrained features extractor on this kind of dataset. FearNet shows better performance by taking advantage of a warm-up phase with 50 classes. Still, we can see that OvA-INN is able to clearly outperform all the other approaches, reaching $72 \\%$ accuracy after training on 100 classes. We can see that the performances of methods retraining ResNet from scratch (iCaRL and End-to-End IL) ",
+        "bbox": [
+            174,
+            854,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/1ba544fef104c5dd97354bd844d1fe64150594f8aa4df798546373c629f875ae.jpg",
+        "image_caption": [
+            "Figure 2: Comparison of the accuracy of several Continual Learning methods on CIFAR-100 with various batches of classes. FearNet’s curve has no point before 50 classes because the first 50 classes are learned in a non-continous fashion. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            215,
+            106,
+            779,
+            435
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "quickly deteriorate compared to those using pretrained parameters. Even with larger batches of classes, the gap is still present. ",
+        "bbox": [
+            173,
+            526,
+            823,
+            554
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "It can be surpising that at the end of its warm-up phase, FearNet still has an accuracy bellow OvAINN, even though it has been trained on all the data available at this point. It should be noted that FearNet is training an autoencoder and uses its encoding part as a features extractor (stacked on the ResNet) before classifying a sample. This can diminish the discriminative power of the network since it is also constrained to reproduce its input (only a single autoencoder is used for all classes). ",
+        "bbox": [
+            174,
+            561,
+            825,
+            631
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To further understand the effect of an Invertible Network on the feature space of a sample, we propose to project the different features spaces in 2D using t-SNE (Maaten & Hinton, 2008). We project the features of the five first classes of CIFAR-100 test set (see Figure 3). Classes that are already well represented in a cluster with ResNet features (like violet class) are clearly separated from the clusters of Invertible Networks. Classes represented with ambiguity with ResNet features (like light green and red) are better clustered in the Invertible Network space. ",
+        "bbox": [
+            174,
+            637,
+            825,
+            722
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5 DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            743,
+            310,
+            760
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "A limiting factor in our approach is the necessity to add a new network each time one wants to learn a new class. This makes the memory and computational cost of OvA-INN linear with the number of classes. Recent works in networks merging could alleviate the memory issue by sharing weights (Chou et al., 2018) or relying on weights superposition (Cheung et al., 2019). This being said, we showed that Ova-INN was able to achieve superior accuracy on CIFAR-100 class-by-class training than approaches reported in the literature, while using less parameters. ",
+        "bbox": [
+            174,
+            776,
+            825,
+            861
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Another constraint of using Invertible Networks is to keep the size of the output equal to the size of the input. When one wants to apply a features extractor with a high number of output channels, it can have a very negative impact on the memory consumption of the invertible layers. Feature Selection or Feature Aggregation techniques may help to alleviate this issue (Tang et al., 2014). ",
+        "bbox": [
+            176,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/8240c52921b53eac8428576bec9b09b1519e4387d4ff5ef7cd1dcc1943ce5920.jpg",
+        "image_caption": [
+            "Figure 3: t-SNE projections of features spaces for five classes from CIFAR-100 test set (colors are given by the ground truth). (a): features space before applying Invertible Networks (black crosses are the clusters centers). $( b ) , ( c ) , ( d ) , ( e ) , ( f )$ : each features space after the Invertible Network of each class. The samples of a class represented by a network are clustered around the zero vector (black cross) whilst the samples from other classes appear further away from the cluster. Another visualization highlighting the differences between OvA-INN and Nearest Prototype is presented in Appendix D. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            199,
+            103,
+            812,
+            388
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Finally, we can notice that our approach is highly dependent on the quality of the pretrained features extractor. In our CIFAR-100, we had to rescale the input to make it compatible with ResNet. Nonetheless, recent research works show promising results in training features extractors in very efficient ways (Asano et al., 2019). Because it does not require to retrain its features extractor, we can foresee better performance in class-by-class learning with OvA-INN as new and more efficient features extractors are discovered. ",
+        "bbox": [
+            174,
+            541,
+            825,
+            626
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "As a future research direction, one could try to incorporate our method in a Reinforcement Learning scenario where various situations can be learned separately in a first phase (each situation with its own Invertible Network). Then during a second phase where any situation can appear without the agent explicitly told in which situation it is in, the agent could rely on previously trained Invertible Networks to improve its policy. This setting is closely related to Options in Reinforcement Learning. Also, in a regression setting, one can add a fully connected layer after an intermediate layer of an Invertible Network and use it to predict the output for the trained class. At test time, one only need to read the output from the regression layer of the Invertible Network that had the highest confidence. ",
+        "bbox": [
+            174,
+            633,
+            825,
+            744
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            784,
+            318,
+            799
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we proposed a new approach for the challenging problem of single-head Continual Learning without storing any of the previous data. On top of a fixed pretrained neural network, we trained for each class an Invertible Network to refine the extracted features and maximize the loglikelihood on samples from its class. This way, we show that we can predict the class of a sample by running each Invertible Network and identifying the one with the highest log-likelihood. This setting allows us to take full benefit of pretrained models, which results in very good performances on the class-by-class training of CIFAR-100 compared to prior works. ",
+        "bbox": [
+            174,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            287,
+            117
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Rahaf Aljundi, Francesca Babiloni, Mohamed Elhoseiny, Marcus Rohrbach, and Tinne Tuytelaars. Memory aware synapses: Learning what (not) to forget. In Proceedings of the European Conference on Computer Vision (ECCV), pp. 139–154, 2018. ",
+        "bbox": [
+            174,
+            126,
+            821,
+            169
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yuki M Asano, Christian Rupprecht, and Andrea Vedaldi. Surprising effectiveness of few-image unsupervised feature learning. arXiv preprint arXiv:1904.13132, 2019. ",
+        "bbox": [
+            169,
+            176,
+            823,
+            207
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Francisco M Castro, Manuel J Mar´ın-Jimenez, Nicol ´ as Guil, Cordelia Schmid, and Karteek Alahari.´ End-to-end incremental learning. In Proceedings of the European Conference on Computer Vision (ECCV), pp. 233–248, 2018. ",
+        "bbox": [
+            173,
+            215,
+            825,
+            258
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Arslan Chaudhry, Puneet K Dokania, Thalaiyasingam Ajanthan, and Philip HS Torr. Riemannian walk for incremental learning: Understanding forgetting and intransigence. arXiv preprint arXiv:1801.10112, 2018. ",
+        "bbox": [
+            171,
+            267,
+            823,
+            309
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Brian Cheung, Alex Terekhov, Yubei Chen, Pulkit Agrawal, and Bruno A. Olshausen. Superposition of many models into one. CoRR, abs/1902.05522, 2019. URL http://arxiv.org/abs/ 1902.05522. ",
+        "bbox": [
+            173,
+            318,
+            826,
+            361
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yi-Min Chou, Yi-Ming Chan, Jia-Hong Lee, Chih-Yi Chiu, and Chu-Song Chen. Unifying and merging well-trained deep neural networks for inference stage. In Proceedings of the Twenty-Seventh International Joint Conference on Artificial Intelligence, IJCAI-18, pp. 2049– 2056. International Joint Conferences on Artificial Intelligence Organization, 7 2018. doi: 10.24963/ijcai.2018/283. URL https://doi.org/10.24963/ijcai.2018/283. ",
+        "bbox": [
+            173,
+            369,
+            825,
+            441
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Laurent Dinh, David Krueger, and Yoshua Bengio. NICE: Non-linear independent components estimation. arXiv preprint arXiv:1410.8516, 2014. ",
+        "bbox": [
+            174,
+            450,
+            823,
+            479
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sebastian Farquhar and Yarin Gal. Towards robust evaluations of continual learning. arXiv preprint arXiv:1805.09733, 2018. ",
+        "bbox": [
+            174,
+            488,
+            821,
+            517
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ian Goodfellow, Yoshua Bengio, and Aaron Courville. Deep learning. 2016. ",
+        "bbox": [
+            174,
+            525,
+            678,
+            541
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Wenpeng Hu, Zhou Lin, Bing Liu, Chongyang Tao, Zhengwei Tao, Jinwen Ma, Dongyan Zhao, and Rui Yan. Overcoming catastrophic forgetting via model adaptation. 2018. ",
+        "bbox": [
+            174,
+            549,
+            825,
+            579
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ronald Kemker and Christopher Kanan. FearNet: Brain-inspired model for incremental learning. arXiv preprint arXiv:1711.10563, 2017. ",
+        "bbox": [
+            173,
+            588,
+            823,
+            617
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014. ",
+        "bbox": [
+            169,
+            626,
+            825,
+            655
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "James Kirkpatrick, Razvan Pascanu, Neil Rabinowitz, Joel Veness, Guillaume Desjardins, Andrei A Rusu, Kieran Milan, John Quan, Tiago Ramalho, Agnieszka Grabska-Barwinska, et al. Overcoming catastrophic forgetting in neural networks. Proceedings of the national academy of sciences, pp. 201611835, 2017. ",
+        "bbox": [
+            173,
+            662,
+            825,
+            719
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun, Leon Bottou, Yoshua Bengio, Patrick Haffner, et al. Gradient-based learning applied to document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998. ",
+        "bbox": [
+            173,
+            729,
+            823,
+            758
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Kimin Lee, Honglak Lee, Kibok Lee, and Jinwoo Shin. Training confidence-calibrated classifiers for detecting out-of-distribution samples. arXiv preprint arXiv:1711.09325, 2017. ",
+        "bbox": [
+            171,
+            767,
+            823,
+            796
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yu Li, Zhongxiao Li, Lizhong Ding, Peng Yang, Yuhui Hu, Wei Chen, and Xin Gao. SupportNet: solving catastrophic forgetting in class incremental learning with support data. arXiv preprint arXiv:1806.02942, 2018. ",
+        "bbox": [
+            173,
+            805,
+            825,
+            848
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Zhizhong Li and Derek Hoiem. Learning without forgetting. IEEE Transactions on Pattern Analysis and Machine Intelligence, 40(12):2935–2947, 2018. ",
+        "bbox": [
+            173,
+            857,
+            823,
+            886
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Shiyu Liang, Yixuan Li, and Rayadurgam Srikant. Enhancing the reliability of out-of-distribution image detection in neural networks. arXiv preprint arXiv:1706.02690, 2017. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "David Lopez-Paz et al. Gradient episodic memory for continual learning. In Advances in Neural Information Processing Systems, pp. 6467–6476, 2017. ",
+        "bbox": [
+            171,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 9
+    },
+    {
+        "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": [
+            173,
+            141,
+            823,
+            171
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Michael McCloskey and Neal J Cohen. Catastrophic interference in connectionist networks: The sequential learning problem. 24:109–165, 1989. ",
+        "bbox": [
+            171,
+            180,
+            825,
+            210
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "German I Parisi, Ronald Kemker, Jose L Part, Christopher Kanan, and Stefan Wermter. Continual lifelong learning with neural networks: A review. arXiv preprint arXiv:1802.07569, 2018. ",
+        "bbox": [
+            173,
+            218,
+            823,
+            248
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Adam Paszke, Sam Gross, Soumith Chintala, Gregory Chanan, Edward Yang, Zachary DeVito, Zeming Lin, Alban Desmaison, Luca Antiga, and Adam Lerer. Automatic differentiation in pytorch. 2017. ",
+        "bbox": [
+            173,
+            257,
+            825,
+            301
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Amal Rannen, Rahaf Aljundi, Matthew B Blaschko, and Tinne Tuytelaars. Encoder based lifelong learning. pp. 1320–1328, 2017. ",
+        "bbox": [
+            174,
+            310,
+            823,
+            339
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sylvestre-Alvise Rebuffi, Alexander Kolesnikov, Georg Sperl, and Christoph H Lampert. iCaRL: Incremental classifier and representation learning. pp. 5533–5542, 2017. ",
+        "bbox": [
+            173,
+            348,
+            823,
+            378
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Andrei A Rusu, Neil C Rabinowitz, Guillaume Desjardins, Hubert Soyer, James Kirkpatrick, Koray Kavukcuoglu, Razvan Pascanu, and Raia Hadsell. Progressive neural networks. arXiv preprint arXiv:1606.04671, 2016. ",
+        "bbox": [
+            174,
+            387,
+            823,
+            430
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hanul Shin, Jung Kwon Lee, Jaehong Kim, and Jiwon Kim. Continual learning with deep generative replay. pp. 2990–2999, 2017. ",
+        "bbox": [
+            171,
+            439,
+            823,
+            469
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jake Snell, Kevin Swersky, and Richard Zemel. Prototypical networks for few-shot learning. pp. 4077–4087, 2017. ",
+        "bbox": [
+            171,
+            478,
+            825,
+            508
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jiliang Tang, Salem Alelyani, and Huan Liu. Feature selection for classification: A review. Data classification: Algorithms and applications, pp. 37, 2014. ",
+        "bbox": [
+            169,
+            517,
+            825,
+            547
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Gido M. van de Ven and Andreas S. Tolias. Three scenarios for continual learning. CoRR, abs/1904.07734, 2019. URL http://arxiv.org/abs/1904.07734. ",
+        "bbox": [
+            174,
+            555,
+            823,
+            585
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Oriol Vinyals, Charles Blundell, Timothy Lillicrap, Daan Wierstra, et al. Matching networks for one shot learning. pp. 3630–3638, 2016. ",
+        "bbox": [
+            174,
+            594,
+            821,
+            625
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jaehong Yoon, Eunho Yang, Jeongtae Lee, and Sung Ju Hwang. Lifelong learning with dynamically expandable networks. arXiv preprint arXiv:1708.01547, 2017. ",
+        "bbox": [
+            173,
+            633,
+            823,
+            662
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jaehong Yoon, Eunho Yang, Jeongtae Lee, and Sung Ju Hwang. Lifelong learning with dynamically expandable networks. 2018. ",
+        "bbox": [
+            173,
+            671,
+            823,
+            700
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Friedemann Zenke, Ben Poole, and Surya Ganguli. Continual learning through synaptic intelligence. pp. 3987–3995, 2017. ",
+        "bbox": [
+            174,
+            710,
+            823,
+            739
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "A MEMORY USAGE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            767,
+            351,
+            784
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "A.1 MNIST ",
+        "bbox": [
+            174,
+            797,
+            274,
+            814
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "OvA-INN uses 2 blocks with 2 layers ( $f _ { 1 }$ and $f _ { 2 , }$ ) for 10 classes. The weight matrix of each layer $W$ is a product of two matrices $A$ and $B$ of size $3 9 2 \\times 1 6$ and $1 6 \\times 3 9 2$ . The memory required for OvA-INN is : ",
+        "bbox": [
+            174,
+            824,
+            825,
+            866
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2a960a87a85f038729480dc6246da9d6350148811a9da47285b6740929ac0a93.jpg",
+        "text": "$$\nS _ { \\mathrm { O v A - I N N , M N I S T } } = ( 3 9 2 \\times 1 6 \\times 2 + 3 9 2 ) \\times 2 \\times 2 \\times 1 0 = 5 1 7 4 4 0\n$$",
+        "text_format": "latex",
+        "bbox": [
+            171,
+            872,
+            607,
+            890
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We set the coreset size of iCaRL and SupportNet to $s = 8 0 0$ with each image of size $2 8 \\times 2 8$ , the convolutional network is composed of a layer of 64 channels with $5 \\times 5$ kernel, a layer of 32 ",
+        "bbox": [
+            173,
+            895,
+            825,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "channels with $5 \\times 5$ kernel, a fully-connected layer with 100 channels applied on an input of size $7 \\times 7$ and a final layer of 10 channels : ",
+        "bbox": [
+            174,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "${ \\mathfrak { H } } _ { \\mathrm { i C a R , M N I S T } } = 2 8 \\times 2 8 \\times 8 0 0 + ( 5 \\times 5 + 1 ) \\times 3 2 + ( 5 \\times 5 + 1 ) \\times 6 4 + ( 7 \\times 7 \\times 6 4 + 1 ) \\times 1 0 0 + ( 1 \\times 1 0 0 ) \\times 2 = 2 4$ $( 1 0 0 + 1 ) \\times 1 0 = 9 4 4 4 0 6$ ",
+        "bbox": [
+            174,
+            137,
+            826,
+            167
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A.2 CIFAR-100 ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            183,
+            303,
+            196
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Since every method rely on a ResNet32 (around 20M parameters) to compute their features (except FearNet which uses ResNet48). We do not count the features extractor in the memory consumption. ",
+        "bbox": [
+            174,
+            208,
+            823,
+            238
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "OvA-INN uses 2 blocks with 2 layers ( $f _ { 1 }$ and $f _ { 2 } ^ { \\mathrm { ~ ~ } } ,$ ) for 100 classes. The weight matrix of each layer $W$ is a product of two matrices $A$ and $B$ of size $2 5 6 \\times 3 2$ and $3 2 \\times 2 5 6$ . The memory required is : ",
+        "bbox": [
+            174,
+            244,
+            823,
+            272
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bb00d4db58cce288315dcbc5ddb3dca4efb28c31a6ec23bb05022fa76a28fe5c.jpg",
+        "text": "$$\nS _ { \\mathrm { O v A - I N N , C I F A R } } = ( 2 5 6 \\times 3 2 \\times 2 + 2 5 6 ) \\times 2 \\times 2 \\times 1 0 0 = 6 6 5 6 0 0 0\n$$",
+        "text_format": "latex",
+        "bbox": [
+            173,
+            279,
+            617,
+            296
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We use the default coreset size $s = 2 0 0 0$ of iCaRL and End-to-End $\\mathrm { I L }$ with each image of size $3 2 \\times 3 2$ : ",
+        "bbox": [
+            174,
+            300,
+            823,
+            329
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ffa383e4f8dde4eef1832f78278c40de6c4f29c0f6332536cbb50b4311fe6484.jpg",
+        "text": "$$\nS _ { \\mathrm { i C a R L , C I F A R } } = 3 2 \\times 3 2 \\times 3 \\times 2 0 0 0 = 6 1 4 4 0 0 0\n$$",
+        "text_format": "latex",
+        "bbox": [
+            171,
+            335,
+            488,
+            352
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "B HYPERPARAMETERS SETTINGS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            371,
+            467,
+            386
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Our implementation is done with Pytorch (Paszke et al., 2017), using the Adam optimizer (Kingma & Ba, 2014) and a scheduler that reduces the learning rate by a factor of 0.5 when the loss stops improving. We use the resize transformation from torchvision with the default bilinear interpolation. ",
+        "bbox": [
+            174,
+            400,
+            826,
+            443
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "table",
+        "img_path": "images/3531ccd04d69ceeb5b243eee02a993c4d046aa9b1c5b929f8c8cd5f3c7bb79e3.jpg",
+        "table_caption": [
+            "Table 2: MNIST Hyperparameters "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Hyperparameter</td><td>Value</td></tr><tr><td>Learning Rate</td><td>0.002</td></tr><tr><td>Number of epochs</td><td>200</td></tr><tr><td>Weight decay</td><td>0.0</td></tr><tr><td>Patience</td><td>20</td></tr></table>",
+        "bbox": [
+            235,
+            478,
+            442,
+            564
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "table",
+        "img_path": "images/0b86cb57ae8e14bf8c5dd0c03635932c1e9c643239fd82e81a1d49897c164f3f.jpg",
+        "table_caption": [
+            "Table 3: CIFAR-100 Hyperparameters "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Hyperparameter</td><td>Value</td></tr><tr><td></td><td></td></tr><tr><td>Learning Rate</td><td>0.002</td></tr><tr><td>Number of epochs Weight decay</td><td>1000 0.0002</td></tr><tr><td>Patience</td><td>30</td></tr></table>",
+        "bbox": [
+            555,
+            478,
+            764,
+            565
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "table",
+        "img_path": "images/85c9d3a15f6fbe4495ec6fd998025d6c17217d5cc5cdd553b10cc00f28507d3b.jpg",
+        "table_caption": [
+            "Table 4: t-SNE Hyperparameters "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Hyperparameter</td><td>Value</td></tr><tr><td></td><td></td></tr><tr><td>Perplexity</td><td>15.0</td></tr><tr><td>Principal Components</td><td>50</td></tr><tr><td>Steps</td><td>400</td></tr></table>",
+        "bbox": [
+            385,
+            611,
+            612,
+            688
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "C TASK-BY-TASK LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            717,
+            431,
+            733
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We provide additional experimental results on the multi-head learning of CIFAR100 with 10 tasks of 10 classes each. The training procedure of OvA-INN does not change from the usual single-head learning but, at test time, the evaluation is processed by batches of 10 classes. The accuracy score is the average accuracy over all 10 tasks. We report the results from (Yoon et al., 2017). Although our approach is able to match state-of-the-art results in accuracy, it should be noticed that it is drastically more memory and time consuming than the other baselines. ",
+        "bbox": [
+            173,
+            747,
+            826,
+            832
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "table",
+        "img_path": "images/a76702783845620b847ec7d8ac05d4a5100b5f9e8cb9184db8341dc0d9bbc787.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Accuracy (%)</td></tr><tr><td></td><td></td></tr><tr><td>EWC(Kirkpatrick et al., 2017)</td><td>81.34</td></tr><tr><td>Progressive Networks (Rusu et al., 2016)</td><td>88.19</td></tr><tr><td>DEN (Yoon et al., 2017)</td><td>92.25</td></tr><tr><td>OvA-INN</td><td>92.58</td></tr></table>",
+        "bbox": [
+            295,
+            840,
+            700,
+            926
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "D VISUALIZATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            344,
+            117
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We highlight the differences between OvA-INN and Nearest Prototype when classifying 20 classes of CIFAR-100 in Figure 4. ",
+        "bbox": [
+            174,
+            133,
+            825,
+            162
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/02e4c855ccb13188bd983f8e9f0b207a784e5a6405a1adf39e60f6c338389052.jpg",
+        "image_caption": [
+            "Figure 4: top: t-SNE projection of the features space before applying Invertible Networks (black crosses are the clusters centers) for 20 classes from CIFAR-100 test set (colors are given by the ground truth). bottom: in blue and yellow are the samples correctly and wrongly classified by both Nearest Prototype and OvA-INN, in green the samples better classified by OvA-INN than Nearest Prototype and orange the samples better classified by Nearest Prototype than OvA-INN. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            297,
+            179,
+            730,
+            751
+        ],
+        "page_idx": 11
+    }
+]

parse/train/rkhxwltab/rkhxwltab.md

@@ -0,0 +1,120 @@
+# AANN: ABSOLUTE ARTIFICIAL NEURAL NETWORK
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+This research paper describes a simplistic architecture named as AANN: Absolute Artificial Neural Network, which can be used to create highly interpretable representations of the input data. These representations are generated by penalizing the learning of the network in such a way that those learned representations correspond to the respective labels present in the labelled dataset used for supervised training; thereby, simultaneously giving the network the ability to classify the input data. The network can be used in the reverse direction to generate data that closely resembles the input by feeding in representation vectors as required. This research paper also explores the use of mathematical abs (absolute valued) functions as activation functions which constitutes the core part of this neural network architecture. Finally the results obtained on the MNIST dataset by using this technique are presented and discussed in brief.
+
+# 1 INTRODUCTION
+
+In the field of philosophy, there has been a principle known as ’Ockham’s Razor’ which, in a simplified relevant language states that ”Among the available multiple solutions to the same problem, the simplest one is the best one”. For instance, if there are multiple polynomial functions that fit a given data distribution, the lowest degree one would be preferred (Russell & Norvig, 2015). The technique AANN is driven by this principle. In spite of being elementary in its construction, an AANN is able to classify inputs in the forward direction while being able to generate them back in the reverse direction. It can be visualized to be doing classification in the forward direction whereas performing a regression task in the backward direction.
+
+A standalone GAN (Generative Adversarial Network) described in Goodfellow et al. (2014) is able to create representations of the input data by using a novel technique of generating a distribution that contains the original data points as well as data points generated by the Generator part of the network; the distribution is then used by the Discriminator part of the network to classify the data points as genuine or generated. The representations generated by a GAN, although being very effective in creating undistinguishable data points, are however not interpretable and also highly entangled (Chen et al., 2016) (Makhzani et al., 2016). Using an InfoGAN, the problem of entanglement is solved by training in such a way that the network maximises mutual information within small clusters of related latent representations (Chen et al., 2016). Auto-encoder is another technique that uses the concept of encoder-decoder architecture for creating low dimensional representations of the originally very high dimensional input data points. A VAE: Variational Auto-Encoder tries to make the learned representations sparse by using the KL-divergence cost as a regularizer on the final cost of an autoencoder (Kingma & Welling, 2014). Various attempts at combining the two techniques of GAN and VAE have also been made in the unsupervised as well as semi-supervised learning directions (Makhzani et al., 2016) (Larsen et al., 2016). However, these techniques kept getting more and more complicated and somewhere in synthesizing these techniques, it is felt that the ’striving for simplicity’ principle has been neglected.
+
+The Absolute Artificial Neural Network exploits all possible information available in the labelled training datasets to structure the learned representations of the input data. Structurally, an AANN is very similar to a feed forward Neural Network with the distinction that AANN uses the abs function as the activation function of the neurons. Due to this, all the activations produced, including the hidden layer activations, contain positive real number values. Thus, the network runs on the assumption that the input data as well as the label information comes from a positive data distribution. This doesn’t create an issue for the computer vision based tasks. However, for those situations, where this is not possible, the feature values in the input dataset can be easily moved 1 into the positive region of the multi-dimensional input data space.
+
+![](images/9e516f408ea128ec3cb7efc48252ab9cd78db307a514d2b33acbf6439cc47ff0.jpg)  
+Figure 1: Example of learned representation space created by AANN
+
+The AANN transforms the n-dimensional input data into a space whose number of dimensions are equal to the number of labels used in the training dataset. For instance, presume that, the task is to classify images of cats and dogs and there is a labelled dataset present for achieving this classification. So, the learned representations will contain two dimensions corresponing to each label: cat and dog. The input images are transformed into 2-dimensional vectors by the AANN in such a way that the vectors are as close as possible to their ideal axes. This is achieved by constructing the cost function in a manner that it maximises the cosine value of the angle formed by the vector with its ideal axis. As a result, the representation space generated by this AANN can be visualized as shown in the Figure 1. The label axes in the representation space are mutually orthogonal; thus the resulting representation vectors become very interpretable.
+
+# 2 AANN DESCRIPTION
+
+![](images/359604c9065dac6121f4e5adc1c9c2d3e1623fbc026483f0b41d9cdb344763bd.jpg)  
+Figure 2: Bidirectional artificial neuron: the building block of an AANN.
+
+The AANN is constructed by using a ’Bidirectional Neuron’ (Figure 2) as the building block for the hidden layers of a preliminary feed forward neural network. This bidirectional neuron uses the abs (mathematical absolute valued) function as the activation function. The computation performed by the neuron is similar in the forward and the backward directions. In the forward direction, the computation is given by:
+
+$$
+A _ { f o r w a r d } = \mid ( W _ { l e f t } * X _ { i n } ) + b _ { f o r w a r d } \mid
+$$
+
+Whereas, in the backward direction, the neuron computes:
+
+$$
+A _ { r e v e r s e } = \mid ( W _ { r i g h t } * X _ { i n . r e v } ) + b _ { r e v e r s e } \mid
+$$
+
+The weights of the hidden layers of the AANN in forward direction learn to compute a function for transforming the input data into the representation vectors. While in the reverse direction, the weights constitute a function for constructing data points that closely resemble the data points belonging to the input dataset from the representation vectors. It is highly intriguing, and at the same time enigmatic, that the same set of weights constitute two entirely distinct functions.
+
+# 2.1 FORWARD PASS
+
+![](images/dff8d6b8ccfc906505cac767387504510ebae557eaf0ac4af2e6af9224969142.jpg)  
+Figure 3: Forward pass of the AANN.
+
+The input n-dimensional feature vector is passed through the neural network consisting of hidden layers, constructed from the bidirectional neurons, to obtain an m-dimensional representation vector; where m corresponds to the number of labels. The obtained representation vector is then converted into a unit vector, which primarily corresponds to the cosines of the angles made by the representation vector with the coordinate axes. Finally, the forward cost ${ J } _ { f o r w a r d }$ can be computed as either the Euclidean distance or just the mean absoulte difference, which is an estimate of the euclidean distance, between the unit representation vector $Y ^ { \prime }$ and the one-hot-encoded-label vector $Y$ .
+
+The direction cosines of the vector can be obtained by using the formula:
+
+$$
+\begin{array} { c } { { \mathrm { i f } \ A = [ x _ { 1 } , x _ { 2 } , x _ { 3 } , . . . , x _ { m } ] ; \mathrm { t h e n } \mid \overline { { { A } } } \mid = \sqrt { x _ { 1 } ^ { 2 } + x _ { 2 } ^ { 2 } + x _ { 3 } ^ { 2 } + . . . + x _ { m } ^ { 2 } } } } \\ { { A _ { c o s i n e } = \displaystyle \frac { \overline { { { A } } } } { | \overline { { { A } } } | } } } \end{array}
+$$
+
+i.e. by scaling every activation value present in the representation vector by the inverse of the magnitude of the vector. This results in a unit vector that only corresponds to the direction of the original vector. As per the forward cost, it is intended to bring this direction vector as close as possible to the ideal label coordinate axis. Due to which, the label axis encodes the input information as representation vectors of different magnitudes converge on it. [link] 2 This visualization demonstrates how information gets encoded along the label axis in various real valued magnitude ranges. The visualization was generated by interpolating a small of range of values, precisely $[ 0 - 1 0 0 )$ , along all 10 different axes corresponding to the 10 digits, present in an MNIST dataset, in a sequence by using a trained AANN. It is clearly evident from the visualization that the network creates more than just input output mappings; it creates a function of the learned representations as apparent from the smooth transitions between the different forms of a digit along it’s dedicated axis.
+
+# 2.2 REVERSE PASS
+
+![](images/3b043c784a3574cf25fb0579037985e41ccf00771bd8816517c2f231a45baf65.jpg)  
+Figure 4: Reverse pass of the AANN.
+
+During the reverse pass of the AANN, the representation vector emitted by the network of hidden layers in the forward pass is fed back into the network in the reverse direction 3. The network then performs transpose operations to give off a new vector $X ^ { \prime }$ in the input $\mathbf { n }$ -dimensional space. The reverse cost $J _ { r e v e r s e }$ is computed as either the euclidean distance or the mean absolute difference between the vectors $X ^ { \prime }$ and $X$ . By defining the reverse cost in such a way, it is intended to obtain the vector $X ^ { \prime }$ as close as possible to the original input vector $X$ . This accords the network the ability to generate data points in the input space in the reverse direction.
+
+# 2.3 TRAINING:
+
+The network is trained by using the Backpropagation (Rumelhart et al., 1986) algorithm to minimise the final cost $J _ { f i n a l }$ . The final cost is defined as the sum of the forward and the reverse costs.
+
+$$
+J _ { f i n a l } = J _ { f o r w a r d } + J _ { r e v e r s e }
+$$
+
+It is ultimately this cost with respect to whom the partial derivatives of the parameters are computed. The parameters are then adjusted by using the computed derivatives according to the Adam optimization as described in Kingma & Ba (2017).
+
+This action of performing the forward pass to calculate the forward cost followed by the reverse pass to obtain the reverse cost and then performing backpropagation on the final cost constitutes a single pass of the AANN. The term AANN: Absolute Artificial Neural Network, which is also the title of the paper, thus refers to this unified process of training a neural network in such a way.
+
+# 3 EXPERIMENTATION WITH OTHER ACTIVATION FUNCTIONS
+
+This section attempts to succinctly describe the process of, and findings attained by, using other activation functions for the neural network architecture described in the previous section. Since the actual reasons why these activation functions behave in the manner that they do are not fully known, it has been tried to remain fatihful while describing the experiments and not to make any unproven, or otherwise philosophical, remarks in this section. The programming implementations of these experiments have been made available at [link].
+
+![](images/596e25eefa272612e440f8d064ec7cf59ce75d79b3fdceaf04724cfad3c1f354.jpg)  
+Figure 5: Images generated in the reverse direction by different activation function settings of an AANN. (a) Use of ReLU activation function. (b) Linear activation function. (c) ReLU in the forward direction and Abs in the backward direction. (d) Abs forward and ReLU backward. (e) Use of Sigmoid activation function.
+
+Upon using the ReLU, i.e. Rectified Linear-Unit, function (Nair & Hinton, 2010) as the activation function for this architecture, all the activations shoot to nan 4 in the forward direction leading to proliferation of nan in the reverse direction as well. If the Linear activation function is used, the network performs poorly in the forward direction, leading to very high classification error rates, while, the network converges to the point that it outputs the same structure as shown in $( b )$ of Figure 5 for every possible representation vector. On activating the hidden neurons with a ReLU in the forward direction and with an Abs in the reverse direction, the network kills all the activations, i.e. outputs the zero vector for every input, in the forward direction. In the backward direction, the network converges to the (c) structure. Upon using the Abs function in the forward direction and the ReLU in the backward direction, the network this time kills all the activations in the backward direction as visualized in (d). The (e) in Figure 5 is the output achieved by using the Sigmoid activation function in the network. The result obtained is very similar to the result of using Linear activation function, as in $( b )$ .
+
+# 4 RESULTS ON MNIST DATASET
+
+The AANN architecture was trained on the MNIST digit recognition dataset5. The dataset contains [ $\left( 2 8 \mathrm { ~ x ~ } 2 8 \right)$ pixels] sized images of handwritten digits from 0 - 9. The programming implementation using the Tensorflow framework (Abadi et al., 2015) has been made available at [link].
+
+![](images/bc1942491702a458469b6590db474193393b2a515a8519d047c7c1a9350115bf.jpg)  
+Figure 6: Cost plots obtained upon training the AANN on the MNIST digit dataset. (a) Forward cost. (b) Reverse cost. (c) Final cost.
+
+There are 42000 images in the training set, of which, $9 5 \%$ were used for train set and remaining $5 \%$ images were used for the dev set. i.e. 39900 in the train set and 2100 in the dev set. The network was trained using the Adam (Kingma & Ba, 2017) optimizer with $\alpha = 0 . 0 0 1$ , $\beta _ { 1 } = 0 . 9$ , $\beta _ { 2 } = 0 . 9 9 9$ and $\epsilon = 1 0 ^ { - 8 }$ .
+
+![](images/7b041a1c377c55f2ff507a06fac5793de8f57d47815f2a938d5d017569b36e93.jpg)  
+Figure 7: Outputs generated by the AANN in the reverse direction. (a) Original images fed into the network. (b) Images reconstructed by the network in the reverse direction.
+
+The network achieved a classification accuracy score of $9 9 . 8 6 \%$ on the train set and $9 7 . 4 3 \%$ on the dev set in the forward direction. The unseen test set of this version of the dataset used contains another 28000 images for which the network achieved an accuracy of $9 7 . 6 7 1 \%$ . Figure 7 shows the images generated by the network in the reverse direction against the original images fed to the network. It is perceived that the capability of the network should not be evaluated only on the basis of it’s forward accuracy scores but should be evaluated on the basis of a unified metric that not only measures the network’s forward performance but also the faithfulness with which the network is able to generate input data points in the reverse direction.
+
+# 5 CONCLUSIONS AND FUTURE SCOPE
+
+This research paper put forth an elementary but potent neural network architecture, named as AANN, that has the ability to learn in the forward as well as the backward direction. It also proposed the Abs function as a viable activation function for a neural network architecture. Due to lack of hardware resources, the experimentation had to be limited to the preliminary MNIST dataset, but it is firmly believed that the technique will perform equally well upon tackling other robust datasets, because of the theoretical evidence shown in the performed experiments.
+
+The AANN presently encodes the information in real number valued ranges across the the dedicated label axes in the the representation space. Certain regularization functions can be synthesized in order to stretch these ranges so that more information can be incorporated in them. The number of dimensions of the learned representations can be manually controlled by setting certain number of dedicated axes to a single label and by modifiying the forward cost function in such a way that the representation vectors lie inside the space generated by the coordinate axes dedicated to the ideal label. An in depth mathematical study of the Abs activation function could reveal the underlying behaviour of AANN. This forms the future scope for research.
+
+This technique also opens up new research opportunities for considering the AANN architectural modifications to certain network architectures like Rasmus et al. (2015) for semi-supervised learning. Moreover, it would be interesting to note the implications of applying the corresponding modifications to more advanced architectures such as Conv-nets (Krizhevsky et al., 2012) and Recurrent Nets with LSTM cells (Hochreiter & Schmidhuber, 1997).
+
+# REFERENCES
+
+M. Abadi et al. Tensorflow: Large-scale machine learning on heterogeneous distributed systems. Preliminary White Paper, 2015.   
+X. Chen et al. Infogan: Interpretable representation learning by information maximizing generative adversarial nets. arXiv:1606.03657v1 [cs.LG], 2016.   
+I. Goodfellow et al. Generative adversarial nets. arXiv:1406.2661v1 [stat.ML], 2014.   
+S. Hochreiter and J. Schmidhuber. Long short-term memory. Neural Computation 9(8):1735-1780, 1997.   
+D. Kingma and J. Ba. Adam: A method for stochastic optimization. arXiv:1412.6980v9 [cs.LG], 2017.   
+D. Kingma and M. Welling. Auto-encoding variational bayes. arXiv:1312.6114v10 [stat.ML], 2014.   
+A. Krizhevsky et al. Imagenet classification with deep convolutional neural networks. In Proceedings of the Neural Information Processing Systems Conference, 2012.   
+A. Larsen et al. Autoencoding beyond pixels using a learned similarity metric. arXiv:1512.09300v2, 2016.   
+A. Makhzani et al. Adversarial autoencoders. arXiv:1511.05644v2, 2016.   
+V. Nair and G. Hinton. Rectified linear units improve restricted boltzmann machines. In Proceedings of the 27 th International Conference on Machine Learning, Haifa, Israel, 2010.   
+A. Rasmus et al. Semi-supervised learning with ladder networks. arXiv:1507.02672v2 [cs.NE], 2015.   
+D. Rumelhart et al. Learning representations by back-propagating errors. Nature, 323:533–536, October 1986.   
+S. Russell and P. Norvig. Artificial Intelligence A Modern Approach, chapter 18: Learning from examples. Person publications, 3rd edition, 2015.

parse/train/rkhxwltab/rkhxwltab_content_list.json

@@ -0,0 +1,577 @@
+[
+    {
+        "type": "text",
+        "text": "AANN: ABSOLUTE ARTIFICIAL NEURAL NETWORK ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            98,
+            802,
+            121
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            145,
+            398,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            210,
+            544,
+            226
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "This research paper describes a simplistic architecture named as AANN: Absolute Artificial Neural Network, which can be used to create highly interpretable representations of the input data. These representations are generated by penalizing the learning of the network in such a way that those learned representations correspond to the respective labels present in the labelled dataset used for supervised training; thereby, simultaneously giving the network the ability to classify the input data. The network can be used in the reverse direction to generate data that closely resembles the input by feeding in representation vectors as required. This research paper also explores the use of mathematical abs (absolute valued) functions as activation functions which constitutes the core part of this neural network architecture. Finally the results obtained on the MNIST dataset by using this technique are presented and discussed in brief. ",
+        "bbox": [
+            233,
+            241,
+            764,
+            407
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            434,
+            336,
+            449
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In the field of philosophy, there has been a principle known as ’Ockham’s Razor’ which, in a simplified relevant language states that ”Among the available multiple solutions to the same problem, the simplest one is the best one”. For instance, if there are multiple polynomial functions that fit a given data distribution, the lowest degree one would be preferred (Russell & Norvig, 2015). The technique AANN is driven by this principle. In spite of being elementary in its construction, an AANN is able to classify inputs in the forward direction while being able to generate them back in the reverse direction. It can be visualized to be doing classification in the forward direction whereas performing a regression task in the backward direction. ",
+        "bbox": [
+            174,
+            465,
+            825,
+            577
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "A standalone GAN (Generative Adversarial Network) described in Goodfellow et al. (2014) is able to create representations of the input data by using a novel technique of generating a distribution that contains the original data points as well as data points generated by the Generator part of the network; the distribution is then used by the Discriminator part of the network to classify the data points as genuine or generated. The representations generated by a GAN, although being very effective in creating undistinguishable data points, are however not interpretable and also highly entangled (Chen et al., 2016) (Makhzani et al., 2016). Using an InfoGAN, the problem of entanglement is solved by training in such a way that the network maximises mutual information within small clusters of related latent representations (Chen et al., 2016). Auto-encoder is another technique that uses the concept of encoder-decoder architecture for creating low dimensional representations of the originally very high dimensional input data points. A VAE: Variational Auto-Encoder tries to make the learned representations sparse by using the KL-divergence cost as a regularizer on the final cost of an autoencoder (Kingma & Welling, 2014). Various attempts at combining the two techniques of GAN and VAE have also been made in the unsupervised as well as semi-supervised learning directions (Makhzani et al., 2016) (Larsen et al., 2016). However, these techniques kept getting more and more complicated and somewhere in synthesizing these techniques, it is felt that the ’striving for simplicity’ principle has been neglected. ",
+        "bbox": [
+            174,
+            583,
+            825,
+            819
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The Absolute Artificial Neural Network exploits all possible information available in the labelled training datasets to structure the learned representations of the input data. Structurally, an AANN is very similar to a feed forward Neural Network with the distinction that AANN uses the abs function as the activation function of the neurons. Due to this, all the activations produced, including the hidden layer activations, contain positive real number values. Thus, the network runs on the assumption that the input data as well as the label information comes from a positive data distribution. This doesn’t create an issue for the computer vision based tasks. However, for those situations, where this is not possible, the feature values in the input dataset can be easily moved 1 into the positive region of the multi-dimensional input data space. ",
+        "bbox": [
+            174,
+            827,
+            823,
+            922
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            169,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/9e516f408ea128ec3cb7efc48252ab9cd78db307a514d2b33acbf6439cc47ff0.jpg",
+        "image_caption": [
+            "Figure 1: Example of learned representation space created by AANN "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            351,
+            147,
+            647,
+            281
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The AANN transforms the n-dimensional input data into a space whose number of dimensions are equal to the number of labels used in the training dataset. For instance, presume that, the task is to classify images of cats and dogs and there is a labelled dataset present for achieving this classification. So, the learned representations will contain two dimensions corresponing to each label: cat and dog. The input images are transformed into 2-dimensional vectors by the AANN in such a way that the vectors are as close as possible to their ideal axes. This is achieved by constructing the cost function in a manner that it maximises the cosine value of the angle formed by the vector with its ideal axis. As a result, the representation space generated by this AANN can be visualized as shown in the Figure 1. The label axes in the representation space are mutually orthogonal; thus the resulting representation vectors become very interpretable. ",
+        "bbox": [
+            173,
+            330,
+            825,
+            470
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 AANN DESCRIPTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            491,
+            383,
+            507
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/359604c9065dac6121f4e5adc1c9c2d3e1623fbc026483f0b41d9cdb344763bd.jpg",
+        "image_caption": [
+            "Figure 2: Bidirectional artificial neuron: the building block of an AANN. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            351,
+            529,
+            647,
+            680
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The AANN is constructed by using a ’Bidirectional Neuron’ (Figure 2) as the building block for the hidden layers of a preliminary feed forward neural network. This bidirectional neuron uses the abs (mathematical absolute valued) function as the activation function. The computation performed by the neuron is similar in the forward and the backward directions. In the forward direction, the computation is given by: ",
+        "bbox": [
+            173,
+            732,
+            825,
+            803
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/52e31640fd0dfdb9e07a7b6b1887169e9737451238b3dad3440d1329ed0ae0f6.jpg",
+        "text": "$$\nA _ { f o r w a r d } = \\mid ( W _ { l e f t } * X _ { i n } ) + b _ { f o r w a r d } \\mid\n$$",
+        "text_format": "latex",
+        "bbox": [
+            361,
+            813,
+            635,
+            832
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Whereas, in the backward direction, the neuron computes: ",
+        "bbox": [
+            174,
+            842,
+            557,
+            857
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/beba11b70bed727e4e4d283b80f952e3ffadfba2a4f97f93726aeae281ebb7ad.jpg",
+        "text": "$$\nA _ { r e v e r s e } = \\mid ( W _ { r i g h t } * X _ { i n . r e v } ) + b _ { r e v e r s e } \\mid\n$$",
+        "text_format": "latex",
+        "bbox": [
+            351,
+            867,
+            647,
+            886
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The weights of the hidden layers of the AANN in forward direction learn to compute a function for transforming the input data into the representation vectors. While in the reverse direction, the weights constitute a function for constructing data points that closely resemble the data points belonging to the input dataset from the representation vectors. It is highly intriguing, and at the same time enigmatic, that the same set of weights constitute two entirely distinct functions. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.1 FORWARD PASS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            190,
+            323,
+            204
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/dff8d6b8ccfc906505cac767387504510ebae557eaf0ac4af2e6af9224969142.jpg",
+        "image_caption": [
+            "Figure 3: Forward pass of the AANN. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            219,
+            826,
+            431
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The input n-dimensional feature vector is passed through the neural network consisting of hidden layers, constructed from the bidirectional neurons, to obtain an m-dimensional representation vector; where m corresponds to the number of labels. The obtained representation vector is then converted into a unit vector, which primarily corresponds to the cosines of the angles made by the representation vector with the coordinate axes. Finally, the forward cost ${ J } _ { f o r w a r d }$ can be computed as either the Euclidean distance or just the mean absoulte difference, which is an estimate of the euclidean distance, between the unit representation vector $Y ^ { \\prime }$ and the one-hot-encoded-label vector $Y$ . ",
+        "bbox": [
+            173,
+            481,
+            825,
+            579
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The direction cosines of the vector can be obtained by using the formula: ",
+        "bbox": [
+            174,
+            585,
+            651,
+            601
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/05bb924eb64a7f0f7de31aaaa5859cf6a66ad9e1b0a6816fcc28d2894056ccbc.jpg",
+        "text": "$$\n\\begin{array} { c } { { \\mathrm { i f } \\ A = [ x _ { 1 } , x _ { 2 } , x _ { 3 } , . . . , x _ { m } ] ; \\mathrm { t h e n } \\mid \\overline { { { A } } } \\mid = \\sqrt { x _ { 1 } ^ { 2 } + x _ { 2 } ^ { 2 } + x _ { 3 } ^ { 2 } + . . . + x _ { m } ^ { 2 } } } } \\\\ { { A _ { c o s i n e } = \\displaystyle \\frac { \\overline { { { A } } } } { | \\overline { { { A } } } | } } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            281,
+            609,
+            722,
+            666
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "i.e. by scaling every activation value present in the representation vector by the inverse of the magnitude of the vector. This results in a unit vector that only corresponds to the direction of the original vector. As per the forward cost, it is intended to bring this direction vector as close as possible to the ideal label coordinate axis. Due to which, the label axis encodes the input information as representation vectors of different magnitudes converge on it. [link] 2 This visualization demonstrates how information gets encoded along the label axis in various real valued magnitude ranges. The visualization was generated by interpolating a small of range of values, precisely $[ 0 - 1 0 0 )$ , along all 10 different axes corresponding to the 10 digits, present in an MNIST dataset, in a sequence by using a trained AANN. It is clearly evident from the visualization that the network creates more than just input output mappings; it creates a function of the learned representations as apparent from the smooth transitions between the different forms of a digit along it’s dedicated axis. ",
+        "bbox": [
+            173,
+            672,
+            825,
+            828
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 REVERSE PASS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            318,
+            117
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/3b043c784a3574cf25fb0579037985e41ccf00771bd8816517c2f231a45baf65.jpg",
+        "image_caption": [
+            "Figure 4: Reverse pass of the AANN. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            204,
+            130,
+            789,
+            400
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "During the reverse pass of the AANN, the representation vector emitted by the network of hidden layers in the forward pass is fed back into the network in the reverse direction 3. The network then performs transpose operations to give off a new vector $X ^ { \\prime }$ in the input $\\mathbf { n }$ -dimensional space. The reverse cost $J _ { r e v e r s e }$ is computed as either the euclidean distance or the mean absolute difference between the vectors $X ^ { \\prime }$ and $X$ . By defining the reverse cost in such a way, it is intended to obtain the vector $X ^ { \\prime }$ as close as possible to the original input vector $X$ . This accords the network the ability to generate data points in the input space in the reverse direction. ",
+        "bbox": [
+            173,
+            446,
+            825,
+            545
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.3 TRAINING: ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            560,
+            290,
+            574
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The network is trained by using the Backpropagation (Rumelhart et al., 1986) algorithm to minimise the final cost $J _ { f i n a l }$ . The final cost is defined as the sum of the forward and the reverse costs. ",
+        "bbox": [
+            173,
+            587,
+            823,
+            614
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3eb086ab7bb51613bc5a10d3cacc65f3e375589e3d29505896d1ef4e082b3cce.jpg",
+        "text": "$$\nJ _ { f i n a l } = J _ { f o r w a r d } + J _ { r e v e r s e }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            398,
+            625,
+            598,
+            642
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "It is ultimately this cost with respect to whom the partial derivatives of the parameters are computed. The parameters are then adjusted by using the computed derivatives according to the Adam optimization as described in Kingma & Ba (2017). ",
+        "bbox": [
+            173,
+            650,
+            825,
+            693
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "This action of performing the forward pass to calculate the forward cost followed by the reverse pass to obtain the reverse cost and then performing backpropagation on the final cost constitutes a single pass of the AANN. The term AANN: Absolute Artificial Neural Network, which is also the title of the paper, thus refers to this unified process of training a neural network in such a way. ",
+        "bbox": [
+            174,
+            699,
+            825,
+            756
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 EXPERIMENTATION WITH OTHER ACTIVATION FUNCTIONS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            776,
+            686,
+            791
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "This section attempts to succinctly describe the process of, and findings attained by, using other activation functions for the neural network architecture described in the previous section. Since the actual reasons why these activation functions behave in the manner that they do are not fully known, it has been tried to remain fatihful while describing the experiments and not to make any unproven, or otherwise philosophical, remarks in this section. The programming implementations of these experiments have been made available at [link]. ",
+        "bbox": [
+            174,
+            805,
+            825,
+            888
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/596e25eefa272612e440f8d064ec7cf59ce75d79b3fdceaf04724cfad3c1f354.jpg",
+        "image_caption": [
+            "Figure 5: Images generated in the reverse direction by different activation function settings of an AANN. (a) Use of ReLU activation function. (b) Linear activation function. (c) ReLU in the forward direction and Abs in the backward direction. (d) Abs forward and ReLU backward. (e) Use of Sigmoid activation function. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            99,
+            823,
+            238
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Upon using the ReLU, i.e. Rectified Linear-Unit, function (Nair & Hinton, 2010) as the activation function for this architecture, all the activations shoot to nan 4 in the forward direction leading to proliferation of nan in the reverse direction as well. If the Linear activation function is used, the network performs poorly in the forward direction, leading to very high classification error rates, while, the network converges to the point that it outputs the same structure as shown in $( b )$ of Figure 5 for every possible representation vector. On activating the hidden neurons with a ReLU in the forward direction and with an Abs in the reverse direction, the network kills all the activations, i.e. outputs the zero vector for every input, in the forward direction. In the backward direction, the network converges to the (c) structure. Upon using the Abs function in the forward direction and the ReLU in the backward direction, the network this time kills all the activations in the backward direction as visualized in (d). The (e) in Figure 5 is the output achieved by using the Sigmoid activation function in the network. The result obtained is very similar to the result of using Linear activation function, as in $( b )$ . ",
+        "bbox": [
+            173,
+            342,
+            825,
+            523
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 RESULTS ON MNIST DATASET ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            545,
+            459,
+            561
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The AANN architecture was trained on the MNIST digit recognition dataset5. The dataset contains [ $\\left( 2 8 \\mathrm { ~ x ~ } 2 8 \\right)$ pixels] sized images of handwritten digits from 0 - 9. The programming implementation using the Tensorflow framework (Abadi et al., 2015) has been made available at [link]. ",
+        "bbox": [
+            173,
+            578,
+            826,
+            621
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/bc1942491702a458469b6590db474193393b2a515a8519d047c7c1a9350115bf.jpg",
+        "image_caption": [
+            "Figure 6: Cost plots obtained upon training the AANN on the MNIST digit dataset. (a) Forward cost. (b) Reverse cost. (c) Final cost. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            638,
+            812,
+            763
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "There are 42000 images in the training set, of which, $9 5 \\%$ were used for train set and remaining $5 \\%$ images were used for the dev set. i.e. 39900 in the train set and 2100 in the dev set. The network was trained using the Adam (Kingma & Ba, 2017) optimizer with $\\alpha = 0 . 0 0 1$ , $\\beta _ { 1 } = 0 . 9$ , $\\beta _ { 2 } = 0 . 9 9 9$ and $\\epsilon = 1 0 ^ { - 8 }$ . ",
+        "bbox": [
+            174,
+            829,
+            825,
+            885
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/7b041a1c377c55f2ff507a06fac5793de8f57d47815f2a938d5d017569b36e93.jpg",
+        "image_caption": [
+            "Figure 7: Outputs generated by the AANN in the reverse direction. (a) Original images fed into the network. (b) Images reconstructed by the network in the reverse direction. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            99,
+            823,
+            342
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The network achieved a classification accuracy score of $9 9 . 8 6 \\%$ on the train set and $9 7 . 4 3 \\%$ on the dev set in the forward direction. The unseen test set of this version of the dataset used contains another 28000 images for which the network achieved an accuracy of $9 7 . 6 7 1 \\%$ . Figure 7 shows the images generated by the network in the reverse direction against the original images fed to the network. It is perceived that the capability of the network should not be evaluated only on the basis of it’s forward accuracy scores but should be evaluated on the basis of a unified metric that not only measures the network’s forward performance but also the faithfulness with which the network is able to generate input data points in the reverse direction. ",
+        "bbox": [
+            174,
+            438,
+            825,
+            551
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSIONS AND FUTURE SCOPE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            598,
+            500,
+            613
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "This research paper put forth an elementary but potent neural network architecture, named as AANN, that has the ability to learn in the forward as well as the backward direction. It also proposed the Abs function as a viable activation function for a neural network architecture. Due to lack of hardware resources, the experimentation had to be limited to the preliminary MNIST dataset, but it is firmly believed that the technique will perform equally well upon tackling other robust datasets, because of the theoretical evidence shown in the performed experiments. ",
+        "bbox": [
+            174,
+            645,
+            825,
+            728
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The AANN presently encodes the information in real number valued ranges across the the dedicated label axes in the the representation space. Certain regularization functions can be synthesized in order to stretch these ranges so that more information can be incorporated in them. The number of dimensions of the learned representations can be manually controlled by setting certain number of dedicated axes to a single label and by modifiying the forward cost function in such a way that the representation vectors lie inside the space generated by the coordinate axes dedicated to the ideal label. An in depth mathematical study of the Abs activation function could reveal the underlying behaviour of AANN. This forms the future scope for research. ",
+        "bbox": [
+            174,
+            736,
+            825,
+            847
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "This technique also opens up new research opportunities for considering the AANN architectural modifications to certain network architectures like Rasmus et al. (2015) for semi-supervised learning. Moreover, it would be interesting to note the implications of applying the corresponding modifications to more advanced architectures such as Conv-nets (Krizhevsky et al., 2012) and Recurrent Nets with LSTM cells (Hochreiter & Schmidhuber, 1997). ",
+        "bbox": [
+            176,
+            854,
+            823,
+            922
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            287,
+            118
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "M. Abadi et al. Tensorflow: Large-scale machine learning on heterogeneous distributed systems. Preliminary White Paper, 2015.   \nX. Chen et al. Infogan: Interpretable representation learning by information maximizing generative adversarial nets. arXiv:1606.03657v1 [cs.LG], 2016.   \nI. Goodfellow et al. Generative adversarial nets. arXiv:1406.2661v1 [stat.ML], 2014.   \nS. Hochreiter and J. Schmidhuber. Long short-term memory. Neural Computation 9(8):1735-1780, 1997.   \nD. Kingma and J. Ba. Adam: A method for stochastic optimization. arXiv:1412.6980v9 [cs.LG], 2017.   \nD. Kingma and M. Welling. Auto-encoding variational bayes. arXiv:1312.6114v10 [stat.ML], 2014.   \nA. Krizhevsky et al. Imagenet classification with deep convolutional neural networks. In Proceedings of the Neural Information Processing Systems Conference, 2012.   \nA. Larsen et al. Autoencoding beyond pixels using a learned similarity metric. arXiv:1512.09300v2, 2016.   \nA. Makhzani et al. Adversarial autoencoders. arXiv:1511.05644v2, 2016.   \nV. Nair and G. Hinton. Rectified linear units improve restricted boltzmann machines. In Proceedings of the 27 th International Conference on Machine Learning, Haifa, Israel, 2010.   \nA. Rasmus et al. Semi-supervised learning with ladder networks. arXiv:1507.02672v2 [cs.NE], 2015.   \nD. Rumelhart et al. Learning representations by back-propagating errors. Nature, 323:533–536, October 1986.   \nS. Russell and P. Norvig. Artificial Intelligence A Modern Approach, chapter 18: Learning from examples. Person publications, 3rd edition, 2015. ",
+        "bbox": [
+            171,
+            125,
+            828,
+            569
+        ],
+        "page_idx": 6
+    }
+]

parse/train/xLExSzfIDmo/xLExSzfIDmo.md

@@ -0,0 +1,236 @@
+# Robust Contrastive Learning Using Negative Samples with Diminished Semantics
+
+Songwei Ge Univeristy of Maryland songweig@cs.umd.edu
+
+Shlok Mishra Univeristy of Maryland shlokm@cs.umd.edu
+
+Haohan Wang Carnegie Mellon University haohanw@cs.cmu.edu
+
+Chun-Liang Li Google Cloud AI chunliang@google.com
+
+David Jacobs Univeristy of Maryland dwj@cs.umd.edu
+
+# Abstract
+
+Unsupervised learning has recently made exceptional progress because of the development of more effective contrastive learning methods. However, CNNs are prone to depend on low-level features that humans deem non-semantic. This dependency has been conjectured to induce a lack of robustness to image perturbations or domain shift. In this paper, we show that by generating carefully designed negative samples, contrastive learning can learn more robust representations with less dependence on such features. Contrastive learning utilizes positive pairs that preserve semantic information while perturbing superficial features in the training images. Similarly, we propose to generate negative samples in a reversed way, where only the superfluous instead of the semantic features are preserved. We develop two methods, texture-based and patch-based augmentations, to generate negative samples. These samples achieve better generalization, especially under out-of-domain settings. We also analyze our method and the generated texture-based samples, showing that texture features are indispensable in classifying particular ImageNet classes and especially finer classes. We also show that model bias favors texture and shape features differently under different test settings. Our code, trained models, and ImageNet-Texture dataset can be found at https://github.com/ SongweiGe/Contrastive-Learning-with-Non-Semantic-Negatives.
+
+# 1 Introduction
+
+Recent studies on self-supervised learning have shown great success in learning visual representations without human annotations. The gap between unsupervised and supervised learning has been progressively closed by contrastive learning [53, 48, 7, 18, 49, 6, 16, 56]. In the meantime, CNNs trained in the supervised setting are known to learn correlations between labels and superfluous features such as local patches [4, 3], texture [14], high-frequency components [51], and even artificially added features [26], which has raised concerns about deploying these models in a real scenario [30, 15]. CNNs trained by contrastive learning methods are no exception [23]. In this paper, we propose to construct negative samples that only preserve non-semantic features. We show that using contrastive learning methods trained with these negative samples can mitigate these concerns.
+
+Contrastive learning methods exploit carefully designed augmentations to construct positive pairs and pull their representations together. These augmentations are crucial to contrastive learning [7, 6]. A common assumption behind these augmentations is to preserve the semantics of the input images while perturbing other superficial signals. This inspires us to generate negative samples and inject additional implicit biases on the visual features learned by the models. Specifically, we utilize augmentations that diminish the semantic features while keeping the undesired features such as texture. By pushing apart the representations of such negative samples and input images, the models are expected to rely more on the semantics of the images and less on superficial features.
+
+![](images/9ecd5d9e861959c25ccbf6de85b64fafde48ebc920f7eb10ffdb9ee9fce236a0.jpg)  
+Figure 1: We propose to construct negative samples (NS) from input images for contrastive learning with augmentations that only preserve non-semantic information such as texture and local features.
+
+Inspired by the non-semantic features, we propose two methods to craft negative samples. The first method relies on texture synthesis tools from classic approaches [12, 52]. It generates realistic texture images based on two patches extracted from input images, as shown in Figure 1(d). For each image in ImageNet, we generate its texture version and form a dataset which we call ImageNet-Texture. The second method constructs non-semantic images by tiling randomly sampled patches of different sizes from the input image, as shown in Figure 1(e). Comparing the non-semantic negative samples with two semantic positive samples in Figure 1(b) and Figure 1(c), the dog from the input image is still recognizable in the positive samples but hard to understand from negative samples. Instead, local statistics such as the fur and color of the dog are preserved in the negative samples.
+
+The generated non-semantic samples can be readily used with existing contrastive learning methods that distinguish positive pairs from negative pairs such as MoCo [18] and SimCLR [7]. Despite their simplicity, we show that these non-semantic negative samples are actually harder than the standard negative samples used by these methods, which are inefficient at leveraging hard negatives [13, 31]. Further, our negative pairs can also be used by contrastive learning methods that do not explicitly use negative samples, such as BYOL [16]. We evaluate our methods with two contrastive learning methods, MoCo [18, 8] and BYOL [16], on three datasets, ImageNet-100, ImageNet-1K and STL10. When using our proposed augmentations to generate negative samples and minimize their representation similarity to the input images, we notice a consistent improvement on the generalization performance over backbone methods [8, 16] and previous negative example generation strategies [31, 43], especially under out-of-distribution (OOD) settings.
+
+We conduct a systematic analysis of how the shape-texture trade-off influences model performance based on the proposed ImageNet-Texture dataset. We control the penalty on similarities between the non-semantic negative examples and the query samples. This impacts the trade-off between using shape and texture features. We find that the relative importance of texture and shape features varies across different datasets. For example, shape bias benefits ImageNet-Sketch [50] more than the original ImageNet validation set. On the other hand, texture bias benefits finer-grained classification more, such as dog breed classification included in ImageNet. These results complement previous evidence showing the effectiveness of shape features in classifying 16 coarse classes [14]. Such preference for one feature over the other is also observed intra-dataset: the texture is more important for some classes such as dishrag and plaque. These observations make us question the relationship between shape and texture features as the implicitly necessary bias of CNNs and advocate for an adaptive combination of both when deploying the model in real scenarios. In summary:
+
+• We propose texture-based and patch-based augmentations to generate negative samples from input images, and show that these negative samples improve the generalization of contrastive learning.   
+• We introduce the ImageNet-Texture dataset, which contains texture versions of ImageNet images generated by texture synthesis tools.   
+• We provide fine-grained analysis on the shape-texture trade-off of CNNs, and show different scenarios when one is preferred over the other.
+
+# 2 Negative Samples with Diminished Semantics
+
+CNNs are apt to learn low level features such as texture under supervised settings [3, 14, 51]; this has been recently witnessed under the contrastive learning setting as well [23]. To mitigate this problem, we propose two methods, texture-based and patch-based augmentations, to generate negative samples for contrastive learning. Texture-based augmentation generates realistic images based on texture synthesis and patch-based augmentation exploits more comprehensive local features by sampling patches from input images. By penalizing learned similarities between the representations of images and their non-semantic counterparts, the model is encouraged to rely less on the undesired features and focus more on the semantics. In practice, we find the two negative samples play similar roles and the patch-based method works slightly better. In this section, we start with an overview of contrastive learning and show how non-semantic negatives are used in these frameworks. Then we elaborate on the two approaches to generate negative samples with diminished semantics.
+
+# 2.1 Contrastive learning with non-semantic negatives
+
+Given an encoder network $f$ and an image $\mathbf { x }$ , we denote the output of the network as $\mathbf { z } = f ( \mathbf { x } )$ . We use $z _ { i }$ and $z _ { p }$ to denote the representations of the query sample $\mathbf { \boldsymbol { x } } _ { i }$ and a positive sample $\mathbf { \boldsymbol { x } } _ { p }$ generated from the same input image with augmentations that preserve semantics. For contrastive learning methods like MoCo [18] and SimCLR [7], $z _ { n }$ denotes the representation of the standard negative sample ${ \pmb x } _ { n }$ extracted from the memory bank (MoCo) or other images in the current batch (SimCLR). $z _ { n s }$ is the representation of the proposed negative sample $\mathbf { \Delta x } _ { n s }$ which contains particular non-semantic features of the input image with the semantic part weakened. We extend the noise-contrastive estimation (NCE) loss as below:
+
+$$
+\mathcal { L } _ { \mathrm { N C E } } = - \sum _ { i \in I } \log \frac { \exp { \left( z _ { i } ^ { T } z _ { p } / \tau \right) } } { \exp { \left( z _ { i } ^ { T } z _ { p } / \tau \right) } + \exp { \left( \alpha z _ { i } ^ { T } z _ { n s } / \tau \right) } + \sum _ { n \in N } \exp { \left( z _ { i } ^ { T } z _ { n } / \tau \right) } } ,
+$$
+
+where $\tau$ is a temperature parameter and $\alpha$ is an additional scaling parameter for non-semantic negatives. A larger $\alpha$ implies a stronger penalty on the similarity between the representations of the query image and its non-semantic version. In Appendix B.1 we discuss other possible ways to apply $\alpha$ .
+
+Methods like BYOL [16] do not explicitly rely on negative samples. Nevertheless, BYOL adapts the loss to maximize the agreement of positive pairs. Therefore, we explicitly use the non-semantic negative sample with their loss to minimize its similarity to the query sample:
+
+$$
+\mathcal { L } _ { \mathrm { B Y O L } } = | | z _ { i } - z _ { p } | | - \alpha | | z _ { i } - z _ { n s } | | = 2 - 2 \alpha - 2 z _ { i } ^ { T } z _ { p } + 2 \alpha z _ { i } ^ { T } z _ { n s } .
+$$
+
+We overload $\alpha$ to be the parameter that controls the penalty on the similarity between the representations of input image and its non-semantic version under BYOL, with similar intention as MoCo and SimCLR above. To minimize either $\mathcal { L } _ { \mathrm { N C E } }$ or $\mathcal { L } _ { \mathrm { B Y O L } }$ , the encoder must learn features from $\mathbf { \Delta } _ { \mathbf { \mathcal { X } } _ { i } }$ that are not contained in $\mathbf { \Delta } _ { \mathbf { \mathcal { X } } _ { n s } }$ but shared with $\mathbf { \boldsymbol { x } } _ { p }$ .
+
+# 2.2 Texture-based negative sample generation
+
+We use texture synthesis tools to generate negative samples. Texture synthesis aims to generate realistic images that preserve as much local structure as possible from an example image [19, 11, 42]. For instance, as shown in Figure 1(d), the texture of the input dog image preserves the fur and colors of the dog. Notably, in previous discussion of robustness [3, 50], such local structure has often been recognized as highly correlated with the labels yet superfluous to generalization. For example, under large domain shift due to lighting, motion, and even modality, the texture is more apt to change than the semantic features, such as the shape. Furthermore, CNNs trained on ImageNet are more likely to classify images based on the texture features rather than the shape features which are instead preferred by humans due to their transferability [14]. To encourage the model to rely more on the shape features, we propose a two-step method to generate the texture image of input images as the negative samples for contrastive learning.
+
+To be specific, we first sample two patches from given images as the input to the texture synthesis algorithms. One patch is extracted from the center of the image. This patch is expected to reflect the texture of the object according to the implicit bias contained in the ImageNet dataset that most of the objects are center-oriented in the images [2]. The other patch is extracted from a random location to reflect other possible textures of the image (e.g. background, peripheral region of the object). In this work, we extract patches with size $9 6 \times 9 6$ when image size allows, otherwise $4 8 \times 4 8$ patches are extracted. Second, we adopt off-the-shelf texture synthesis algorithms [12, 52, 1] to generate texture images based on the two patches. These non-parametric algorithms iteratively sample pixels from given patches that share a similar neighborhood with the current pixel. Specifically, we use the open-source software built on these methods [12, 52, 1] with multi-threaded CPU support implemented in Rust 1. For each sample in the ImageNet dataset, we generate one $2 2 4 \times 2 2 4$ texture image to construct a dataset that has the same training and validation size as the ImageNet dataset. We call this dataset ImageNet-Texture. More examples can be found in Appendix A.1.
+
+# 2.3 Patch-based negative sample generation
+
+To simulate the local information contained in the images [4, 3], we propose an efficient patch-based method to generate non-semantic images. Given an image and a patch size $d$ , we sample patches of size $d$ from $\textstyle { \left( \lceil \frac { 2 2 4 } { d } \rceil \right) ^ { 2 } }$ non-overlapping random locations that lie entirely in the image. The patches are then tiled and cropped into $2 2 4 \times 2 2 4$ as negative samples. Compared with the texture-based method, this generation process takes negligible time, therefore it can be implemented as part of the data loading process in parallel with training. By doing so, each training sample can be paired with different negative samples generated from different patches every time it is used, compared with the two fixed patches selected when generating texture images.
+
+Different from the texture-based method that generates realistic images, the patch-based method generates images with artificial lines as shown in Figure 1e. One might be concerned with possible degenerate solution where the model outputs a low similarity whenever it detects the repeated sharp changes in the horizontal or vertical directions, which could be done with a single layer of convolution. However, interestingly, we find that the model does not find such a simple solution in practice. This is also noticed in a previous study where the image and its copy with a patch cut out are non-trivially distinguished by the model [34]. To mitigate this potential issue, we randomly sample patch size $d$ from a prior distribution instead of using a fixed $d$ in practice, which allows the model to look at texture at different scales.
+
+# 2.4 How hard are the texture-based and patch-based negative samples?
+
+Constrastive learning methods are known to struggle with finding hard negative samples [13, 31] and researchers have proposed several ways to better leverage hard negatives [31, 43]. An intermediate question is how hard are our proposed negative samples compared with those standard negative samples used in previous constrastive learning methods [7, 18], i.e. random training samples.
+
+![](images/053ffd820a486e3452bda8b348ec62db7db59f94587e6cc554e2bef9504f7767.jpg)  
+Figure 2: The histogram of cosine similarity between the representations of query sample and its paired samples, namely positive sample and standard, texture-based, and patch-based negative samples (NS), using MoCo-v2 model trained on the ImageNet-1K dataset for 200 epochs.
+
+We use the official MoCo-v2 model pretrained on the ImageNet-1K dataset for 200 epochs to calculate the cosine similarities between different kinds of pairs across the ImageNet training set. We plot the histogram of these similarities in Figure 2. As shown in the Figures 2a and 2b, most positive pairs and negative pairs have similarity close to 1 and 0 respectively. Specifically, the average similarities across the training samples are 0.94257 and 0.00018 for positive and negative pairs. As shown in the Figures 2d and 2c, the distributions of patch-based and texture-based negative samples are very different from those of standard negative samples; their similarity distributions have heavy tails in the positive region. Specifically, the distribution of patch-based and texture-based negative samples have average similarity 0.29503 and 0.35248 across the dataset, which shows that they remain difficult after training with standard negative examples.
+
+# 3 Experiments
+
+In this section, we evaluate the two kinds of non-semantic negative samples with two contrastive learning methods, MoCo and BYOL, on the ImageNet dataset. We also experiment using its subset, the ImageNet-100 dataset [48, 31], which allows us to perform more comprehensive experiments. We report accuracy on out-of-domain (OOD) datasets including the ImageNet-C(orruption) [22], ImageNet-S(ketch) [50], Stylized-ImageNet [14], and ImageNet-R(endition)[21] datasets as an evaluation of the model’s robustness to domain shifts. ImageNet-C and Stylized-ImageNet contain images transformed from the images in the ImageNet validation set with common corruption and transferred style. ImageNet-S and ImageNet-R are collected independently from the ImageNet dataset and share all or a subset of the classes in the ImageNet dataset with a focus on sketch and other rendering modalities. We show that with our proposed non-semantic negatives, contrastive learning generalizes better under domain shifts. For patch-based negatives, it also improves the performance on the in-domain dataset.
+
+# 3.1 ImageNet-100
+
+Table 1: Top-1 accuracy on the ImageNet-100 dataset and its OOD variants. We consider the supervised baseline as well as several self-supervised baselines including MoCo-v2, BYOL, InsDis, CMC, and InfoMIN. For our main comparison using MoCo-v2 and BYOL, we also report the standard deviation of 3 runs. For MoCo models, $k$ represents the size of the memory bank. We use \* to denote the experiments that use the training setting in a concurrent work IFM [44].   
+
+<table><tr><td></td><td>ImageNet</td><td>ImageNet-C</td><td>ImageNet-S</td><td>Stylized-ImageNet</td><td>ImageNet-R</td></tr><tr><td>MoCo-v2-k=16384</td><td>77.88±0.28</td><td>43.08±0.27</td><td>28.24±0.58</td><td>16.20±0.55</td><td>32.92±0.12</td></tr><tr><td>+ Texture-based -α = 2</td><td>77.76±0.17</td><td>43.58±0.33</td><td>29.11±0.39</td><td>16.59±0.17</td><td>33.36±0.15</td></tr><tr><td>+Patch-based -α = 2</td><td>79.35±0.12</td><td>45.13±0.35</td><td>31.76±0.88</td><td>17.37±0.19</td><td>34.78±0.15</td></tr><tr><td>+ Patch-based -α=3</td><td>75.58±0.52</td><td>44.45±0.15</td><td>34.03±0.58</td><td>18.60±0.26</td><td>36.89±0.11</td></tr><tr><td>MoCo-v2-k=8192</td><td>77.73±0.38</td><td>43.22±0.39</td><td>28.45±0.36</td><td>16.83±0.12</td><td>33.19±0.44</td></tr><tr><td>+ Patch-based -α = 2</td><td>79.54±0.32</td><td>45.48±0.20</td><td>33.36±0.45</td><td>17.81±0.32</td><td>36.31±0.37</td></tr><tr><td>MoCo-v2*</td><td>80.00±0.14</td><td>45.15±0.42</td><td>30.38±0.30</td><td>16.68±0.39</td><td>30.38±0.30</td></tr><tr><td>+ IFM[44]- ε = 0.05</td><td>80.86</td><td>47.36</td><td>31.35</td><td>18.18</td><td>36.79</td></tr><tr><td>+ IFM[44] - ε= 0.1</td><td>81.22</td><td>47.46</td><td>31.87</td><td>18.42</td><td>37.23</td></tr><tr><td>+ IFM[44] - ε = 0.2</td><td>81.02</td><td>47.19</td><td>31.55</td><td>18.68</td><td>37.14</td></tr><tr><td>+ Patch-based -α = 2</td><td>81.49±0.11</td><td>47.48±0.20</td><td>34.20±0.40</td><td>17.95±0.41</td><td>38.45±0.19</td></tr><tr><td>BYOL</td><td>78.76±0.28</td><td>44.43±0.35</td><td>35.84±0.38</td><td>15.01±0.19</td><td>39.53±0.51</td></tr><tr><td>+ Patch-based -α = 0.05</td><td>78.81±0.33</td><td>44.60±0.21</td><td>36.76±0.51</td><td>15.52±0.22</td><td>41.16±0.39</td></tr><tr><td>InsDis [53]</td><td>68.52</td><td>28.93</td><td>16.67</td><td>9.86</td><td>19.60</td></tr><tr><td>CMC [48]</td><td>79.34</td><td>39.28</td><td>24.04</td><td>13.88</td><td>32.68</td></tr><tr><td>InfoMin [49]</td><td>82.74</td><td>48.87</td><td>38.43</td><td>18.14</td><td>40.68</td></tr><tr><td>Supervised</td><td>86.26</td><td>49.17</td><td>34.95</td><td>21.20</td><td>39.76</td></tr></table>
+
+We follow the hyperparameters used in [31] to train MoCo-v2 on the ImageNet-100 dataset with a memory bank size $k = 1 6 3 8 4$ or a halved memory bank size. We also conduct experiments following the hyperparameters in a concurrent study [44] except that we keep $k = 1 6 3 8 4$ for our method. For patch-based augmentation parameters, we use patch size sampled from a uniform distribution $d \sim \mathcal { U } ( 1 6 , 7 2 )$ . The parameter $\alpha$ is indicated behind each model name. We discuss the impact of $\alpha$ in detail in the next section. More ablations on the patch-based augmentations can be found in Appendix C.3. For ImageNet-C, we report the average accuracy across 5 levels of corruption severity.
+
+We repeat the experiments, including both the pretraining and linear evaluation, for 3 runs and report the mean and standard deviation in Table 1. As shown in the table, when following the previous memory bank size, using both patch-based and texture-based negatives improve the OOD generalizations. Specifically, patch-based augmentation increases the accuracy on ImageNet-S by ${ \bar { 5 } } . 7 9 \%$ and ImageNet-R by $5 . 9 7 \%$ when $\alpha = 3$ . When $\alpha = 2$ , it also increases the in-domain accuracy by $1 . 4 7 \%$ and accuracy on ImageNet-C by $2 . 0 5 \%$ . The similar trend shared by standard ImageNet and ImageNet-C with different $\alpha$ can be attributed to the resemblance of the images in the two dataset, especially those corrupted images with a lower level of severity. We show the performance of the model with $\alpha = 3$ is actually better on the highest corruption level as shown in Appendix C.2. The improvement achieved using texture-based negatives is less, probably because the information contained in the texture image is restricted due to the limited access to the two fixed patches. When the memory bank is halved to be 8, 192, the baseline MoCo model has slightly worse performance, decreasing from 77.88 to 77.73. But with patch-based hard negative samples, the MoCo-v2 model instead achieved the best accuracy 79.54 on the ImageNet-100 validation set, IamgeNet-C and IamgeNet-R. We discuss this more in a later section.
+
+![](images/13e0947ad2247e9e55fca29e31f1da4e0662f238e8457ce44311671fec0a3e71.jpg)  
+Figure 3: Histogram of cosine similarity between the representations of query sample and its paired positive sample, standard, texture-based, and patch-based negative samples (NS), using models trained without (blue) and with patch-based negative samples (red: $\alpha = 2$ , green: $\alpha = 3$ ).
+
+Similar to Figure 2, in Figure 3 we visualize the distribution of the cosine similarity between the query sample and both semantic and non-semantic samples calculated based on the models trained with and without patch-based negative samples. The shift of the distribution towards the origin in Figure 3d meets the expectation that our method reduces the similarity of input images and patch-based negative samples. Specifically, the average similarity decreases from 0.4040 to 0.3252 to 0.1593 when $\alpha$ increases from 0, namely no patched-based negatives, to 2 to 3. Interestingly, we notice in Figure 3c that the similarity to texture-based negative samples also decreases, and the average similarity decreases from 0.4114 to 0.3541 to 0.1896, although we did not explicitly penalize it. This demonstrates the resemblance of patch-based negative samples to texture-based negative samples. Given the better performance achieved with patch-based negative samples, for the rest of the experiments, we mainly focus on the patch-based methods. But we still conduct our analysis on the texture-based samples. We also find a marginal decrease in the positive similarity $( - 0 . 0 0 6 8 )$ and negative similarity $( - 0 . 0 0 0 8 )$ when $\alpha = 2$ and a substantial decrease in the positive similarity $( - 0 . 0 7 3 7 )$ and increase in the negative similarity (0.0036) when $\alpha = 3$ . A similar figure for texture-based negative samples can be found in the Appendix in Figure 12.
+
+# 3.2 ImageNet-1K
+
+<table><tr><td></td><td>ImageNet</td><td>ImageNet-C</td><td>ImageNet-S</td><td>Stylized-ImageNet</td><td>ImageNet-R</td></tr><tr><td>MoCo-v2 [8]</td><td>67.60</td><td>87.7</td><td>17.47</td><td>5.55</td><td>27.81</td></tr><tr><td>+ MoCHi [31]</td><td>67.56</td><td>88.7</td><td>16.32</td><td>5.94</td><td>25.71</td></tr><tr><td>+ Patch-base NS -α = 2</td><td>67.92</td><td>87.6</td><td>18.58</td><td>6.34</td><td>28.95</td></tr></table>
+
+Table 2: Top-1 accuracy on the ImageNet-1K dataset and its sketch, stylized, rendition variants, and mCE on the ImageNet-C dataset.
+
+We follow the official hyperparameters [8] to train MoCo-v2 with our patch-based negative samples on the ImageNet-1K dataset. For the parameter $\alpha$ and patch size $d$ , we follow the same configuration used on the ImageNet-100 dataset. We compare our results against the MoCo-v2 baseline [8] and the hard negative mixing algorithm, MoCHi [31]. Due to limited computational resources, we report the metrics evaluated with the official model without repeated runs. The results are shown in Table 2.
+
+More results can be found in Appendix C.6. Note that for ImageNet-C, we show the mCE metric [22], for which smaller is better. For the other datasets, we show the top-1 accuracy.
+
+# 3.3 Extension to other non-semantic features
+
+Non-semantic features are sometimes referred to as “shortcuts” in the contrastive learning literature [6, 7]. Models that leverage such features often exhibit unfavorable generalization to downstream tasks. For example, without color jittering, SimCLR [9] tends to utilize color histograms to reduce the training loss. In this section, we show that models trained with nonsemantic negatives are coerced to avoid the shortcuts shared between query images and their non-semantic counterparts. In the example of the color shortcut, we
+
+<table><tr><td>Model</td><td>Top-1 Accuracy</td></tr><tr><td>MoCo-v2 [8]</td><td>70.44</td></tr><tr><td>+ Patch-based NS</td><td>76.42</td></tr></table>
+
+Table 3: Test accuracy of MoCo-v2 on the ImageNet-100 dataset after removing color jittering and adding patch-based negatives.
+
+note that the expected color distribution of our patch-based negatives is identical to that of the query images, and the actual distribution of samples is close. We conduct experiments with MoCo-v2 on the ImageNet-100 dataset while removing the color jittering from the augmentations. The accuracy of models with and without patch-based negatives are reported in Table 3. We found that patch-based negatives contribute significant effectiveness in preventing the models from learning such a color distribution shortcut.
+
+# 3.4 Memory bank size
+
+Contrastive learning methods based on negative samples suffer from ineffective excavation of hard negatives [13, 31] and resort to large batch sizes [7] or memory bank [18]. In this section, we study whether our proposed negative samples can mitigate this problem on the STL-10 and ImageNet-100 datasets. We keep the hyperparameters intact and vary the memory bank size. We report the accuracy of the MoCo-v2 baseline with and without patch-based negative samples on STL-10 dataset in Table 4. We also compare with [43] which exploits hard negatives through reweighting. We found that with proper hyperparameters the MoCo-v2 baseline already beats the reweighting results with SimCLR.
+
+<table><tr><td>SimCLR[7] + Debiased [10] + Hard [43]</td><td>80.16 84.908 87.428</td></tr><tr><td>MoCo-v2 [8]</td><td>88.00</td></tr><tr><td>+ Patch-based NS</td><td>89.36</td></tr></table>
+
+Table 4: Top-1 accuracy on the STL-10 dataset.
+
+![](images/0b38077e0c3c65a670fda2ace37e180bbbbb07800ff1f071f7779145860a5cbc.jpg)  
+Figure 4: Top-1 accuracy on the STL-10 dataset with different memory bank sizes.
+
+![](images/8da6d9ec1b551ab8ff2c66031e55c4aae98dcc8dfc11c58806b92f2b9972ce8c.jpg)  
+Figure 5: Top-1 accuracy on the ImageNet-100 dataset with different memory bank sizes.
+
+§ denotes results visually extracted from Figure 2 in [43].
+
+As shown in Figures 4 and 5, using patch-based non-semantic negatives consistently improves the MoCo baseline when the number of standard negatives varies. When slightly decreasing the memory bank size on the STL-10 dataset as shown in Figure 4 and ImageNet-100 in Table 1, the performance with patch-based negatives increases. This is probably because, according to Eq. 1 and analysis in Appendix B.1, a smaller memory bank size causes a larger contribution of non-semantic negatives to the loss, and consequently a larger regularization. To further demystify this observation, we conduct experiments with evenly sampled memory bank sizes between 4096 and 16384 and report the average and standard deviation across 3 runs in Figure 5. We confirm a consistent recession of baseline accuracy when decreasing memory back sizes [18, 43]. However, the steady improvement led by the non-semantic negatives effectively mitigates the problem - the decrease caused by a smaller memory bank is less substantial and using patch-based negatives always beats the baseline.
+
+# 4 Discussion
+
+# 4.1 Controlling the shape-texture trade-off with $\alpha$
+
+There has been a growing interest in understanding the cause and impact of the trade-off between shape and texture bias of CNNs [14, 23, 35, 27]. CNNs trained on ImageNet are known to be over-reliant on the texture features [14]. Contrastive learning with our non-semantic negatives serve as not only an effective method to reduce such reliance, but a natural tool to study such a trade-off.
+
+![](images/4992b7aa00d082da0b5210f824275b6074f9ac4af7a1f2f7c2d058ec5fc6a667.jpg)  
+Figure 6: Larger $\alpha$ monotonically increases the model bias to shape features over texture features. Model performance is impacted by such a trade-off differently under different settings. In all scenarios, slightly calibrated shape bias improves model performance. The test settings represented in the red lines gain more from the increased shape bias than the settings represented in the green lines.
+
+We train MoCo-v2 models with different $\alpha$ from 1 to 5 on the ImageNet-100 dataset. As shown in Figure 6a, we find that $\alpha$ effectively controls the trade-off on the model bias to the shape and texture features. $\alpha = 0$ is used to denote the baseline method. Specifically, a larger $\alpha$ in the loss function 1 leads to a larger penalty on the similarity between the representations of query samples and non-semantic samples, consequently a larger shape bias. We follow [14] to calculate shape bias on the stimuli images with conflicted shape and texture clues generated by style transfer. We show the corresponding accuracy on the shape and texture labels in Figure 6b.
+
+As shown in Figure 6b, when $\alpha$ increases the texture accuracy on the stimuli dataset monotonically decreases while the shape accuracy monotonically increases. To further study how the trade-off between shape and texture bias impacts the model performance, we first compare the accuracy on the ImageNet validation dataset and ImageNet-Sketch dataset [50] when $\alpha$ varies in Figure 6c. We find that on both datasets, slightly increased shape bias over baseline $\alpha = 2$ ) improves performances. Interestingly, the accuracy peak on the ImageNet-Sketch appears at $\alpha = 3$ while the peak appears at $\alpha = 2$ on the ImageNet validation dataset. In addition, for even larger $\alpha$ the accuracy on the ImageNet-Sketch dataset still outperforms the baseline while the standard accuracy gets hurt. This shows that different downstream tasks may benefit differently from differently shape-biased models.
+
+We plot the histograms of similarities calculated by the models trained with different $\alpha$ in Appendix Figure 13. We find that large $\alpha$ makes the original pretext task challenging - the model cannot effectively pull together the representations of positive pairs. Specifically, when $\alpha$ increases from 1 to 5, the average similarity of the positive pairs decrease from 0.9267 to 0.7541. This demonstrates that it is hard for the model to learn representations that are completely independent of the texture features contained in the non-semantic images.
+
+# 4.2 Rethinking the shape-texture trade-off through class-based analysis
+
+The initial discussion on the shape-texture trade-off shows that humans rely more on the shape features while CNNs rely more on texture features and increasing shape bias can improve accuracy and robustness [14]. However, similar to [40, 23], we notice that increasing shape bias does not always improve the generalization and robustness of the models. To better understand this phenomenon, we provide two observations based on the analysis of the ImageNet-Texture dataset and our method to explain why a texture-biased model is helpful with classification on the ImageNet dataset.
+
+First, we find that an increasing shape bias often leads to more errors among the fine-grained classes. The initial discussion of the shape-bias [14] only pays attention to the selected 16 coarse classes. We thus compare the finer and coarse class accuracy on the dog images of ImageNet dataset as in Figure 6d. For coarse class accuracy, the predictions are counted to be correct whenever the image is classified as a dog class, no matter which dog class is predicted, while for the finer class accuracy, only those predictions of target dog classes are counted to be correct. We notice that the finer class accuracy drops more significantly when shape bias increases as opposed to the coarse class accuracy. For example, when $\alpha = 3$ , the finer class accuracy drops from 72.9 to 67.6 while the coarse class accuracy slightly decreases from 97.8 to 97.7. Therefore, for datasets with numerous fine-grained classes like ImageNet, a texture-biased model is more helpful for a higher accuracy, which confirms the previous conjecture [54] . Second, in Appendix Figure 9, we show a scatter plot of texture accuracy vs. standard accuracy of different model architectures and a histogram of accuracy on individual ImageNet-Texture classes. We identify several classes where using only texture features is sufficient to achieve a high classification accuracy. These classes are all missing in the previous study [14]. As shown in Figure 7 and Appendix Figure 10, texture serves as a more important clue than the shape for these classes.
+
+![](images/c6ba57412c923a730dcc67460ee2fbfd0c28a8d9834c454fafc9b5d28ea800bd.jpg)  
+Figure 7: A ResNet-50 model trained on the ImageNet dataset achieves decent accuracy when only texture features are available on some classes. A normal image and its texture version are displayed for some of these classes. The caption indicates the class ID, name, and accuracy on texture images.
+
+# 5 Related Work
+
+Contrastive learning based self-supervised learning Recent contrastive learning based selfsupervised learning methods including MoCo [18], SimCLR [7], InfoMin[49], SimSiam[9], BYOL [16], SwAV [6], Barlow Twins [56] have proven helpful in learning visual representations. These methods rely on different pretext tasks to increase the agreement among the different views of the same image. The augmentations used to generate these views are essential to the success of these contrastive learning methods [7, 6] by preventing shortcuts such as the use of simple color histogram [7]. There is an ongoing trend of developing novel augmentations [6, 49] or adaptively applying augmentations [54] and consistent improvement has been achieved with these studies. However, it is intractable to eliminate every shortcut and sometimes tricky to craft the correct positive pairs. Different from these methods, we show that augmentations that perturb the semantic features and craft negative samples can be more effective to impose additional regularization. For example, to prevent models from relying on local features, it is much easier to destroy global features and create negatives than to remove all the local features and create positives. Furthermore, by maximizing the difference between natural images and their non-semantic versions in the representation space, the models are coerced to avoid any potential shortcuts shared by them.
+
+Methods like MoCo [18] and SimCLR [7] distinguish positive pairs from negative pairs that are picked from the rest of the dataset. However, most of the negatives prove to be unnecessary and insufficient [13, 31]. To excavate effective negative samples, these methods heavily depend on the large batch sizes [7] or memory bank [18]. Utilizing hard negative samples has long been recognized as an effective approach to boost model performance [17, 29, 55, 46]. In the contrastive learning studies, [10, 43] modify the contrastive learning loss to make it assign greater weights to the hard negative samples. [31] proposes to synthesize hard negative samples by taking linear combinations of the hardest negative samples. Our work is orthogonal to these ideas in the way that we propose to generate negative samples from given images themselves to reduce the reliance on the undesired features. In addition, two recent works [25, 32] study the application of adversarial examples as hard positive and negative samples in contrastive learning. [45] augments the images by manipulating their foregrounds and backgrounds to generate negative and positive samples. Compared with these studies, we mainly focus on the OOD evaluation of the models. In addition, our patch-based augmentation is also related to the self-Supervised learning methods that adopt the pretext task based on jigsaw [41, 39, 20], which we discuss in the Appendix B.2.
+
+Robustness and out-of-domain generalization of CNNs High test accuracy provides no guarantee that a network learns high-level semantic features instead of low-level superfluous features that exist in both training and test dataset [30]. An increasing number of studies have corroborated such concerns and found that CNNs can rely on local patches [4, 3], texture [14], high-frequency components [51] and even artificially added features [26] to achieve high test accuracy. These superficial correlations become brittle under large domain shifts [22, 21]. This still remains an unsolved problem [47] and is rarely discussed in the contrastive learning setting.
+
+Among all these undesired features, the shape-texture bias has been widely discussed in recent studies [14, 36]. Previous work has shown that CNNs trained on the ImageNet dataset are biased to texture features and such over-reliance can hurt the generalization performance of CNNs [14, 24]. Several studies have aimed at mitigating this problem [38, 35] or providing a better understanding [23, 27]. In this paper, we introduce a dataset called ImageNet-Texture, which can help future studies on these problems. Our method also effectively controls the trade-off between shape and texture bias. We provide new insights about this problem based on the analysis of our method and dataset.
+
+# 6 Closing Remarks
+
+Conclusion CNNs are prone to learn discriminative features that are vulnerable under domain shifts. In this paper, we first demonstrate the regularization power of contrastive learning to discard any undesired features by generating appropriate negative samples. We explore two approaches, the patch-based and texture-based augmentations, to craft negative samples with only local features preserved. We show that the representations learned by contrastive learning with such negative samples depend less on the local features, and consequently generalize better under OOD settings. We hope this paper can encourage people to rethink the role that negative samples play in contrastive learning, which hopefully leads to more efficient methods to generate negative samples.
+
+Limitations The problem of dependence on superficial features exists in various domains beyond vision, such as language [37, 28]. Therefore, it is intriguing to consider generalizing such an idea to other modalities. In addition, as the mechanism to ensure that contrastive learning models trained on large datasets to discard the bias of the datasets is yet to be invented, severe social issues in fairness or privacy may be raised as a result [5, 33]. In this paper, we show how to calibrate the bias towards texture features using proposed negative samples. It is also worth considering whether contrastive learning can be used to address any of these negative effects triggered by bias in datasets.
+
+# Acknowledgments and Disclosure of Funding
+
+The authors thank the National Science Foundation, grant no. IIS-1910132 and the Guaranteeing AI Robustness Against Deception (GARD) program from DARPA for their support of this project. The authors thank Yannis Kalantidis for his help with reproducing MoCo-v2 on the ImageNet-100 dataset and Joshua Robinson for providing the checkpoints of IFM models for comparison.
+
+# References
+
+[1] M. Ashikhmin. Synthesizing natural textures. In Proceedings of the 2001 symposium on Interactive 3D graphics, pages 217–226, 2001.   
+[2] L. Beyer, O. J. Hénaff, A. Kolesnikov, X. Zhai, and A. van den Oord. Are we done with imagenet?, 2020.   
+[3] W. Brendel and M. Bethge. Approximating CNNs with bag-of-local-features models works surprisingly well on imagenet. In International Conference on Learning Representations, 2019.   
+[4] T. B. Brown, D. Mané, A. Roy, M. Abadi, and J. Gilmer. Adversarial patch. arXiv preprint arXiv:1712.09665, 2017.   
+[5] J. Buolamwini and T. Gebru. Gender shades: Intersectional accuracy disparities in commercial gender classification. In Conference on fairness, accountability and transparency, pages 77–91. PMLR, 2018.   
+[6] M. Caron, I. Misra, J. Mairal, P. Goyal, P. Bojanowski, and A. Joulin. Unsupervised learning of visual features by contrasting cluster assignments. arXiv preprint arXiv:2006.09882, 2020.   
+[7] T. Chen, S. Kornblith, M. Norouzi, and G. Hinton. A simple framework for contrastive learning of visual representations. In International conference on machine learning, pages 1597–1607. PMLR, 2020. [8] X. Chen, H. Fan, R. Girshick, and K. He. Improved baselines with momentum contrastive learning. arXiv preprint arXiv:2003.04297, 2020.   
+[9] X. Chen and K. He. Exploring simple siamese representation learning. arXiv preprint arXiv:2011.10566, 2020.   
+[10] C.-Y. Chuang, J. Robinson, Y.-C. Lin, A. Torralba, and S. Jegelka. Debiased contrastive learning. In H. Larochelle, M. Ranzato, R. Hadsell, M. F. Balcan, and H. Lin, editors, Advances in Neural Information Processing Systems, volume 33, pages 8765–8775. Curran Associates, Inc., 2020.   
+[11] J. S. De Bonet. Multiresolution sampling procedure for analysis and synthesis of texture images. In Proceedings of the 24th annual conference on Computer graphics and interactive techniques, pages 361–368, 1997.   
+[12] A. A. Efros and T. K. Leung. Texture synthesis by non-parametric sampling. In Proceedings of the seventh IEEE international conference on computer vision, volume 2, pages 1033–1038. IEEE, 1999.   
+[13] J. Frankle, D. J. Schwab, A. S. Morcos, et al. Are all negatives created equal in contrastive instance discrimination? arXiv preprint arXiv:2010.06682, 2020.   
+[14] R. Geirhos, P. Rubisch, C. Michaelis, M. Bethge, F. A. Wichmann, and W. Brendel. Imagenet-trained CNNs are biased towards texture; increasing shape bias improves accuracy and robustness. In International Conference on Learning Representations, 2019.   
+[15] R. Geirhos, C. R. M. Temme, J. Rauber, H. H. Schütt, M. Bethge, and F. A. Wichmann. Generalisation in humans and deep neural networks. In Proceedings of the 32nd International Conference on Neural Information Processing Systems, pages 7549–7561, 2018.   
+[16] J.-B. Grill, F. Strub, F. Altché, C. Tallec, P. Richemond, E. Buchatskaya, C. Doersch, B. Avila Pires, Z. Guo, M. Gheshlaghi Azar, B. Piot, k. kavukcuoglu, R. Munos, and M. Valko. Bootstrap your own latent - a new approach to self-supervised learning. In H. Larochelle, M. Ranzato, R. Hadsell, M. F. Balcan, and H. Lin, editors, Advances in Neural Information Processing Systems, volume 33, pages 21271–21284. Curran Associates, Inc., 2020.   
+[17] B. Harwood, V. Kumar B G, G. Carneiro, I. Reid, and T. Drummond. Smart mining for deep metric learning. In Proceedings of the IEEE International Conference on Computer Vision (ICCV), Oct 2017.   
+[18] K. He, H. Fan, Y. Wu, S. Xie, and R. Girshick. Momentum contrast for unsupervised visual representation learning. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 9729–9738, 2020.   
+[19] D. J. Heeger and J. R. Bergen. Pyramid-based texture analysis/synthesis. In Proceedings of the 22nd annual conference on Computer graphics and interactive techniques, pages 229–238, 1995.   
+[20] O. Henaff. Data-efficient image recognition with contrastive predictive coding. In International Conference on Machine Learning, pages 4182–4192. PMLR, 2020.   
+[21] D. Hendrycks, S. Basart, N. Mu, S. Kadavath, F. Wang, E. Dorundo, R. Desai, T. Zhu, S. Parajuli, M. Guo, D. Song, J. Steinhardt, and J. Gilmer. The many faces of robustness: A critical analysis of out-of-distribution generalization. arXiv preprint arXiv:2006.16241, 2020.   
+[22] D. Hendrycks and T. Dietterich. Benchmarking neural network robustness to common corruptions and perturbations. Proceedings of the International Conference on Learning Representations, 2019.   
+[23] K. Hermann, T. Chen, and S. Kornblith. The origins and prevalence of texture bias in convolutional neural networks. Advances in Neural Information Processing Systems, 33, 2020.   
+[24] K. L. Hermann and A. K. Lampinen. What shapes feature representations? exploring datasets, architectures, and training, 2020.   
+[25] C.-H. Ho and N. Nvasconcelos. Contrastive learning with adversarial examples. In H. Larochelle, M. Ranzato, R. Hadsell, M. F. Balcan, and H. Lin, editors, Advances in Neural Information Processing Systems, volume 33, pages 17081–17093. Curran Associates, Inc., 2020.   
+[26] H. Huang, X. Ma, S. M. Erfani, J. Bailey, and Y. Wang. Unlearnable examples: Making personal data unexploitable. In International Conference on Learning Representations, 2021.   
+[27] M. A. Islam, M. Kowal, P. Esser, S. Jia, B. Ommer, K. G. Derpanis, and N. Bruce. Shape or texture: Understanding discriminative features in {cnn}s. In International Conference on Learning Representations, 2021.   
+[28] R. Jia and P. Liang. Adversarial examples for evaluating reading comprehension systems. In Proceedings of the 2017 Conference on Empirical Methods in Natural Language Processing, pages 2021–2031, 2017.   
+[29] S. Jin, A. RoyChowdhury, H. Jiang, A. Singh, A. Prasad, D. Chakraborty, and E. Learned-Miller. Unsupervised hard example mining from videos for improved object detection. In Proceedings of the European Conference on Computer Vision (ECCV), pages 307–324, 2018.   
+[30] J. Jo and Y. Bengio. Measuring the tendency of cnns to learn surface statistical regularities. arXiv preprint arXiv:1711.11561, 2017.   
+[31] Y. Kalantidis, M. B. Sariyildiz, N. Pion, P. Weinzaepfel, and D. Larlus. Hard negative mixing for contrastive learning. In Neural Information Processing Systems (NeurIPS), 2020.   
+[32] M. Kim, J. Tack, and S. J. Hwang. Adversarial self-supervised contrastive learning. In H. Larochelle, M. Ranzato, R. Hadsell, M. F. Balcan, and H. Lin, editors, Advances in Neural Information Processing Systems, volume 33, pages 2983–2994. Curran Associates, Inc., 2020.   
+[33] S. Kiritchenko and S. M. Mohammad. Examining gender and race bias in two hundred sentiment analysis systems. arXiv preprint arXiv:1805.04508, 2018.   
+[34] C.-L. Li, K. Sohn, J. Yoon, and T. Pfister. Cutpaste: Self-supervised learning for anomaly detection and localization. arXiv preprint arXiv:2104.04015, 2021.   
+[35] Y. Li, Q. Yu, M. Tan, J. Mei, P. Tang, W. Shen, A. Yuille, and cihang xie. Shape-texture debiased neural network training. In International Conference on Learning Representations, 2021.   
+[36] G. Malhotra and J. Bowers. The contrasting roles of shape in human vision and convolutional neural networks. In CogSci, 2019.   
+[37] T. McCoy, E. Pavlick, and T. Linzen. Right for the wrong reasons: Diagnosing syntactic heuristics in natural language inference. In Proceedings of the 57th Annual Meeting of the Association for Computational Linguistics, pages 3428–3448, 2019.   
+[38] S. Mishra, A. Shah, A. Bansal, J. Choi, A. Shrivastava, A. Sharma, and D. Jacobs. Learning visual representations for transfer learning by suppressing texture. arXiv preprint arXiv:2011.01901, 2020.   
+[39] I. Misra and L. v. d. Maaten. Self-supervised learning of pretext-invariant representations. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 6707–6717, 2020.   
+[40] C. K. Mummadi, R. Subramaniam, R. Hutmacher, J. Vitay, V. Fischer, and J. H. Metzen. Does enhanced shape bias improve neural network robustness to common corruptions? In ICLR, 2021.   
+[41] M. Noroozi and P. Favaro. Unsupervised learning of visual representations by solving jigsaw puzzles. In European conference on computer vision, pages 69–84. Springer, 2016.   
+[42] J. Portilla and E. P. Simoncelli. A parametric texture model based on joint statistics of complex wavelet coefficients. International journal of computer vision, 40(1):49–70, 2000.   
+[43] J. Robinson, C.-Y. Chuang, S. Sra, and S. Jegelka. Contrastive learning with hard negative samples. International Conference on Learning Representations, 2021.   
+[44] J. Robinson, L. Sun, K. Yu, K. Batmanghelich, S. Jegelka, and S. Sra. Can contrastive learning avoid shortcut solutions? NeurIPS, 2021.   
+[45] C. K. Ryali, D. J. Schwab, and A. S. Morcos. Leveraging background augmentations to encourage semantic focus in self-supervised contrastive learning. arXiv preprint arXiv:2103.12719, 2021.   
+[46] E. Simo-Serra, E. Trulls, L. Ferraz, I. Kokkinos, P. Fua, and F. Moreno-Noguer. Discriminative learning of deep convolutional feature point descriptors. In Proceedings of the IEEE International Conference on Computer Vision, pages 118–126, 2015.   
+[47] R. Taori, A. Dave, V. Shankar, N. Carlini, B. Recht, and L. Schmidt. Measuring robustness to natural distribution shifts in image classification. Advances in Neural Information Processing Systems, 33, 2020.   
+[48] Y. Tian, D. Krishnan, and P. Isola. Contrastive multiview coding. In ECCV, 2020.   
+[49] Y. Tian, C. Sun, B. Poole, D. Krishnan, C. Schmid, and P. Isola. What makes for good views for contrastive learning. arXiv preprint arXiv:2005.10243, 2020.   
+[50] H. Wang, S. Ge, Z. Lipton, and E. P. Xing. Learning robust global representations by penalizing local predictive power. In Advances in Neural Information Processing Systems, pages 10506–10518, 2019.   
+[51] H. Wang, X. Wu, Z. Huang, and E. P. Xing. High-frequency component helps explain the generalization of convolutional neural networks. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 8684–8694, 2020.   
+[52] L.-Y. Wei and M. Levoy. Fast texture synthesis using tree-structured vector quantization. In Proceedings of the 27th annual conference on Computer graphics and interactive techniques, pages 479–488, 2000.   
+[53] Z. Wu, Y. Xiong, S. X. Yu, and D. Lin. Unsupervised feature learning via non-parametric instance discrimination. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 3733–3742, 2018.   
+[54] T. Xiao, X. Wang, A. A. Efros, and T. Darrell. What should not be contrastive in contrastive learning. In International Conference on Learning Representations, 2020.   
+[55] H. Xuan, A. Stylianou, X. Liu, and R. Pless. Hard negative examples are hard, but useful. In European Conference on Computer Vision, pages 126–142. Springer, 2020.   
+[56] J. Zbontar, L. Jing, I. Misra, Y. LeCun, and S. Deny. Barlow twins: Self-supervised learning via redundancy reduction. arXiv preprint arXiv:2103.03230, 2021.

parse/train/xLExSzfIDmo/xLExSzfIDmo_content_list.json

@@ -0,0 +1,1080 @@
+[
+    {
+        "type": "text",
+        "text": "Robust Contrastive Learning Using Negative Samples with Diminished Semantics ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            122,
+            823,
+            171
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Songwei Ge Univeristy of Maryland songweig@cs.umd.edu ",
+        "bbox": [
+            207,
+            222,
+            370,
+            263
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Shlok Mishra Univeristy of Maryland shlokm@cs.umd.edu ",
+        "bbox": [
+            413,
+            222,
+            566,
+            262
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Haohan Wang Carnegie Mellon University haohanw@cs.cmu.edu ",
+        "bbox": [
+            606,
+            222,
+            790,
+            263
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Chun-Liang Li Google Cloud AI chunliang@google.com ",
+        "bbox": [
+            279,
+            285,
+            450,
+            327
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "David Jacobs Univeristy of Maryland dwj@cs.umd.edu ",
+        "bbox": [
+            563,
+            285,
+            720,
+            327
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            363,
+            535,
+            378
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Unsupervised learning has recently made exceptional progress because of the development of more effective contrastive learning methods. However, CNNs are prone to depend on low-level features that humans deem non-semantic. This dependency has been conjectured to induce a lack of robustness to image perturbations or domain shift. In this paper, we show that by generating carefully designed negative samples, contrastive learning can learn more robust representations with less dependence on such features. Contrastive learning utilizes positive pairs that preserve semantic information while perturbing superficial features in the training images. Similarly, we propose to generate negative samples in a reversed way, where only the superfluous instead of the semantic features are preserved. We develop two methods, texture-based and patch-based augmentations, to generate negative samples. These samples achieve better generalization, especially under out-of-domain settings. We also analyze our method and the generated texture-based samples, showing that texture features are indispensable in classifying particular ImageNet classes and especially finer classes. We also show that model bias favors texture and shape features differently under different test settings. Our code, trained models, and ImageNet-Texture dataset can be found at https://github.com/ SongweiGe/Contrastive-Learning-with-Non-Semantic-Negatives. ",
+        "bbox": [
+            232,
+            393,
+            766,
+            642
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            667,
+            312,
+            685
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recent studies on self-supervised learning have shown great success in learning visual representations without human annotations. The gap between unsupervised and supervised learning has been progressively closed by contrastive learning [53, 48, 7, 18, 49, 6, 16, 56]. In the meantime, CNNs trained in the supervised setting are known to learn correlations between labels and superfluous features such as local patches [4, 3], texture [14], high-frequency components [51], and even artificially added features [26], which has raised concerns about deploying these models in a real scenario [30, 15]. CNNs trained by contrastive learning methods are no exception [23]. In this paper, we propose to construct negative samples that only preserve non-semantic features. We show that using contrastive learning methods trained with these negative samples can mitigate these concerns. ",
+        "bbox": [
+            174,
+            700,
+            825,
+            824
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Contrastive learning methods exploit carefully designed augmentations to construct positive pairs and pull their representations together. These augmentations are crucial to contrastive learning [7, 6]. A common assumption behind these augmentations is to preserve the semantics of the input images while perturbing other superficial signals. This inspires us to generate negative samples and inject additional implicit biases on the visual features learned by the models. Specifically, we utilize augmentations that diminish the semantic features while keeping the undesired features such as texture. By pushing apart the representations of such negative samples and input images, the models are expected to rely more on the semantics of the images and less on superficial features. ",
+        "bbox": [
+            174,
+            832,
+            825,
+            901
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/9ecd5d9e861959c25ccbf6de85b64fafde48ebc920f7eb10ffdb9ee9fce236a0.jpg",
+        "image_caption": [
+            "Figure 1: We propose to construct negative samples (NS) from input images for contrastive learning with augmentations that only preserve non-semantic information such as texture and local features. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            87,
+            821,
+            215
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            281,
+            825,
+            324
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Inspired by the non-semantic features, we propose two methods to craft negative samples. The first method relies on texture synthesis tools from classic approaches [12, 52]. It generates realistic texture images based on two patches extracted from input images, as shown in Figure 1(d). For each image in ImageNet, we generate its texture version and form a dataset which we call ImageNet-Texture. The second method constructs non-semantic images by tiling randomly sampled patches of different sizes from the input image, as shown in Figure 1(e). Comparing the non-semantic negative samples with two semantic positive samples in Figure 1(b) and Figure 1(c), the dog from the input image is still recognizable in the positive samples but hard to understand from negative samples. Instead, local statistics such as the fur and color of the dog are preserved in the negative samples. ",
+        "bbox": [
+            173,
+            329,
+            825,
+            454
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The generated non-semantic samples can be readily used with existing contrastive learning methods that distinguish positive pairs from negative pairs such as MoCo [18] and SimCLR [7]. Despite their simplicity, we show that these non-semantic negative samples are actually harder than the standard negative samples used by these methods, which are inefficient at leveraging hard negatives [13, 31]. Further, our negative pairs can also be used by contrastive learning methods that do not explicitly use negative samples, such as BYOL [16]. We evaluate our methods with two contrastive learning methods, MoCo [18, 8] and BYOL [16], on three datasets, ImageNet-100, ImageNet-1K and STL10. When using our proposed augmentations to generate negative samples and minimize their representation similarity to the input images, we notice a consistent improvement on the generalization performance over backbone methods [8, 16] and previous negative example generation strategies [31, 43], especially under out-of-distribution (OOD) settings. ",
+        "bbox": [
+            174,
+            460,
+            825,
+            612
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We conduct a systematic analysis of how the shape-texture trade-off influences model performance based on the proposed ImageNet-Texture dataset. We control the penalty on similarities between the non-semantic negative examples and the query samples. This impacts the trade-off between using shape and texture features. We find that the relative importance of texture and shape features varies across different datasets. For example, shape bias benefits ImageNet-Sketch [50] more than the original ImageNet validation set. On the other hand, texture bias benefits finer-grained classification more, such as dog breed classification included in ImageNet. These results complement previous evidence showing the effectiveness of shape features in classifying 16 coarse classes [14]. Such preference for one feature over the other is also observed intra-dataset: the texture is more important for some classes such as dishrag and plaque. These observations make us question the relationship between shape and texture features as the implicitly necessary bias of CNNs and advocate for an adaptive combination of both when deploying the model in real scenarios. In summary: ",
+        "bbox": [
+            174,
+            619,
+            825,
+            785
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• We propose texture-based and patch-based augmentations to generate negative samples from input images, and show that these negative samples improve the generalization of contrastive learning.   \n• We introduce the ImageNet-Texture dataset, which contains texture versions of ImageNet images generated by texture synthesis tools.   \n• We provide fine-grained analysis on the shape-texture trade-off of CNNs, and show different scenarios when one is preferred over the other. ",
+        "bbox": [
+            217,
+            799,
+            825,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Negative Samples with Diminished Semantics ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            88,
+            584,
+            107
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "CNNs are apt to learn low level features such as texture under supervised settings [3, 14, 51]; this has been recently witnessed under the contrastive learning setting as well [23]. To mitigate this problem, we propose two methods, texture-based and patch-based augmentations, to generate negative samples for contrastive learning. Texture-based augmentation generates realistic images based on texture synthesis and patch-based augmentation exploits more comprehensive local features by sampling patches from input images. By penalizing learned similarities between the representations of images and their non-semantic counterparts, the model is encouraged to rely less on the undesired features and focus more on the semantics. In practice, we find the two negative samples play similar roles and the patch-based method works slightly better. In this section, we start with an overview of contrastive learning and show how non-semantic negatives are used in these frameworks. Then we elaborate on the two approaches to generate negative samples with diminished semantics. ",
+        "bbox": [
+            173,
+            119,
+            825,
+            272
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.1 Contrastive learning with non-semantic negatives ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            289,
+            557,
+            304
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Given an encoder network $f$ and an image $\\mathbf { x }$ , we denote the output of the network as $\\mathbf { z } = f ( \\mathbf { x } )$ . We use $z _ { i }$ and $z _ { p }$ to denote the representations of the query sample $\\mathbf { \\boldsymbol { x } } _ { i }$ and a positive sample $\\mathbf { \\boldsymbol { x } } _ { p }$ generated from the same input image with augmentations that preserve semantics. For contrastive learning methods like MoCo [18] and SimCLR [7], $z _ { n }$ denotes the representation of the standard negative sample ${ \\pmb x } _ { n }$ extracted from the memory bank (MoCo) or other images in the current batch (SimCLR). $z _ { n s }$ is the representation of the proposed negative sample $\\mathbf { \\Delta x } _ { n s }$ which contains particular non-semantic features of the input image with the semantic part weakened. We extend the noise-contrastive estimation (NCE) loss as below: ",
+        "bbox": [
+            173,
+            313,
+            826,
+            425
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/cbbfb8c7fa237865ecb31cc890b223ff67f775a962402f90b0ac7cd93da2ea71.jpg",
+        "text": "$$\n\\mathcal { L } _ { \\mathrm { N C E } } = - \\sum _ { i \\in I } \\log \\frac { \\exp { \\left( z _ { i } ^ { T } z _ { p } / \\tau \\right) } } { \\exp { \\left( z _ { i } ^ { T } z _ { p } / \\tau \\right) } + \\exp { \\left( \\alpha z _ { i } ^ { T } z _ { n s } / \\tau \\right) } + \\sum _ { n \\in N } \\exp { \\left( z _ { i } ^ { T } z _ { n } / \\tau \\right) } } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            232,
+            430,
+            764,
+            472
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\tau$ is a temperature parameter and $\\alpha$ is an additional scaling parameter for non-semantic negatives. A larger $\\alpha$ implies a stronger penalty on the similarity between the representations of the query image and its non-semantic version. In Appendix B.1 we discuss other possible ways to apply $\\alpha$ . ",
+        "bbox": [
+            173,
+            478,
+            823,
+            534
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Methods like BYOL [16] do not explicitly rely on negative samples. Nevertheless, BYOL adapts the loss to maximize the agreement of positive pairs. Therefore, we explicitly use the non-semantic negative sample with their loss to minimize its similarity to the query sample: ",
+        "bbox": [
+            174,
+            540,
+            823,
+            582
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/19fe78939eaf76d9c7af49d8f43880a0d98a2c5089d2d6a0a138b17d9bb9df87.jpg",
+        "text": "$$\n\\mathcal { L } _ { \\mathrm { B Y O L } } = | | z _ { i } - z _ { p } | | - \\alpha | | z _ { i } - z _ { n s } | | = 2 - 2 \\alpha - 2 z _ { i } ^ { T } z _ { p } + 2 \\alpha z _ { i } ^ { T } z _ { n s } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            266,
+            588,
+            732,
+            608
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We overload $\\alpha$ to be the parameter that controls the penalty on the similarity between the representations of input image and its non-semantic version under BYOL, with similar intention as MoCo and SimCLR above. To minimize either $\\mathcal { L } _ { \\mathrm { N C E } }$ or $\\mathcal { L } _ { \\mathrm { B Y O L } }$ , the encoder must learn features from $\\mathbf { \\Delta } _ { \\mathbf { \\mathcal { X } } _ { i } }$ that are not contained in $\\mathbf { \\Delta } _ { \\mathbf { \\mathcal { X } } _ { n s } }$ but shared with $\\mathbf { \\boldsymbol { x } } _ { p }$ . ",
+        "bbox": [
+            174,
+            613,
+            825,
+            670
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 Texture-based negative sample generation ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            685,
+            504,
+            700
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We use texture synthesis tools to generate negative samples. Texture synthesis aims to generate realistic images that preserve as much local structure as possible from an example image [19, 11, 42]. For instance, as shown in Figure 1(d), the texture of the input dog image preserves the fur and colors of the dog. Notably, in previous discussion of robustness [3, 50], such local structure has often been recognized as highly correlated with the labels yet superfluous to generalization. For example, under large domain shift due to lighting, motion, and even modality, the texture is more apt to change than the semantic features, such as the shape. Furthermore, CNNs trained on ImageNet are more likely to classify images based on the texture features rather than the shape features which are instead preferred by humans due to their transferability [14]. To encourage the model to rely more on the shape features, we propose a two-step method to generate the texture image of input images as the negative samples for contrastive learning. ",
+        "bbox": [
+            173,
+            710,
+            825,
+            863
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To be specific, we first sample two patches from given images as the input to the texture synthesis algorithms. One patch is extracted from the center of the image. This patch is expected to reflect the texture of the object according to the implicit bias contained in the ImageNet dataset that most of the objects are center-oriented in the images [2]. The other patch is extracted from a random location to reflect other possible textures of the image (e.g. background, peripheral region of the object). In this work, we extract patches with size $9 6 \\times 9 6$ when image size allows, otherwise $4 8 \\times 4 8$ patches are extracted. Second, we adopt off-the-shelf texture synthesis algorithms [12, 52, 1] to generate texture images based on the two patches. These non-parametric algorithms iteratively sample pixels from given patches that share a similar neighborhood with the current pixel. Specifically, we use the open-source software built on these methods [12, 52, 1] with multi-threaded CPU support implemented in Rust 1. For each sample in the ImageNet dataset, we generate one $2 2 4 \\times 2 2 4$ texture image to construct a dataset that has the same training and validation size as the ImageNet dataset. We call this dataset ImageNet-Texture. More examples can be found in Appendix A.1. ",
+        "bbox": [
+            174,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            90,
+            825,
+            229
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.3 Patch-based negative sample generation ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            247,
+            490,
+            262
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To simulate the local information contained in the images [4, 3], we propose an efficient patch-based method to generate non-semantic images. Given an image and a patch size $d$ , we sample patches of size $d$ from $\\textstyle { \\left( \\lceil \\frac { 2 2 4 } { d } \\rceil \\right) ^ { 2 } }$ non-overlapping random locations that lie entirely in the image. The patches are then tiled and cropped into $2 2 4 \\times 2 2 4$ as negative samples. Compared with the texture-based method, this generation process takes negligible time, therefore it can be implemented as part of the data loading process in parallel with training. By doing so, each training sample can be paired with different negative samples generated from different patches every time it is used, compared with the two fixed patches selected when generating texture images. ",
+        "bbox": [
+            174,
+            273,
+            825,
+            385
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Different from the texture-based method that generates realistic images, the patch-based method generates images with artificial lines as shown in Figure 1e. One might be concerned with possible degenerate solution where the model outputs a low similarity whenever it detects the repeated sharp changes in the horizontal or vertical directions, which could be done with a single layer of convolution. However, interestingly, we find that the model does not find such a simple solution in practice. This is also noticed in a previous study where the image and its copy with a patch cut out are non-trivially distinguished by the model [34]. To mitigate this potential issue, we randomly sample patch size $d$ from a prior distribution instead of using a fixed $d$ in practice, which allows the model to look at texture at different scales. ",
+        "bbox": [
+            174,
+            390,
+            825,
+            515
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.4 How hard are the texture-based and patch-based negative samples? ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            534,
+            681,
+            547
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Constrastive learning methods are known to struggle with finding hard negative samples [13, 31] and researchers have proposed several ways to better leverage hard negatives [31, 43]. An intermediate question is how hard are our proposed negative samples compared with those standard negative samples used in previous constrastive learning methods [7, 18], i.e. random training samples. ",
+        "bbox": [
+            174,
+            559,
+            825,
+            614
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/053ffd820a486e3452bda8b348ec62db7db59f94587e6cc554e2bef9504f7767.jpg",
+        "image_caption": [
+            "Figure 2: The histogram of cosine similarity between the representations of query sample and its paired samples, namely positive sample and standard, texture-based, and patch-based negative samples (NS), using MoCo-v2 model trained on the ImageNet-1K dataset for 200 epochs. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            631,
+            821,
+            739
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We use the official MoCo-v2 model pretrained on the ImageNet-1K dataset for 200 epochs to calculate the cosine similarities between different kinds of pairs across the ImageNet training set. We plot the histogram of these similarities in Figure 2. As shown in the Figures 2a and 2b, most positive pairs and negative pairs have similarity close to 1 and 0 respectively. Specifically, the average similarities across the training samples are 0.94257 and 0.00018 for positive and negative pairs. As shown in the Figures 2d and 2c, the distributions of patch-based and texture-based negative samples are very different from those of standard negative samples; their similarity distributions have heavy tails in the positive region. Specifically, the distribution of patch-based and texture-based negative samples have average similarity 0.29503 and 0.35248 across the dataset, which shows that they remain difficult after training with standard negative examples. ",
+        "bbox": [
+            174,
+            815,
+            825,
+            885
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            92,
+            825,
+            161
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            181,
+            312,
+            198
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this section, we evaluate the two kinds of non-semantic negative samples with two contrastive learning methods, MoCo and BYOL, on the ImageNet dataset. We also experiment using its subset, the ImageNet-100 dataset [48, 31], which allows us to perform more comprehensive experiments. We report accuracy on out-of-domain (OOD) datasets including the ImageNet-C(orruption) [22], ImageNet-S(ketch) [50], Stylized-ImageNet [14], and ImageNet-R(endition)[21] datasets as an evaluation of the model’s robustness to domain shifts. ImageNet-C and Stylized-ImageNet contain images transformed from the images in the ImageNet validation set with common corruption and transferred style. ImageNet-S and ImageNet-R are collected independently from the ImageNet dataset and share all or a subset of the classes in the ImageNet dataset with a focus on sketch and other rendering modalities. We show that with our proposed non-semantic negatives, contrastive learning generalizes better under domain shifts. For patch-based negatives, it also improves the performance on the in-domain dataset. ",
+        "bbox": [
+            174,
+            213,
+            826,
+            378
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.1 ImageNet-100 ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            396,
+            312,
+            411
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/1b4022cccb9baf8b252bf560a8187b717e08bc7e5cf4d980a7ed9d5a65b7d48f.jpg",
+        "table_caption": [
+            "Table 1: Top-1 accuracy on the ImageNet-100 dataset and its OOD variants. We consider the supervised baseline as well as several self-supervised baselines including MoCo-v2, BYOL, InsDis, CMC, and InfoMIN. For our main comparison using MoCo-v2 and BYOL, we also report the standard deviation of 3 runs. For MoCo models, $k$ represents the size of the memory bank. We use \\* to denote the experiments that use the training setting in a concurrent work IFM [44]. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>ImageNet</td><td>ImageNet-C</td><td>ImageNet-S</td><td>Stylized-ImageNet</td><td>ImageNet-R</td></tr><tr><td>MoCo-v2-k=16384</td><td>77.88±0.28</td><td>43.08±0.27</td><td>28.24±0.58</td><td>16.20±0.55</td><td>32.92±0.12</td></tr><tr><td>+ Texture-based -α = 2</td><td>77.76±0.17</td><td>43.58±0.33</td><td>29.11±0.39</td><td>16.59±0.17</td><td>33.36±0.15</td></tr><tr><td>+Patch-based -α = 2</td><td>79.35±0.12</td><td>45.13±0.35</td><td>31.76±0.88</td><td>17.37±0.19</td><td>34.78±0.15</td></tr><tr><td>+ Patch-based -α=3</td><td>75.58±0.52</td><td>44.45±0.15</td><td>34.03±0.58</td><td>18.60±0.26</td><td>36.89±0.11</td></tr><tr><td>MoCo-v2-k=8192</td><td>77.73±0.38</td><td>43.22±0.39</td><td>28.45±0.36</td><td>16.83±0.12</td><td>33.19±0.44</td></tr><tr><td>+ Patch-based -α = 2</td><td>79.54±0.32</td><td>45.48±0.20</td><td>33.36±0.45</td><td>17.81±0.32</td><td>36.31±0.37</td></tr><tr><td>MoCo-v2*</td><td>80.00±0.14</td><td>45.15±0.42</td><td>30.38±0.30</td><td>16.68±0.39</td><td>30.38±0.30</td></tr><tr><td>+ IFM[44]- ε = 0.05</td><td>80.86</td><td>47.36</td><td>31.35</td><td>18.18</td><td>36.79</td></tr><tr><td>+ IFM[44] - ε= 0.1</td><td>81.22</td><td>47.46</td><td>31.87</td><td>18.42</td><td>37.23</td></tr><tr><td>+ IFM[44] - ε = 0.2</td><td>81.02</td><td>47.19</td><td>31.55</td><td>18.68</td><td>37.14</td></tr><tr><td>+ Patch-based -α = 2</td><td>81.49±0.11</td><td>47.48±0.20</td><td>34.20±0.40</td><td>17.95±0.41</td><td>38.45±0.19</td></tr><tr><td>BYOL</td><td>78.76±0.28</td><td>44.43±0.35</td><td>35.84±0.38</td><td>15.01±0.19</td><td>39.53±0.51</td></tr><tr><td>+ Patch-based -α = 0.05</td><td>78.81±0.33</td><td>44.60±0.21</td><td>36.76±0.51</td><td>15.52±0.22</td><td>41.16±0.39</td></tr><tr><td>InsDis [53]</td><td>68.52</td><td>28.93</td><td>16.67</td><td>9.86</td><td>19.60</td></tr><tr><td>CMC [48]</td><td>79.34</td><td>39.28</td><td>24.04</td><td>13.88</td><td>32.68</td></tr><tr><td>InfoMin [49]</td><td>82.74</td><td>48.87</td><td>38.43</td><td>18.14</td><td>40.68</td></tr><tr><td>Supervised</td><td>86.26</td><td>49.17</td><td>34.95</td><td>21.20</td><td>39.76</td></tr></table>",
+        "bbox": [
+            173,
+            430,
+            838,
+            676
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We follow the hyperparameters used in [31] to train MoCo-v2 on the ImageNet-100 dataset with a memory bank size $k = 1 6 3 8 4$ or a halved memory bank size. We also conduct experiments following the hyperparameters in a concurrent study [44] except that we keep $k = 1 6 3 8 4$ for our method. For patch-based augmentation parameters, we use patch size sampled from a uniform distribution $d \\sim \\mathcal { U } ( 1 6 , 7 2 )$ . The parameter $\\alpha$ is indicated behind each model name. We discuss the impact of $\\alpha$ in detail in the next section. More ablations on the patch-based augmentations can be found in Appendix C.3. For ImageNet-C, we report the average accuracy across 5 levels of corruption severity. ",
+        "bbox": [
+            174,
+            779,
+            825,
+            877
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We repeat the experiments, including both the pretraining and linear evaluation, for 3 runs and report the mean and standard deviation in Table 1. As shown in the table, when following the previous memory bank size, using both patch-based and texture-based negatives improve the OOD generalizations. Specifically, patch-based augmentation increases the accuracy on ImageNet-S by ${ \\bar { 5 } } . 7 9 \\%$ and ImageNet-R by $5 . 9 7 \\%$ when $\\alpha = 3$ . When $\\alpha = 2$ , it also increases the in-domain accuracy by $1 . 4 7 \\%$ and accuracy on ImageNet-C by $2 . 0 5 \\%$ . The similar trend shared by standard ImageNet and ImageNet-C with different $\\alpha$ can be attributed to the resemblance of the images in the two dataset, especially those corrupted images with a lower level of severity. We show the performance of the model with $\\alpha = 3$ is actually better on the highest corruption level as shown in Appendix C.2. The improvement achieved using texture-based negatives is less, probably because the information contained in the texture image is restricted due to the limited access to the two fixed patches. When the memory bank is halved to be 8, 192, the baseline MoCo model has slightly worse performance, decreasing from 77.88 to 77.73. But with patch-based hard negative samples, the MoCo-v2 model instead achieved the best accuracy 79.54 on the ImageNet-100 validation set, IamgeNet-C and IamgeNet-R. We discuss this more in a later section. ",
+        "bbox": [
+            174,
+            883,
+            823,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            90,
+            825,
+            271
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/13e0947ad2247e9e55fca29e31f1da4e0662f238e8457ce44311671fec0a3e71.jpg",
+        "image_caption": [
+            "Figure 3: Histogram of cosine similarity between the representations of query sample and its paired positive sample, standard, texture-based, and patch-based negative samples (NS), using models trained without (blue) and with patch-based negative samples (red: $\\alpha = 2$ , green: $\\alpha = 3$ ). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            286,
+            825,
+            391
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Similar to Figure 2, in Figure 3 we visualize the distribution of the cosine similarity between the query sample and both semantic and non-semantic samples calculated based on the models trained with and without patch-based negative samples. The shift of the distribution towards the origin in Figure 3d meets the expectation that our method reduces the similarity of input images and patch-based negative samples. Specifically, the average similarity decreases from 0.4040 to 0.3252 to 0.1593 when $\\alpha$ increases from 0, namely no patched-based negatives, to 2 to 3. Interestingly, we notice in Figure 3c that the similarity to texture-based negative samples also decreases, and the average similarity decreases from 0.4114 to 0.3541 to 0.1896, although we did not explicitly penalize it. This demonstrates the resemblance of patch-based negative samples to texture-based negative samples. Given the better performance achieved with patch-based negative samples, for the rest of the experiments, we mainly focus on the patch-based methods. But we still conduct our analysis on the texture-based samples. We also find a marginal decrease in the positive similarity $( - 0 . 0 0 6 8 )$ and negative similarity $( - 0 . 0 0 0 8 )$ when $\\alpha = 2$ and a substantial decrease in the positive similarity $( - 0 . 0 7 3 7 )$ and increase in the negative similarity (0.0036) when $\\alpha = 3$ . A similar figure for texture-based negative samples can be found in the Appendix in Figure 12. ",
+        "bbox": [
+            173,
+            459,
+            826,
+            666
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.2 ImageNet-1K ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            683,
+            307,
+            698
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/09df562da9d5f3932868fb638cff3b365dade5d2d4404d70fec416a0390f2892.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>ImageNet</td><td>ImageNet-C</td><td>ImageNet-S</td><td>Stylized-ImageNet</td><td>ImageNet-R</td></tr><tr><td>MoCo-v2 [8]</td><td>67.60</td><td>87.7</td><td>17.47</td><td>5.55</td><td>27.81</td></tr><tr><td>+ MoCHi [31]</td><td>67.56</td><td>88.7</td><td>16.32</td><td>5.94</td><td>25.71</td></tr><tr><td>+ Patch-base NS -α = 2</td><td>67.92</td><td>87.6</td><td>18.58</td><td>6.34</td><td>28.95</td></tr></table>",
+        "bbox": [
+            173,
+            720,
+            825,
+            789
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Table 2: Top-1 accuracy on the ImageNet-1K dataset and its sketch, stylized, rendition variants, and mCE on the ImageNet-C dataset. ",
+        "bbox": [
+            173,
+            799,
+            825,
+            827
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We follow the official hyperparameters [8] to train MoCo-v2 with our patch-based negative samples on the ImageNet-1K dataset. For the parameter $\\alpha$ and patch size $d$ , we follow the same configuration used on the ImageNet-100 dataset. We compare our results against the MoCo-v2 baseline [8] and the hard negative mixing algorithm, MoCHi [31]. Due to limited computational resources, we report the metrics evaluated with the official model without repeated runs. The results are shown in Table 2. ",
+        "bbox": [
+            174,
+            842,
+            825,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "More results can be found in Appendix C.6. Note that for ImageNet-C, we show the mCE metric [22], for which smaller is better. For the other datasets, we show the top-1 accuracy. ",
+        "bbox": [
+            171,
+            90,
+            825,
+            119
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.3 Extension to other non-semantic features ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            159,
+            498,
+            174
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Non-semantic features are sometimes referred to as “shortcuts” in the contrastive learning literature [6, 7]. Models that leverage such features often exhibit unfavorable generalization to downstream tasks. For example, without color jittering, SimCLR [9] tends to utilize color histograms to reduce the training loss. In this section, we show that models trained with nonsemantic negatives are coerced to avoid the shortcuts shared between query images and their non-semantic counterparts. In the example of the color shortcut, we ",
+        "bbox": [
+            173,
+            194,
+            517,
+            332
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/2b99f75c21ed8bb1b7252f4e63273240e332ea6a190a0dc9cd9470f3c0dc6acd.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Top-1 Accuracy</td></tr><tr><td>MoCo-v2 [8]</td><td>70.44</td></tr><tr><td>+ Patch-based NS</td><td>76.42</td></tr></table>",
+        "bbox": [
+            555,
+            210,
+            797,
+            265
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 3: Test accuracy of MoCo-v2 on the ImageNet-100 dataset after removing color jittering and adding patch-based negatives. ",
+        "bbox": [
+            529,
+            276,
+            823,
+            318
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "note that the expected color distribution of our patch-based negatives is identical to that of the query images, and the actual distribution of samples is close. We conduct experiments with MoCo-v2 on the ImageNet-100 dataset while removing the color jittering from the augmentations. The accuracy of models with and without patch-based negatives are reported in Table 3. We found that patch-based negatives contribute significant effectiveness in preventing the models from learning such a color distribution shortcut. ",
+        "bbox": [
+            174,
+            332,
+            825,
+            415
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.4 Memory bank size ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            454,
+            341,
+            469
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Contrastive learning methods based on negative samples suffer from ineffective excavation of hard negatives [13, 31] and resort to large batch sizes [7] or memory bank [18]. In this section, we study whether our proposed negative samples can mitigate this problem on the STL-10 and ImageNet-100 datasets. We keep the hyperparameters intact and vary the memory bank size. We report the accuracy of the MoCo-v2 baseline with and without patch-based negative samples on STL-10 dataset in Table 4. We also compare with [43] which exploits hard negatives through reweighting. We found that with proper hyperparameters the MoCo-v2 baseline already beats the reweighting results with SimCLR. ",
+        "bbox": [
+            173,
+            489,
+            825,
+            585
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/c3768478063a67864900f7ea6a3aa15d480ad530feb6a142c45345142d61fe4c.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>SimCLR[7] + Debiased [10] + Hard [43]</td><td>80.16 84.908 87.428</td></tr><tr><td>MoCo-v2 [8]</td><td>88.00</td></tr><tr><td>+ Patch-based NS</td><td>89.36</td></tr></table>",
+        "bbox": [
+            173,
+            594,
+            361,
+            676
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 4: Top-1 accuracy on the STL-10 dataset. ",
+        "bbox": [
+            173,
+            684,
+            357,
+            710
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/0b38077e0c3c65a670fda2ace37e180bbbbb07800ff1f071f7779145860a5cbc.jpg",
+        "image_caption": [
+            "Figure 4: Top-1 accuracy on the STL-10 dataset with different memory bank sizes. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            379,
+            598,
+            578,
+            704
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/8da6d9ec1b551ab8ff2c66031e55c4aae98dcc8dfc11c58806b92f2b9972ce8c.jpg",
+        "image_caption": [
+            "Figure 5: Top-1 accuracy on the ImageNet-100 dataset with different memory bank sizes. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            612,
+            598,
+            815,
+            704
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "§ denotes results visually extracted from Figure 2 in [43]. ",
+        "bbox": [
+            174,
+            712,
+            357,
+            752
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "As shown in Figures 4 and 5, using patch-based non-semantic negatives consistently improves the MoCo baseline when the number of standard negatives varies. When slightly decreasing the memory bank size on the STL-10 dataset as shown in Figure 4 and ImageNet-100 in Table 1, the performance with patch-based negatives increases. This is probably because, according to Eq. 1 and analysis in Appendix B.1, a smaller memory bank size causes a larger contribution of non-semantic negatives to the loss, and consequently a larger regularization. To further demystify this observation, we conduct experiments with evenly sampled memory bank sizes between 4096 and 16384 and report the average and standard deviation across 3 runs in Figure 5. We confirm a consistent recession of baseline accuracy when decreasing memory back sizes [18, 43]. However, the steady improvement led by the non-semantic negatives effectively mitigates the problem - the decrease caused by a smaller memory bank is less substantial and using patch-based negatives always beats the baseline. ",
+        "bbox": [
+            173,
+            760,
+            825,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4 Discussion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            89,
+            294,
+            106
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.1 Controlling the shape-texture trade-off with $\\alpha$ ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            121,
+            532,
+            136
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "There has been a growing interest in understanding the cause and impact of the trade-off between shape and texture bias of CNNs [14, 23, 35, 27]. CNNs trained on ImageNet are known to be over-reliant on the texture features [14]. Contrastive learning with our non-semantic negatives serve as not only an effective method to reduce such reliance, but a natural tool to study such a trade-off. ",
+        "bbox": [
+            173,
+            147,
+            825,
+            203
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/4992b7aa00d082da0b5210f824275b6074f9ac4af7a1f2f7c2d058ec5fc6a667.jpg",
+        "image_caption": [
+            "Figure 6: Larger $\\alpha$ monotonically increases the model bias to shape features over texture features. Model performance is impacted by such a trade-off differently under different settings. In all scenarios, slightly calibrated shape bias improves model performance. The test settings represented in the red lines gain more from the increased shape bias than the settings represented in the green lines. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            219,
+            821,
+            321
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We train MoCo-v2 models with different $\\alpha$ from 1 to 5 on the ImageNet-100 dataset. As shown in Figure 6a, we find that $\\alpha$ effectively controls the trade-off on the model bias to the shape and texture features. $\\alpha = 0$ is used to denote the baseline method. Specifically, a larger $\\alpha$ in the loss function 1 leads to a larger penalty on the similarity between the representations of query samples and non-semantic samples, consequently a larger shape bias. We follow [14] to calculate shape bias on the stimuli images with conflicted shape and texture clues generated by style transfer. We show the corresponding accuracy on the shape and texture labels in Figure 6b. ",
+        "bbox": [
+            173,
+            405,
+            825,
+            502
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "As shown in Figure 6b, when $\\alpha$ increases the texture accuracy on the stimuli dataset monotonically decreases while the shape accuracy monotonically increases. To further study how the trade-off between shape and texture bias impacts the model performance, we first compare the accuracy on the ImageNet validation dataset and ImageNet-Sketch dataset [50] when $\\alpha$ varies in Figure 6c. We find that on both datasets, slightly increased shape bias over baseline $\\alpha = 2$ ) improves performances. Interestingly, the accuracy peak on the ImageNet-Sketch appears at $\\alpha = 3$ while the peak appears at $\\alpha = 2$ on the ImageNet validation dataset. In addition, for even larger $\\alpha$ the accuracy on the ImageNet-Sketch dataset still outperforms the baseline while the standard accuracy gets hurt. This shows that different downstream tasks may benefit differently from differently shape-biased models. ",
+        "bbox": [
+            174,
+            508,
+            825,
+            633
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We plot the histograms of similarities calculated by the models trained with different $\\alpha$ in Appendix Figure 13. We find that large $\\alpha$ makes the original pretext task challenging - the model cannot effectively pull together the representations of positive pairs. Specifically, when $\\alpha$ increases from 1 to 5, the average similarity of the positive pairs decrease from 0.9267 to 0.7541. This demonstrates that it is hard for the model to learn representations that are completely independent of the texture features contained in the non-semantic images. ",
+        "bbox": [
+            174,
+            638,
+            825,
+            723
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.2 Rethinking the shape-texture trade-off through class-based analysis ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            739,
+            681,
+            755
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The initial discussion on the shape-texture trade-off shows that humans rely more on the shape features while CNNs rely more on texture features and increasing shape bias can improve accuracy and robustness [14]. However, similar to [40, 23], we notice that increasing shape bias does not always improve the generalization and robustness of the models. To better understand this phenomenon, we provide two observations based on the analysis of the ImageNet-Texture dataset and our method to explain why a texture-biased model is helpful with classification on the ImageNet dataset. ",
+        "bbox": [
+            174,
+            766,
+            825,
+            849
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "First, we find that an increasing shape bias often leads to more errors among the fine-grained classes. The initial discussion of the shape-bias [14] only pays attention to the selected 16 coarse classes. We thus compare the finer and coarse class accuracy on the dog images of ImageNet dataset as in Figure 6d. For coarse class accuracy, the predictions are counted to be correct whenever the image is classified as a dog class, no matter which dog class is predicted, while for the finer class accuracy, only those predictions of target dog classes are counted to be correct. We notice that the finer class accuracy drops more significantly when shape bias increases as opposed to the coarse class accuracy. For example, when $\\alpha = 3$ , the finer class accuracy drops from 72.9 to 67.6 while the coarse class accuracy slightly decreases from 97.8 to 97.7. Therefore, for datasets with numerous fine-grained classes like ImageNet, a texture-biased model is more helpful for a higher accuracy, which confirms the previous conjecture [54] . Second, in Appendix Figure 9, we show a scatter plot of texture accuracy vs. standard accuracy of different model architectures and a histogram of accuracy on individual ImageNet-Texture classes. We identify several classes where using only texture features is sufficient to achieve a high classification accuracy. These classes are all missing in the previous study [14]. As shown in Figure 7 and Appendix Figure 10, texture serves as a more important clue than the shape for these classes. ",
+        "bbox": [
+            174,
+            856,
+            825,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/c6ba57412c923a730dcc67460ee2fbfd0c28a8d9834c454fafc9b5d28ea800bd.jpg",
+        "image_caption": [
+            "Figure 7: A ResNet-50 model trained on the ImageNet dataset achieves decent accuracy when only texture features are available on some classes. A normal image and its texture version are displayed for some of these classes. The caption indicates the class ID, name, and accuracy on texture images. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            92,
+            821,
+            179
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            262,
+            825,
+            429
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            455,
+            321,
+            472
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Contrastive learning based self-supervised learning Recent contrastive learning based selfsupervised learning methods including MoCo [18], SimCLR [7], InfoMin[49], SimSiam[9], BYOL [16], SwAV [6], Barlow Twins [56] have proven helpful in learning visual representations. These methods rely on different pretext tasks to increase the agreement among the different views of the same image. The augmentations used to generate these views are essential to the success of these contrastive learning methods [7, 6] by preventing shortcuts such as the use of simple color histogram [7]. There is an ongoing trend of developing novel augmentations [6, 49] or adaptively applying augmentations [54] and consistent improvement has been achieved with these studies. However, it is intractable to eliminate every shortcut and sometimes tricky to craft the correct positive pairs. Different from these methods, we show that augmentations that perturb the semantic features and craft negative samples can be more effective to impose additional regularization. For example, to prevent models from relying on local features, it is much easier to destroy global features and create negatives than to remove all the local features and create positives. Furthermore, by maximizing the difference between natural images and their non-semantic versions in the representation space, the models are coerced to avoid any potential shortcuts shared by them. ",
+        "bbox": [
+            174,
+            491,
+            825,
+            696
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Methods like MoCo [18] and SimCLR [7] distinguish positive pairs from negative pairs that are picked from the rest of the dataset. However, most of the negatives prove to be unnecessary and insufficient [13, 31]. To excavate effective negative samples, these methods heavily depend on the large batch sizes [7] or memory bank [18]. Utilizing hard negative samples has long been recognized as an effective approach to boost model performance [17, 29, 55, 46]. In the contrastive learning studies, [10, 43] modify the contrastive learning loss to make it assign greater weights to the hard negative samples. [31] proposes to synthesize hard negative samples by taking linear combinations of the hardest negative samples. Our work is orthogonal to these ideas in the way that we propose to generate negative samples from given images themselves to reduce the reliance on the undesired features. In addition, two recent works [25, 32] study the application of adversarial examples as hard positive and negative samples in contrastive learning. [45] augments the images by manipulating their foregrounds and backgrounds to generate negative and positive samples. Compared with these studies, we mainly focus on the OOD evaluation of the models. In addition, our patch-based augmentation is also related to the self-Supervised learning methods that adopt the pretext task based on jigsaw [41, 39, 20], which we discuss in the Appendix B.2. ",
+        "bbox": [
+            174,
+            704,
+            825,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Robustness and out-of-domain generalization of CNNs High test accuracy provides no guarantee that a network learns high-level semantic features instead of low-level superfluous features that exist in both training and test dataset [30]. An increasing number of studies have corroborated such concerns and found that CNNs can rely on local patches [4, 3], texture [14], high-frequency components [51] and even artificially added features [26] to achieve high test accuracy. These superficial correlations become brittle under large domain shifts [22, 21]. This still remains an unsolved problem [47] and is rarely discussed in the contrastive learning setting. ",
+        "bbox": [
+            174,
+            92,
+            825,
+            188
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Among all these undesired features, the shape-texture bias has been widely discussed in recent studies [14, 36]. Previous work has shown that CNNs trained on the ImageNet dataset are biased to texture features and such over-reliance can hurt the generalization performance of CNNs [14, 24]. Several studies have aimed at mitigating this problem [38, 35] or providing a better understanding [23, 27]. In this paper, we introduce a dataset called ImageNet-Texture, which can help future studies on these problems. Our method also effectively controls the trade-off between shape and texture bias. We provide new insights about this problem based on the analysis of our method and dataset. ",
+        "bbox": [
+            174,
+            194,
+            825,
+            291
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 Closing Remarks ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            310,
+            349,
+            328
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Conclusion CNNs are prone to learn discriminative features that are vulnerable under domain shifts. In this paper, we first demonstrate the regularization power of contrastive learning to discard any undesired features by generating appropriate negative samples. We explore two approaches, the patch-based and texture-based augmentations, to craft negative samples with only local features preserved. We show that the representations learned by contrastive learning with such negative samples depend less on the local features, and consequently generalize better under OOD settings. We hope this paper can encourage people to rethink the role that negative samples play in contrastive learning, which hopefully leads to more efficient methods to generate negative samples. ",
+        "bbox": [
+            174,
+            343,
+            825,
+            454
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Limitations The problem of dependence on superficial features exists in various domains beyond vision, such as language [37, 28]. Therefore, it is intriguing to consider generalizing such an idea to other modalities. In addition, as the mechanism to ensure that contrastive learning models trained on large datasets to discard the bias of the datasets is yet to be invented, severe social issues in fairness or privacy may be raised as a result [5, 33]. In this paper, we show how to calibrate the bias towards texture features using proposed negative samples. It is also worth considering whether contrastive learning can be used to address any of these negative effects triggered by bias in datasets. ",
+        "bbox": [
+            174,
+            468,
+            825,
+            565
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgments and Disclosure of Funding ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            585,
+            553,
+            603
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The authors thank the National Science Foundation, grant no. IIS-1910132 and the Guaranteeing AI Robustness Against Deception (GARD) program from DARPA for their support of this project. The authors thank Yannis Kalantidis for his help with reproducing MoCo-v2 on the ImageNet-100 dataset and Joshua Robinson for providing the checkpoints of IFM models for comparison. ",
+        "bbox": [
+            174,
+            617,
+            825,
+            672
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            691,
+            266,
+            707
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "[1] M. Ashikhmin. Synthesizing natural textures. In Proceedings of the 2001 symposium on Interactive 3D graphics, pages 217–226, 2001.   \n[2] L. Beyer, O. J. Hénaff, A. Kolesnikov, X. Zhai, and A. van den Oord. Are we done with imagenet?, 2020.   \n[3] W. Brendel and M. Bethge. Approximating CNNs with bag-of-local-features models works surprisingly well on imagenet. In International Conference on Learning Representations, 2019.   \n[4] T. B. Brown, D. Mané, A. Roy, M. Abadi, and J. Gilmer. Adversarial patch. arXiv preprint arXiv:1712.09665, 2017.   \n[5] J. Buolamwini and T. Gebru. Gender shades: Intersectional accuracy disparities in commercial gender classification. In Conference on fairness, accountability and transparency, pages 77–91. PMLR, 2018.   \n[6] M. Caron, I. Misra, J. Mairal, P. Goyal, P. Bojanowski, and A. Joulin. Unsupervised learning of visual features by contrasting cluster assignments. arXiv preprint arXiv:2006.09882, 2020.   \n[7] T. Chen, S. Kornblith, M. Norouzi, and G. Hinton. A simple framework for contrastive learning of visual representations. In International conference on machine learning, pages 1597–1607. PMLR, 2020. [8] X. Chen, H. Fan, R. Girshick, and K. He. Improved baselines with momentum contrastive learning. arXiv preprint arXiv:2003.04297, 2020.   \n[9] X. Chen and K. He. Exploring simple siamese representation learning. arXiv preprint arXiv:2011.10566, 2020.   \n[10] C.-Y. Chuang, J. Robinson, Y.-C. Lin, A. Torralba, and S. Jegelka. Debiased contrastive learning. In H. Larochelle, M. Ranzato, R. Hadsell, M. F. Balcan, and H. Lin, editors, Advances in Neural Information Processing Systems, volume 33, pages 8765–8775. Curran Associates, Inc., 2020.   \n[11] J. S. De Bonet. Multiresolution sampling procedure for analysis and synthesis of texture images. In Proceedings of the 24th annual conference on Computer graphics and interactive techniques, pages 361–368, 1997.   \n[12] A. A. Efros and T. K. Leung. Texture synthesis by non-parametric sampling. In Proceedings of the seventh IEEE international conference on computer vision, volume 2, pages 1033–1038. IEEE, 1999.   \n[13] J. Frankle, D. J. Schwab, A. S. Morcos, et al. Are all negatives created equal in contrastive instance discrimination? arXiv preprint arXiv:2010.06682, 2020.   \n[14] R. Geirhos, P. Rubisch, C. Michaelis, M. Bethge, F. A. Wichmann, and W. Brendel. Imagenet-trained CNNs are biased towards texture; increasing shape bias improves accuracy and robustness. In International Conference on Learning Representations, 2019.   \n[15] R. Geirhos, C. R. M. Temme, J. Rauber, H. H. Schütt, M. Bethge, and F. A. Wichmann. Generalisation in humans and deep neural networks. In Proceedings of the 32nd International Conference on Neural Information Processing Systems, pages 7549–7561, 2018.   \n[16] J.-B. Grill, F. Strub, F. Altché, C. Tallec, P. Richemond, E. Buchatskaya, C. Doersch, B. Avila Pires, Z. Guo, M. Gheshlaghi Azar, B. Piot, k. kavukcuoglu, R. Munos, and M. Valko. Bootstrap your own latent - a new approach to self-supervised learning. In H. Larochelle, M. Ranzato, R. Hadsell, M. F. Balcan, and H. Lin, editors, Advances in Neural Information Processing Systems, volume 33, pages 21271–21284. Curran Associates, Inc., 2020.   \n[17] B. Harwood, V. Kumar B G, G. Carneiro, I. Reid, and T. Drummond. Smart mining for deep metric learning. In Proceedings of the IEEE International Conference on Computer Vision (ICCV), Oct 2017.   \n[18] K. He, H. Fan, Y. Wu, S. Xie, and R. Girshick. Momentum contrast for unsupervised visual representation learning. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 9729–9738, 2020.   \n[19] D. J. Heeger and J. R. Bergen. Pyramid-based texture analysis/synthesis. In Proceedings of the 22nd annual conference on Computer graphics and interactive techniques, pages 229–238, 1995.   \n[20] O. Henaff. Data-efficient image recognition with contrastive predictive coding. In International Conference on Machine Learning, pages 4182–4192. PMLR, 2020.   \n[21] D. Hendrycks, S. Basart, N. Mu, S. Kadavath, F. Wang, E. Dorundo, R. Desai, T. Zhu, S. Parajuli, M. Guo, D. Song, J. Steinhardt, and J. Gilmer. The many faces of robustness: A critical analysis of out-of-distribution generalization. arXiv preprint arXiv:2006.16241, 2020.   \n[22] D. Hendrycks and T. Dietterich. Benchmarking neural network robustness to common corruptions and perturbations. Proceedings of the International Conference on Learning Representations, 2019.   \n[23] K. Hermann, T. Chen, and S. Kornblith. The origins and prevalence of texture bias in convolutional neural networks. Advances in Neural Information Processing Systems, 33, 2020.   \n[24] K. L. Hermann and A. K. Lampinen. What shapes feature representations? exploring datasets, architectures, and training, 2020.   \n[25] C.-H. Ho and N. Nvasconcelos. Contrastive learning with adversarial examples. In H. Larochelle, M. Ranzato, R. Hadsell, M. F. Balcan, and H. Lin, editors, Advances in Neural Information Processing Systems, volume 33, pages 17081–17093. Curran Associates, Inc., 2020.   \n[26] H. Huang, X. Ma, S. M. Erfani, J. Bailey, and Y. Wang. Unlearnable examples: Making personal data unexploitable. In International Conference on Learning Representations, 2021.   \n[27] M. A. Islam, M. Kowal, P. Esser, S. Jia, B. Ommer, K. G. Derpanis, and N. Bruce. Shape or texture: Understanding discriminative features in {cnn}s. In International Conference on Learning Representations, 2021.   \n[28] R. Jia and P. Liang. Adversarial examples for evaluating reading comprehension systems. In Proceedings of the 2017 Conference on Empirical Methods in Natural Language Processing, pages 2021–2031, 2017.   \n[29] S. Jin, A. RoyChowdhury, H. Jiang, A. Singh, A. Prasad, D. Chakraborty, and E. Learned-Miller. Unsupervised hard example mining from videos for improved object detection. In Proceedings of the European Conference on Computer Vision (ECCV), pages 307–324, 2018.   \n[30] J. Jo and Y. Bengio. Measuring the tendency of cnns to learn surface statistical regularities. arXiv preprint arXiv:1711.11561, 2017.   \n[31] Y. Kalantidis, M. B. Sariyildiz, N. Pion, P. Weinzaepfel, and D. Larlus. Hard negative mixing for contrastive learning. In Neural Information Processing Systems (NeurIPS), 2020.   \n[32] M. Kim, J. Tack, and S. J. Hwang. Adversarial self-supervised contrastive learning. In H. Larochelle, M. Ranzato, R. Hadsell, M. F. Balcan, and H. Lin, editors, Advances in Neural Information Processing Systems, volume 33, pages 2983–2994. Curran Associates, Inc., 2020.   \n[33] S. Kiritchenko and S. M. Mohammad. Examining gender and race bias in two hundred sentiment analysis systems. arXiv preprint arXiv:1805.04508, 2018.   \n[34] C.-L. Li, K. Sohn, J. Yoon, and T. Pfister. Cutpaste: Self-supervised learning for anomaly detection and localization. arXiv preprint arXiv:2104.04015, 2021.   \n[35] Y. Li, Q. Yu, M. Tan, J. Mei, P. Tang, W. Shen, A. Yuille, and cihang xie. Shape-texture debiased neural network training. In International Conference on Learning Representations, 2021.   \n[36] G. Malhotra and J. Bowers. The contrasting roles of shape in human vision and convolutional neural networks. In CogSci, 2019.   \n[37] T. McCoy, E. Pavlick, and T. Linzen. Right for the wrong reasons: Diagnosing syntactic heuristics in natural language inference. In Proceedings of the 57th Annual Meeting of the Association for Computational Linguistics, pages 3428–3448, 2019.   \n[38] S. Mishra, A. Shah, A. Bansal, J. Choi, A. Shrivastava, A. Sharma, and D. Jacobs. Learning visual representations for transfer learning by suppressing texture. arXiv preprint arXiv:2011.01901, 2020.   \n[39] I. Misra and L. v. d. Maaten. Self-supervised learning of pretext-invariant representations. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 6707–6717, 2020.   \n[40] C. K. Mummadi, R. Subramaniam, R. Hutmacher, J. Vitay, V. Fischer, and J. H. Metzen. Does enhanced shape bias improve neural network robustness to common corruptions? In ICLR, 2021.   \n[41] M. Noroozi and P. Favaro. Unsupervised learning of visual representations by solving jigsaw puzzles. In European conference on computer vision, pages 69–84. Springer, 2016.   \n[42] J. Portilla and E. P. Simoncelli. A parametric texture model based on joint statistics of complex wavelet coefficients. International journal of computer vision, 40(1):49–70, 2000.   \n[43] J. Robinson, C.-Y. Chuang, S. Sra, and S. Jegelka. Contrastive learning with hard negative samples. International Conference on Learning Representations, 2021.   \n[44] J. Robinson, L. Sun, K. Yu, K. Batmanghelich, S. Jegelka, and S. Sra. Can contrastive learning avoid shortcut solutions? NeurIPS, 2021.   \n[45] C. K. Ryali, D. J. Schwab, and A. S. Morcos. Leveraging background augmentations to encourage semantic focus in self-supervised contrastive learning. arXiv preprint arXiv:2103.12719, 2021.   \n[46] E. Simo-Serra, E. Trulls, L. Ferraz, I. Kokkinos, P. Fua, and F. Moreno-Noguer. Discriminative learning of deep convolutional feature point descriptors. In Proceedings of the IEEE International Conference on Computer Vision, pages 118–126, 2015.   \n[47] R. Taori, A. Dave, V. Shankar, N. Carlini, B. Recht, and L. Schmidt. Measuring robustness to natural distribution shifts in image classification. Advances in Neural Information Processing Systems, 33, 2020.   \n[48] Y. Tian, D. Krishnan, and P. Isola. Contrastive multiview coding. In ECCV, 2020.   \n[49] Y. Tian, C. Sun, B. Poole, D. Krishnan, C. Schmid, and P. Isola. What makes for good views for contrastive learning. arXiv preprint arXiv:2005.10243, 2020.   \n[50] H. Wang, S. Ge, Z. Lipton, and E. P. Xing. Learning robust global representations by penalizing local predictive power. In Advances in Neural Information Processing Systems, pages 10506–10518, 2019.   \n[51] H. Wang, X. Wu, Z. Huang, and E. P. Xing. High-frequency component helps explain the generalization of convolutional neural networks. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 8684–8694, 2020.   \n[52] L.-Y. Wei and M. Levoy. Fast texture synthesis using tree-structured vector quantization. In Proceedings of the 27th annual conference on Computer graphics and interactive techniques, pages 479–488, 2000.   \n[53] Z. Wu, Y. Xiong, S. X. Yu, and D. Lin. Unsupervised feature learning via non-parametric instance discrimination. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 3733–3742, 2018.   \n[54] T. Xiao, X. Wang, A. A. Efros, and T. Darrell. What should not be contrastive in contrastive learning. In International Conference on Learning Representations, 2020.   \n[55] H. Xuan, A. Stylianou, X. Liu, and R. Pless. Hard negative examples are hard, but useful. In European Conference on Computer Vision, pages 126–142. Springer, 2020.   \n[56] J. Zbontar, L. Jing, I. Misra, Y. LeCun, and S. Deny. Barlow twins: Self-supervised learning via redundancy reduction. arXiv preprint arXiv:2103.03230, 2021. ",
+        "bbox": [
+            176,
+            714,
+            826,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            87,
+            828,
+            916
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            75,
+            828,
+            919
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            92,
+            825,
+            148
+        ],
+        "page_idx": 12
+    }
+]