Add files using upload-large-folder tool

parse/train/-OrwaD3bG91/-OrwaD3bG91.md

@@ -0,0 +1,241 @@
+# What Matters for Adversarial Imitation Learning?
+
+Manu Orsini∗, Anton Raichuk∗, Léonard Hussenot∗†, Damien Vincent, Robert Dadashi, Sertan Girgin, Matthieu Geist, Olivier Bachem, Olivier Pietquin, Marcin Andrychowicz‡
+
+Google Research, Brain Team
+
+# Abstract
+
+Adversarial imitation learning has become a popular framework for imitation in continuous control. Over the years, several variations of its components were proposed to enhance the performance of the learned policies as well as the sample complexity of the algorithm. In practice, these choices are rarely tested all together in rigorous empirical studies. It is therefore difficult to discuss and understand what choices, among the high-level algorithmic options as well as low-level implementation details, matter. To tackle this issue, we implement more than 50 of these choices in a generic adversarial imitation learning framework and investigate their impacts in a large-scale study $( > 5 0 0 \mathrm { k }$ trained agents) with both synthetic and human-generated demonstrations. We analyze the key results and highlight the most surprising findings.
+
+# 1 Introduction
+
+Reinforcement Learning (RL) has shown its ability to perform complex tasks in contexts where clear reward functions can be set-up (e.g. $+ 1$ for winning a chess game) [15, 37, 40, 43] but for many real-world applications, designing a correct reward function is either tedious or impossible [20], while demonstrating a correct behavior is often easy and cheap. Therefore, imitation learning (IL, [4, 7]) might be the key to unlock the resolution of more complex tasks, such as autonomous driving, for which reward functions are much harder to design.
+
+The simplest approach to IL is Behavioral Cloning (BC, [2]) which uses supervised learning to predict the expert’s action for any given state. However, BC is often unreliable as prediction errors compound in the course of an episode. Adversarial Imitation Learning (AIL, [14]) aims to remedy this using inspiration from Generative Adversarial Networks (GANs, [9]) and Inverse RL [3, 5, 6]: the policy is trained to generate trajectories that are indistinguishable from the expert’s ones. As in GANs, this is formalized as a two-player game where a discriminator is co-trained to distinguish between the policy and expert trajectories (or states). See App. C for a brief introduction to AIL.
+
+A myriad of improvements over the original AIL algorithm were proposed over the years [17, 31, 41, 44, 46], from changing the discriminator’s loss function [17] to switching from on-policy to off-policy agents [31]. However, their relative performance is rarely studied in a controlled setting, and never these changes have never been compared simultaneously. The performance of these high-level choices may also depend on low-level implementation details which might be silenced in the original publications [19, 29, 36, 42], as well as the hyperparameters (HPs) used. Thus, assessing whether the proposed changes are the reason for the presented improvements becomes extremely difficult. This lack of proper comparisons slows down the overall research in imitation learning and the industrial applicability of these methods.
+
+We investigate such high- and low-level choices in depth and study their impact on the algorithm performance. Hence, as our key contributions, we (1) implement a highly-configurable generic AIL algorithm, with various axes of variation $( > 5 0 \mathrm { H P s } )$ ), including 4 different RL algorithms and 7 regularization schemes for the discriminator, (2) conduct a large-scale $\mathrm { 5 5 0 0 k }$ trained agents) experimental study on 10 continuous-control tasks and (3) analyze the experimental results to provide practical insights and recommendations for designing novel and using existing AIL algorithms. We release this generic AIL agent, implemented in JAX [25] as part of the Acme [49] framework: https://github.com/deepmind/acme/blob/master/acme/agents/jax/ail .
+
+Most surprising finding #1: regularizers. While many of our findings confirm common practices in AIL research, some of them are surprising or even contradict prior work. In particular, we find that standard regularizers from Supervised Learning — dropout [10] and weight decay [1] often perform similarly to the regularizers designed specifically for adversarial learning like gradient penalty [18]. Moreover, for easier environments (which were often the only ones used in prior work), we find that it is possible to achieve excellent results without using any explicit discriminator regularization.
+
+Most surprising finding #2: human demonstrations. Not only does the performance of AIL heavily depend on whether the demonstrations were collected from a human operator or generated by an RL algorithm, but the relative performance of algorithmic choices also depends on the demonstration source. Our results suggest that artificial demonstrations are not a good proxy for human data and that the very common practice of evaluating IL algorithms only with synthetic demonstrations may lead to algorithms which perform poorly in the more realistic scenarios with human demonstrations.
+
+# 2 Experimental design
+
+Environments. We focus on continuous-control tasks as robotics appears as one of the main potential applications of IL and a vast majority of the IL literature thus focuses on it. In particular, we run experiments with five widely used environments from OpenAI Gym [13]: HalfCheetah-v2, Hopper-v2, Walker2d-v2, Ant-v2, and Humanoid-v2 and three manipulation environments from Adroit [21]: pen-v0, door-v0, and hammer-v0. The Adroit tasks consist in aligning a pen with a target orientation, opening a door and hammering a nail with a 5-fingered hand.
+
+Demonstrations. For the Gym tasks, we generate demonstrations with a SAC [28] agent trained on the environment reward. For the Adroit environments, we use the “expert” and “human” datasets from D4RL [45], which are, respectively, generated by an RL agent and collected from a human operator. As far as we know, our work is the first to solve these tasks with human datasets in the imitation setup (most of the prior work concentrated on Offline RL). For all environments, we use 11 demonstration trajectories. Following prior work [14, 31, 46], we subsample expert demonstrations by only using every $2 0 ^ { \mathrm { t h } }$ state-action pair to make the tasks harder.
+
+Adversarial Imitation Learning algorithms. We researched prior work on AIL algorithms and made a list of commonly used design decisions like policy objectives or discriminator regularization techniques. We also included a number of natural options which we have not encountered in literature (e.g. dropout [10] in the discriminator or clipping rewards bigger than a threshold). All choices are listed and explained in App. D. Then, we implemented a single highly-configurable AIL agent which exposes all these choices as configuration options in the Acme framework [49] using JAX [25] for automatic differentiation and Flax [47] for neural networks computation. The configuration space is so wide that it covers the whole family of AIL algorithms, in particular, it mostly covers the setups from AIRL [17] and DAC [31]. We plan to open source the agent implementation.
+
+Experimental design. We created a large HP sweep (57 HPs swept, ${ > } 1 2 0 \mathrm { k }$ agents trained) in which each HP is sampled uniformly at random from a discrete set and independently from the other HPs. We manually ensured that the sampling ranges of all HPs are appropriate and cover the optimal values. Then, we analyzed the results of this initial experiment (called wide, detailed description and results in App. G), removed clearly suboptimal options and ran another experiment with the pruned sampling ranges (called main, $4 3 \mathrm { H P s }$ swept, ${ > } 2 5 0 \mathrm { k }$ agents trained, detailed description and results in App. H). The latter experiment serves as the basis for most of the conclusions drawn in this paper but we also run a few additional experiments to investigate some additional questions (App. I and App. J).
+
+This pruning of the HP space guarantees that we draw conclusions based on training configurations which are highly competitive (training curves can be found in Fig. 24) while using a large HP sweep (including, for example, multiple different RL algorithms) ensures that our conclusions are robust and valid not only for a single RL algorithm and specific values of HPs, but are more generally applicable. Moreover, many choices may have strong interactions with other related choices, for example we find a surprisingly strong interaction between the discriminator regularization scheme and the discriminator learning rate (Sec. 4). This means that such choices need to be tuned together (as it is the case in our study) and experiments where only a single choice is varied but the interacting choices are kept fixed may lead to misleading conclusions.
+
+Performance measure. For each HP configuration and each of the 10 environment-dataset pairs we train a policy and evaluate it 10 times through the training by running it for 50 episodes and computing the average undiscounted return using the environment reward. We then average these scores to obtain a single performance score which approximates the area under the learning curve. This ensures we assign higher scores to HP configurations that learn quickly.
+
+Analysis. We consider two different analyses for each choice4:
+
+Conditional 95th percentile: For each potential value of that choice (e.g., RL Algorithm $= { \tt P P 0 }$ ), we look at the performance distribution of sampled configurations with that value. We report the 95th percentile of the performance as well as error bars based on bootstrapping.5 This corresponds to an estimate of the performance one can expect if all other choices were tuned with random search and a limited budget of roughly $1 3 \mathrm { H P }$ configurations6. All scores are normalized so that 0 corresponds to a random policy and 1 to the expert performance (expert scores can be found in App. F).
+
+Distribution of choice within top $5 \%$ configurations. We further consider for each choice the distribution of values among the top $5 \%$ HP configurations. In particular, we measure the ratio of the frequency of the given value in the top $5 \%$ of HP configurations with the best performance to the frequency of this value among all HP configurations. If certain values are over-represented in the top models (ratio higher than 1), this indicates that the specific choice is important for good performance.
+
+We release the raw results of our experiments7 along with a Notebook allowing to load and study it8.
+
+# 3 What matters for the agent training?
+
+Summary of key findings. The AIRL reward function perform best for synthetic demonstrations while $- \ln ( 1 - D )$ is better for human demonstrations. Using explicit absorbing state is crucial in environments with variable length episodes. Observation normalization strongly affects the performance. Using an off-policy RL algorithm is necessary for good sample complexity while replaying expert data and pretraining with BC improves the performance only slightly.
+
+Implicit reward function. In this section, we investigate choices related to agent training with AIL, the most salient of which is probably the choice of the implicit reward function. Let $D ( s , a )$ be the probability of classifying the given state-action pair as expert by the discriminator. In particular, we run experiments with the following reward functions: $\bar { r ( s , a ) = - \log ( 1 - D ( s , a ) ) }$ (used in the original GAIL paper [14]), $r ( s , a ) \bar { = } \log D ( s , a ) - \log ( 1 - D ( s , a ) )$ (called the AIRL reward [17]), $r ( s , a ) = \log D ( s , a )$ (a natural choice we have not encountered in literature), and the FAIRL [46] reward function $r ( s , a ) = - h ( s , a ) \cdot e ^ { h ( s , a ) }$ , where $h ( s , a )$ is the discriminator logit. It can be shown that, under the assumption that all episodes have the same length, maximizing these reward functions corresponds to the minimization of different divergences between the marginal state-action distribution of the expert and the policy. See [46] for an in-depth discussion on this topic. We also consider clipping the rewards with absolute values bigger than a threshold which is a HP.
+
+![](images/0294a4d81ac5ba0b88d700af4e1fbf8304e0099061bf33f6c1ecf26a590fbe7d.jpg)  
+Figure 1: Comparison of different reward functions. The bars show the 95th percentile across HPs sampling of the average policy performance during training. Plot (a) shows the results averaged across all 10 tasks. Plots (b) and (c) show the performance on the subset of environments with variable length episodes when the absorbing state is disabled (b) or enabled (c). See Fig. 12 and Fig. 72 for the individual results in all environments.
+
+The FAIRL reward performed much worse than all others in the initial wide experiment (Fig. 1a) and therefore was not included in our main experiment. This is mostly caused by its inferior performance with off-policy RL algorithms (Fig. 22). Moreover, reward clipping significantly helps the FAIRL reward (Fig. 23) while it does not help the other reward functions apart from some small gains for $- \ln ( 1 - D )$ (Fig. 82). Therefore, we suspect that the poor performance of the FAIRL reward function may be caused by its exponential term which may have very high magnitudes. Moreover, the FAIRL paper [46] mentions that the FAIRL reward is more sensitive to HPs than other reward functions which could also explain its poor performance in our experiments.
+
+Fig. 25 shows that the $\ln ( D )$ reward functions performs a bit worse than the other two reward functions in the main experiment. Five out of the ten tasks used in our experiments have variable length episodes with longer episodes correlated with better behaviour (Hopper, Walker2d, Ant, Humanoid, pen) — on these tasks we can notice that $r ( s , a ) = - \ln ( 1 - \bar { D ( s , a ) } )$ often performs best and $r ( \bar { s } , a ) = \ln D ( s , a )$ worst. This can be explained by the fact that $- \ln ( 1 - D ( s , a ) ) > 0$ and $\ln D ( s , a ) < 0$ which means that the former reward encourages longer episodes and the latter one shorter ones [31]. Absorbing state (described in App. D.2) is a technique introduced in the DAC paper [31] to mitigate the mentioned bias and encourage the policy to generate episodes of similar length to demonstrations. In Fig. 1b-c we show how the performance of different reward functions compares in the environments with variable length episodes depending on whether the absorbing state is used. We can notice that without the absorbing state $\bar { r } ( s , a ) \bar { = } - \ln ( 1 - D ( s , a ) ) > \bar { 0 }$ performs much better in the environments with variable episode length which suggests that the learning is driven to a large extent by the reward bias and not actual imitation of the expert behaviour [31]. This effect disappears when the absorbing state is enabled (Fig. 1c).
+
+Fig. 72 shows the performance of different reward functions in all environments conditioned on whether the absorbing state is used. If the absorbing state is used, the AIRL reward function performs best in all the environments with RL-generated demonstrations, and $\ln ( D )$ performs only marginally worse. The $- \ln ( 1 - D )$ reward function underperforms on the Humanoid and pen tasks while performing best with human datasets. We provide some hypothesis for this behaviour in Sec. 5, where we discuss human demonstrations in more details.
+
+Observation normalization. We consider observation normalization which is applied to the inputs of all neural networks involved in AIL (policy, critic and discriminator). The normalization aims to transform the observations so that that each observation coordinate has mean 0 and standard deviation 1. In particular, we consider computing the normalization statistics either using only the expert demonstrations so that the normalization is fixed throughout the training, or using data from the policy being trained (called online). See App. D.6 for more details. Fig. 26 shows that input normalization significantly influences the performance with the effects on performance being often much larger than those of algorithmic choices like the reward function or RL algorithm used. Surprisingly, normalizing observations can either significantly improve or diminish performance and whether the fixed or online normalization performs better is also environment dependent.
+
+Replaying expert data. When demonstrations as well as external rewards are available, it is common for RL algorithms to sample batches for off-policy updates from the demonstrations in addition to the replay buffer [30, 39]. We varied the ratio of the policy to expert data being replayed but found only very minor gains (Fig. 83). Moreover, in the cases when we see some benefits, it is usually best to replay 16–64 times more policy than expert data. On some tasks (Humanoid) replaying even a single expert transitions every 256 agent ones significantly hurts performance. We suspect that, in contrast to RL with demonstrations, we see little benefit from replaying expert data in the setup with learned rewards because (1) replaying expert data mostly helps when the reward signal is sparse (not the case for discriminator-based rewards), and (2) discriminator may overfit to the expert demonstrations which could result in incorrectly high rewards being assigned to expert transitions.
+
+Pretraining with BC. We also experiment with pretraining a policy with Behavioral Cloning (BC, [2]) at the beginning of training. Despite starting from a much better policy than a random one, we usually observe that the policy quality deteriorates quickly at the beginning of training (see the pen task in Fig. 3) due to being updated using randomly initialized critic and discriminator networks, and the overall gain from pretraining is very small in most environments (Fig. 27).
+
+RL algorithms. We run experiments with four different RL algorithms, three of which are off-policy algorithms (SAC [28], TD3 [26] and D4PG [24]), as well as PPO [22] which is nearly on-policy. Fig. 7 shows that the sample complexity of PPO is significantly worse than that of the off-policy algorithms while all off-policy algorithms perform overall similarly.
+
+RL algorithms HPs. Fig. 8 shows that the discount factor is one of the most important HPs with the values of $0 . 9 7 - 0 . 9 9$ performing well on all tasks. Fig. 29 shows that in most environments it is better not to erase any data from the RL replay buffer and always sample from all the experience encountered so far. It is common in RL to use a noise-free version of the policy during evaluation and we observe that it indeed improves the performance (Fig. 30). The policy MLP size does not matter much (Figs. 31-32) while bigger critic networks perform significantly better (Figs. 9-10). Regarding activation functions, relu performs on par or better than tanh in all environments apart from door in which tanh is significantly better (Fig. 33). Our implementation of TD3 optionally applies gradient clipping but it does not affect the performance much (Fig. 34). D4PG can use n-step returns, this improves the performance on the Adroit tasks but hurts on the Gym suite (Fig. 35).
+
+# 4 What matters for the discriminator training?
+
+Summary of key findings. MLP discriminators perform on par or better than AIL-specific architectures. Explicit discriminator regularization is only important in more complicated environments (Humanoid and harder ones). Spectral norm is overall the best regularizer but standard regularizers from supervised learning often perform on par. Optimal learning rate for the discriminator may be 2–2.5 orders of magnitude lower than the one for the RL agent.
+
+Discriminator input. In this section we look at the choices related to the discriminator training. Fig. 49 shows how the performance depends on the discriminator input. We can observe that while it is beneficial to feed actions as well as states to the discriminator, the state-only demonstrations perform almost as well. Interestingly, on the door task with human data, it is better to ignore the expert actions. We explore the results with human demonstrations in more depth in Sec. 5.
+
+Discriminator architecture. Regarding the discriminator network, our basic architecture is an MLP but we also consider two modifications introduced in AIRL [17]: a reward shaping term and a $\log \pi ( a | s )$ logit shift which introduces a dependence on the current policy (only applicable to RL algorithms with stochastic policies, which in our case are PPO and SAC). See App. D.3 for a detailed description of these techniques. Fig. 13 shows that the logit shift significantly hurts the performance.
+
+This is mainly due to the fact that it does not work well with SAC which is off-policy (Fig. 21). Fig. 50 shows that the shaping term does not affect the performance much. While the modifications from AIRL does not improve the sample complexity in our experiments, it is worth mentioning that they were introduced for another purpose, namely the recovery of transferable reward functions.
+
+Regarding the size of the discriminator MLP(s), the best results on all tasks are obtained with a single hidden layer (Fig. 51), while the size of the hidden layer is of secondary importance (if it is not very small) with the exception of the tasks with human data where fewer hidden units perform significantly better (Fig. 52). All tested discriminator activation functions perform overall similarly while sigmoid performs best with human demonstrations (Fig. 53).
+
+Discriminator training. Fig. 54 shows that it is best to use as large as possible replay buffers for sampling negative examples (i.e. agent transitions). Prior work has claimed the initialization of the last policy layer can significantly influence the performance in RL [42], thus we tried initializing the last discriminator layer with smaller weights but it does not make much difference (Fig 55).
+
+Discriminator regularization. An overfit or too accurate discriminator can make agent’s training challenging, and therefore it is common to use additional regularization techniques when training the AIL discriminator (or GANs in general). We run experiments with a number of regularizers commonly used with AIL, namely Gradient Penalty [18] (GP, used e.g. in [31]), spectral norm [35] (e.g. in [44]), Mixup [23] (e.g. in [52]), as well as using the PUGAIL loss [41] instead of the standard cross entropy loss to train the discriminator. Apart from the above regularizers, we also run experiments with regularizers commonly used in Supervised Learning, namely dropout [10], the weight decay [1] variant from AdamW [33] as well as the entropy bonus of the discriminator output treated as a Bernoulli distribution. The detailed description of all these regularization techniques can be found in App. D.5.
+
+![](images/c39447023d7968d0529aa7c9857d7a8c0207ab8047cb80e05a5eb2ac492b89c9.jpg)  
+Figure 2: The 95th percentile of performance for different discriminator regularizers. The central plot shows the average performance across 5 tasks from OpenAI Gym and the right one the average performance across 5 tasks from the Adroit suite. See Fig. 56 for the plots for individual environments.
+
+Fig. 2 shows how the performance depends on the regularizer. Spectral normalization performs overall best, while GP, dropout and weight decay all perform on par with each other and only a bit worse than spectral normalization. We find this conclusion to be quite surprising given that we have not seen dropout or weight decay being used with AIL in literature. We also notice that the regularization is generally more important on harder tasks like Humanoid or the tasks in the Adroit suite (Fig. 56).
+
+Most of the regularizers investigated in this section have their own HPs and therefore the comparison of different regularizers depends on how these HPs are sampled. As we randomly sample the regularizer-specific HPs in this analysis, our approach favours regularizers that are not too sensitive to their HPs. At the same time, there might be regularizers that are sensitive to their HPs but for which good settings may be easily found. Fig. 67 shows that even if we condition on choosing the optimal HPs for each regularizer, the relative ranking of regularizers does not change.
+
+Moreover, there might be correlations between the regularizer and other HPs, therefore their relative performance may depend on the distribution of all other HPs. In fact, we have found two such surprising correlations. Fig. 73 shows the performance conditioned on the regularizer used as well as the discriminator learning rate. We notice that for PUGAIL, entropy and no regularization, the performance significantly increases for lower discriminator learning rates and the best performing discriminator learning rate $( 1 0 ^ { - 6 } )$ is in fact 2-2.5 orders of magnitude lower than the best learning rate for the RL algorithm (0.0001–0.0003, Figs. 14, 38, 39, 41, 47).9 On the other hand, the remaining regularizers are not too sensitive to the discriminator learning rate. This means that the performance gap between PUGAIL, entropy and no regularization and the other regularizers is to some degree caused by the fact that the former ones are more sensitive to the learning rate and may be smaller than suggested by Fig. 2 if we adjust for the appropriate choice of the discriminator learning rate. We can notice that PUGAIL and entropy are the only regularizers which only change the discriminator loss but do not affect the internals of the discriminator neural network. Given that they are the only two regularizers benefiting from very low discriminator learning rate, we suspect that it means that a very low learning rate can play a regularizing role in the absence of an explicit regularization inside the network.
+
+Another surprising correlation is that in some environments, the regularizer interacts strongly with observation normalization (described App. D.6) employed on discriminator inputs (see Fig. 74 for an example on Ant). These two correlations highlight the difficulty of comparing regularizers, and algorithmic choices more broadly, as their performance significantly depends on the distribution of other HPs.
+
+We also supplement our analysis by comparing the performance of different regularizers for the best found HPs. More precisely, we choose the best value for each HP in the main experiment (listed in App. E) and run them with different regularizers. To account for the mentioned correlations with the discriminator learning rate and observation normalization, we also include these two choices in the HP sweep and choose the best performing variant (as measure by the area under the learning curve) for each regularizer and each environment.
+
+![](images/9f738e4e0f330137f939be30ce289f818ad9b77d6373ce40f4a55cc1cb8a2f01.jpg)  
+Figure 3: Learning curves for different discriminator regularizers when the other HPs are set to the best performing value across all tasks. The y-axis shows the average policy return normalized so that 0 corresponds to a random policy and 1 to the expert. See App. E for the HPs used. The plots shows the averages across 30 random seeds. Best seen in color.
+
+While it is not guaranteed that the performance is going to be good at all because we greedily choose the best performing value for each HP and there might be some unaccounted HP correlations, we find that the performance is very competitive (Fig. 3). Notice that we use the same HPs in all environments and the performance can be probably improved by varying some HPs between the environments, or at least between the two environment suites.
+
+We notice that on the four easiest tasks (HalfCheetah, Hopper, Walker2d, Ant), investigated discriminator regularizers provide no, or only minor performance improvements and excellent results can be achieved without them. On the tasks where regularization is beneficial, we usually see that there are multiple regularizers performing similarly well, with spectral normalization being one of the best regularizers in all tasks apart from the two tasks with human data where PUGAIL performs better.
+
+Regularizers-specific HPs. For GP, the target gradient norm of 1 is slightly better in most environments but the value of 0 is significantly better in hammer-human (Fig. 57), while the penalty strength of 1 performs best overall (Fig. 58). For dropout, it is important to apply it not only to hidden layers but also to inputs (Fig. 59) and the best results are obtained for $50 \%$ input dropout and $7 5 \%$ hidden activations dropout (Figs. 59, 60 and 67). For weight decay, the optimal decay coefficient in the AIL setup is much larger than the values typically used for Supervised Learning, the value $\lambda = 1 0$ performs best in our experiments (Fig. 61). For Mixup, $\alpha = 1$ outperforms the other values on almost all tested environments (Fig. 62). For PUGAIL, the unbounded version performs much better on the Adroit suite, while the bounded version is better on the Gym tasks (Fig. 63), and positive class prior of $\eta = 0 . 7$ performs well on most tasks (Fig. 64). For the discriminator entropy bonus, the values around 0.03 performed best overall (Fig. 65). All experiments with spectral normalization enforce the Lipschitz constant of 1 for each weight matrix.
+
+How to train efficiently? So far we have analysed how HPs affect the sample complexity of AIL algorithms. For the analysis of the HPs which influence sample complexity as well as the computational cost of running an algorithm see App. A. In particular, we describe there a simple code optimization relying on processing multiple batches at once which makes training $2 { - } 3 \mathbf { x }$ faster in wall clock time without affecting the sample complexity (Fig. 5).
+
+# 5 Are synthetic demonstrations a good proxy for human data?
+
+Summary of key findings Human demonstrations significantly differ from synthetic ones. Learning from human demonstrations benefits more from discriminator regularization and may work better with different discriminator inputs and reward functions than RL-generated demonstrations.
+
+Using a dataset of human demonstrations comes with a number of additional challenges. Compared to synthetic demonstrations, the human policy can be multi-modal in that for a given state different decisions might be chosen. A typical example occurs when the human demonstrator remains idle for some time (for example to think about the next action) before taking the actual relevant action: we have two modes in that state, the relevant action has a low probability while the idle action has a very high probability. The human policy might not be exactly markovian either. Those differences are significant enough that the conclusions on synthetic datasets might not hold anymore.
+
+In this section, we focus on the Adroit door and hammer environments for which we run experiments with human as well as synthetic demonstrations. 10 Note that on top of the aforementioned challenges, the setup with the Adroit environments using human demonstrations exhibits a few additional specifics. The demonstrations were collected letting the human decide when the task is completed: said in a different way, the demonstrator is offered an additional action to jump directly to a terminal state and this action is not available to the agent imitating the expert. The end result is a dataset of demonstrations of variable length while the agent can only generate episodes consisting of exactly 200 transitions. Note that there was no time limit imposed on the demonstrator and some of the demonstrations have a length greater than 200 transitions. Getting to the exact same state distribution as the human expert may be impossible, and imitation learning algorithms may have to make some trade-offs. The additional specificity of that setup is that the reward of the environment is not exactly what the human demonstrator optimized. In the door environment, the reward provided by the environment is the highest when the door is fully opened while the human might abort the task slightly before getting the highest reward. However, overall, we consider the reward provided by the environment as a reasonable metric to assess the quality of the trained policies. Moreover, in the hammer environment, some demonstrations have a low return and we suspect those are not successful demonstrations.11
+
+Discriminator regularization. When comparing the results for RL-generated (adroit-expert12) and human demonstrations (adroit-human) we can notice differences on a number of HPs related to the discriminator training. Human demonstrations benefit more from using discriminator regularizers (Fig. 56) and they also work better with smaller discriminator networks (Fig. 52) trained with lower learning rates (Fig. 66). The increased need for regularization suggest that it is easier to overfit to the idiosyncrasies of human demonstrations than to those of RL policies.
+
+![](images/1900ff5a7e1b5a04b03832649b9fdf09dad1f97f7f92fd103e915552ff77f0aa.jpg)  
+Figure 4: Comparison of discriminator inputs (a) and reward functions (b) for environments with human demonstrations. See Fig. 49 and Fig. 25 for the individual results in all environments.
+
+Discriminator input. Fig. 4a shows the performance given the discriminator input depending on the demonstration source. For most tasks with RL-generated demonstrations, feeding actions as well as states improves the performance (Fig. 49). Yet, the opposite holds when human demonstrations are used. We suspect that it might be caused by the mentioned issue with demonstrations lengths which forces the policy to repeat a similar movement but with a different speed than the demonstrator.
+
+Reward functions. Finally, we look at how the relative performance of different reward functions depends on the demonstration source. Fig. 4b shows that for RL-generated demonstrations the best reward function is AIRL while $- \ln ( 1 - D )$ performs better with human demonstrations. Under the assumption that the discriminator is optimal, these two reward functions correspond to the minimization of different divergences between the state (or state-action depending on the discriminator input) occupancy measures of the policy (denoted $\pi$ ) and the expert (denoted $E$ ) .
+
+The reward function performing best with human demonstrations $( - \ln ( 1 - D ) )$ corresponds to the minimization of the Jensen-Shannon divergence (proof in [14]). Interestingly, this divergence is symmetric $( D _ { \mathrm { J S } } ( \pi | | E ) = D _ { \mathrm { J S } } ( E | | \pi ) )$ and bounded $( 0 \leq D _ { \mathrm { J S } } ( \pi | | E ) \leq \ln ( 2 ) )$ . For AIL, the symmetry means that it penalizes the policy for doing things the expert never does with exactly the same weight as for not doing some of the things the expert does while the boundedness means that the penalty for not visiting a single state is always finite. We suspect that this boundedness is beneficial for learning with human demonstrations because it may not be possible to exactly match the human distribution for the reasons explained earlier.
+
+In contrast to Jensen-Shannon, the $D _ { \mathrm { K L } } ( \pi | | E )$ divergence which is optimized by the AIRL reward (proof in [46]) is neither symmetric, nor bounded — it penalizes the policy much more heavily for doing the things the expert never does that for not doing all the things the expert does and the penalty for visiting a single state the expert never visits is infinite (assuming a perfect discriminator).
+
+While it is hard to draw any general conclusions only from the two investigated environments for which we had access to human demonstrations, our analysis shows that the differences between synthetic and human-generated demonstrations can influence the relative performance of different algorithmic choices. This suggests that RL-generated data are not a good proxy for human demonstrations and that the very common practice of evaluating IL only with synthetic demonstrations may lead to algorithms which perform poorly in the more realistic scenarios with human demonstrations.
+
+# 6 Related work
+
+The most similar work to ours is probably [44] which compares the performance of different discriminator regularizers and concludes that gradient penalty is necessary for achieving good performance with off-policy AIL algorithms. In contrast to [44], which uses a single HP configuration, we run large-scale experiments with very wide HP sweeps which allows us to reach more robust conclusions. In particular, we are able to achieve excellent sample complexity on all the environments used in [44] without using any explicit discriminator regularizer (Fig. 3).
+
+The methodology of our study is mostly based on [42] which analyzed the importance of different choices for on-policy actor-critic methods. Our work is also similar to other large-scale studies done in other fields of Deep Learning, e.g. model-based RL [38], GANs [34], NLP [50], disentangled representations [32] and convolution network architectures [51].
+
+# 7 Conclusions
+
+In this empirical study, we investigate in depth many aspects of the AIL framework including discriminator architecture, training and regularization as well as many choices related to the agent training. Our key findings can be divided into three categories: (1) Corroborating prior work, e.g. for the underlying RL problem, off-policy algorithms are more sample efficient than on-policy ones; (2) Adding nuances to previous studies, e.g. while the regularization schemes encouraging Lipschitzness improve the performance, more classical regularizers like dropout or weight decay often perform on par; (3) Raising concerns: we observe a high discrepancy between the results for RL-generated and human data. We hope this study will be helpful to anyone using or designing AIL algorithms.
+
+Additionally we released the [1] unified AIL agent we implemented in JAX within the Acme framework as well as [2] the raw data of our experiment, along with [3] a Notebook that allows to load and study them.
+
+[1] https://github.com/deepmind/acme/tree/master/acme/agents/jax/ail [2] https://storage.googleapis.com/what-matters-in-imitation-learning/data.json [3] https://storage.googleapis.com/what-matters-in-imitation-learning/analysis_ colab.ipynb
+
+# Acknowledgments
+
+We thank Kamyar Ghasemipour for the discussions related to the FAIRL reward function and Lucas Beyer for the feedback on an earlier version of the manuscript.
+
+# References
+
+back-propagation”. In: Advances in neural information processing systems 1 (1988), pp. 177– 185.   
+[2] Dean A Pomerleau. “Efficient training of artificial neural networks for autonomous navigation”. In: Neural computation 3.1 (1991), pp. 88–97.   
+[3] Stuart Russell. “Learning agents for uncertain environments”. In: Conference on Computational learning theory. 1998.   
+[4] Stefan Schaal. “Is imitation learning the route to humanoid robots?” In: Trends in Cognitive Sciences 3.6 (1999), pp. 233–242. ISSN: 1364-6613. DOI: https : / / doi . org / 10 . 1016 / S1364- 6613(99)01327- 3. URL: http://www.sciencedirect.com/science/article/pii/ S1364661399013273.   
+[5] Andrew Y Ng, Stuart J Russell, et al. “Algorithms for inverse reinforcement learning.” In: Icml. Vol. 1. 2000, p. 2.   
+[6] Brian D Ziebart et al. “Maximum entropy inverse reinforcement learning.” In: Aaai. Vol. 8. Chicago, IL, USA. 2008, pp. 1433–1438.   
+[7] Brenna D Argall et al. “A survey of robot learning from demonstration”. In: Robotics and autonomous systems 57.5 (2009), pp. 469–483.   
+[8] Brian D Ziebart. “Modeling purposeful adaptive behavior with the principle of maximum causal entropy”. In: (2010).   
+[9] Ian J Goodfellow et al. “Generative adversarial networks”. In: arXiv preprint arXiv:1406.2661 (2014).   
+[10] Nitish Srivastava et al. “Dropout: a simple way to prevent neural networks from overfitting”. In: The journal of machine learning research 15.1 (2014), pp. 1929–1958.   
+[11] Diederik P. Kingma and Jimmy Ba. “Adam: A Method for Stochastic Optimization”. In: 3rd International Conference on Learning Representations, ICLR 2015, San Diego, CA, USA, May 7-9, 2015, Conference Track Proceedings. 2015. URL: http://arxiv.org/abs/1412.6980.   
+[12] John Schulman et al. “High-dimensional continuous control using generalized advantage estimation”. In: arXiv preprint arXiv:1506.02438 (2015).   
+[13] Greg Brockman et al. “Openai gym”. In: arXiv preprint arXiv:1606.01540 (2016).   
+[14] Jonathan Ho and Stefano Ermon. “Generative adversarial imitation learning”. In: arXiv preprint arXiv:1606.03476 (2016).   
+[15] David Silver et al. “Mastering the game of Go with deep neural networks and tree search”. In: nature 529.7587 (2016), p. 484.   
+[16] Marc G Bellemare, Will Dabney, and Rémi Munos. “A distributional perspective on reinforcement learning”. In: International Conference on Machine Learning. PMLR. 2017, pp. 449– 458.   
+[17] Justin Fu, Katie Luo, and Sergey Levine. “Learning robust rewards with adversarial inverse reinforcement learning”. In: arXiv preprint arXiv:1710.11248 (2017).   
+[18] Ishaan Gulrajani et al. “Improved training of wasserstein gans”. In: arXiv preprint arXiv:1704.00028 (2017).   
+[19] Riashat Islam et al. “Reproducibility of benchmarked deep reinforcement learning tasks for continuous control”. In: arXiv preprint arXiv:1708.04133 (2017).   
+[20] Ivaylo Popov et al. “Data-efficient deep reinforcement learning for dexterous manipulation”. In: arXiv preprint arXiv:1704.03073 (2017).   
+[21] Aravind Rajeswaran et al. “Learning complex dexterous manipulation with deep reinforcement learning and demonstrations”. In: arXiv preprint arXiv:1709.10087 (2017).   
+[22] John Schulman et al. “Proximal policy optimization algorithms”. In: arXiv preprint arXiv:1707.06347 (2017).   
+[23] Hongyi Zhang et al. “mixup: Beyond empirical risk minimization”. In: arXiv preprint arXiv:1710.09412 (2017).   
+[24] Gabriel Barth-Maron et al. “Distributed distributional deterministic policy gradients”. In: arXiv preprint arXiv:1804.08617 (2018).   
+[25] James Bradbury et al. JAX: composable transformations of Python $^ +$ NumPy programs. Version 0.2.5. 2018. URL: http://github.com/google/jax.   
+[26] Scott Fujimoto, Herke Hoof, and David Meger. “Addressing function approximation error in actor-critic methods”. In: International Conference on Machine Learning. PMLR. 2018, pp. 1587–1596.   
+[27] Tuomas Haarnoja et al. “Soft actor-critic algorithms and applications”. In: arXiv preprint arXiv:1812.05905 (2018).   
+[28] Tuomas Haarnoja et al. “Soft Actor-Critic: Off-Policy Maximum Entropy Deep Reinforcement Learning with a Stochastic Actor”. In: International Conference on Machine Learning. 2018, pp. 1861–1870.   
+[29] Peter Henderson et al. “Deep reinforcement learning that matters”. In: Thirty-Second AAAI Conference on Artificial Intelligence. 2018.   
+[30] Todd Hester et al. “Deep q-learning from demonstrations”. In: Proceedings of the AAAI Conference on Artificial Intelligence. Vol. 32. 1. 2018.   
+[31] Ilya Kostrikov et al. “Discriminator-actor-critic: Addressing sample inefficiency and reward bias in adversarial imitation learning”. In: arXiv preprint arXiv:1809.02925 (2018).   
+[32] Francesco Locatello et al. “Challenging common assumptions in the unsupervised learning of disentangled representations”. In: arXiv preprint arXiv:1811.12359 (2018).   
+[33] Ilya Loshchilov and Frank Hutter. “Fixing weight decay regularization in adam”. In: (2018).   
+[34] Mario Lucic et al. “Are gans created equal? a large-scale study”. In: Advances in neural information processing systems. 2018, pp. 700–709.   
+[35] Takeru Miyato et al. “Spectral normalization for generative adversarial networks”. In: arXiv preprint arXiv:1802.05957 (2018).   
+[36] George Tucker et al. “The mirage of action-dependent baselines in reinforcement learning”. In: arXiv preprint arXiv:1802.10031 (2018).   
+[37] Christopher Berner et al. “Dota 2 with large scale deep reinforcement learning”. In: arXiv preprint arXiv:1912.06680 (2019).   
+[38] Eric Langlois et al. “Benchmarking model-based reinforcement learning”. In: arXiv preprint arXiv:1907.02057 (2019).   
+[39] Tom Le Paine et al. “Making efficient use of demonstrations to solve hard exploration problems”. In: arXiv preprint arXiv:1909.01387 (2019).   
+[40] Oriol Vinyals et al. “Grandmaster level in StarCraft II using multi-agent reinforcement learning”. In: Nature 575.7782 (2019), pp. 350–354.   
+[41] Danfei $\mathrm { X u }$ and Misha Denil. “Positive-unlabeled reward learning”. In: arXiv preprint arXiv:1911.00459 (2019).   
+[42] Marcin Andrychowicz et al. “What matters in on-policy reinforcement learning? a large-scale empirical study”. In: arXiv preprint arXiv:2006.05990 (2020).   
+[43] OpenAI: Marcin Andrychowicz et al. “Learning dexterous in-hand manipulation”. In: The International Journal of Robotics Research 39.1 (2020), pp. 3–20.   
+[44] Lionel Blondé, Pablo Strasser, and Alexandros Kalousis. “Lipschitzness Is All You Need To Tame Off-policy Generative Adversarial Imitation Learning”. In: arXiv preprint arXiv:2006.16785 (2020).   
+[45] Justin Fu et al. “D4rl: Datasets for deep data-driven reinforcement learning”. In: arXiv preprint arXiv:2004.07219 (2020).   
+[46] Seyed Kamyar Seyed Ghasemipour, Richard Zemel, and Shixiang Gu. “A divergence minimization perspective on imitation learning methods”. In: Conference on Robot Learning. PMLR. 2020, pp. 1259–1277.   
+[47] Jonathan Heek et al. Flax: A neural network library and ecosystem for JAX. Version 0.3.3. 2020. URL: http://github.com/google/flax.   
+[48] Matteo Hessel et al. Optax: composable gradient transformation and optimisation, in JAX! Version 0.0.1. 2020. URL: http://github.com/deepmind/optax.   
+[49] Matt Hoffman et al. “Acme: A research framework for distributed reinforcement learning”. In: arXiv preprint arXiv:2006.00979 (2020).   
+[50] Jared Kaplan et al. “Scaling laws for neural language models”. In: arXiv preprint arXiv:2001.08361 (2020).   
+[51] Ilija Radosavovic et al. “Designing Network Design Spaces”. In: arXiv preprint arXiv:2003.13678 (2020).
+
+[52] Annie Chen et al. “Batch exploration with examples for scalable robotic reinforcement learning”. In: IEEE Robotics and Automation Letters (2021).
+
+# Checklist
+
+1. For all authors...
+
+(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   
+(b) Did you describe the limitations of your work? [Yes]   
+(c) Did you discuss any potential negative societal impacts of your work? [N/A] We study general purpose imitation algorithms which are not related to any particular application.   
+(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]   
+(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes]   
+(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [Yes]   
+(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [No]
+
+4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets...
+
+(a) If your work uses existing assets, did you cite the creators? [Yes]   
+(b) Did you mention the license of the assets? [No] D4RL demonstrations are available under Apache License 2.0   
+(c) Did you include any new assets either in the supplemental material or as a URL? [No]   
+(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A]   
+(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [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/-OrwaD3bG91/-OrwaD3bG91_content_list.json

@@ -0,0 +1,1075 @@
+[
+    {
+        "type": "text",
+        "text": "What Matters for Adversarial Imitation Learning? ",
+        "text_level": 1,
+        "bbox": [
+            189,
+            122,
+            805,
+            147
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Manu Orsini∗, Anton Raichuk∗, Léonard Hussenot∗†, Damien Vincent, Robert Dadashi, Sertan Girgin, Matthieu Geist, Olivier Bachem, Olivier Pietquin, Marcin Andrychowicz‡ ",
+        "bbox": [
+            246,
+            200,
+            758,
+            244
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Google Research, Brain Team ",
+        "bbox": [
+            400,
+            257,
+            598,
+            271
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            306,
+            535,
+            324
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Adversarial imitation learning has become a popular framework for imitation in continuous control. Over the years, several variations of its components were proposed to enhance the performance of the learned policies as well as the sample complexity of the algorithm. In practice, these choices are rarely tested all together in rigorous empirical studies. It is therefore difficult to discuss and understand what choices, among the high-level algorithmic options as well as low-level implementation details, matter. To tackle this issue, we implement more than 50 of these choices in a generic adversarial imitation learning framework and investigate their impacts in a large-scale study $( > 5 0 0 \\mathrm { k }$ trained agents) with both synthetic and human-generated demonstrations. We analyze the key results and highlight the most surprising findings. ",
+        "bbox": [
+            233,
+            340,
+            766,
+            492
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            521,
+            310,
+            539
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Reinforcement Learning (RL) has shown its ability to perform complex tasks in contexts where clear reward functions can be set-up (e.g. $+ 1$ for winning a chess game) [15, 37, 40, 43] but for many real-world applications, designing a correct reward function is either tedious or impossible [20], while demonstrating a correct behavior is often easy and cheap. Therefore, imitation learning (IL, [4, 7]) might be the key to unlock the resolution of more complex tasks, such as autonomous driving, for which reward functions are much harder to design. ",
+        "bbox": [
+            174,
+            554,
+            825,
+            637
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The simplest approach to IL is Behavioral Cloning (BC, [2]) which uses supervised learning to predict the expert’s action for any given state. However, BC is often unreliable as prediction errors compound in the course of an episode. Adversarial Imitation Learning (AIL, [14]) aims to remedy this using inspiration from Generative Adversarial Networks (GANs, [9]) and Inverse RL [3, 5, 6]: the policy is trained to generate trajectories that are indistinguishable from the expert’s ones. As in GANs, this is formalized as a two-player game where a discriminator is co-trained to distinguish between the policy and expert trajectories (or states). See App. C for a brief introduction to AIL. ",
+        "bbox": [
+            174,
+            643,
+            825,
+            741
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "A myriad of improvements over the original AIL algorithm were proposed over the years [17, 31, 41, 44, 46], from changing the discriminator’s loss function [17] to switching from on-policy to off-policy agents [31]. However, their relative performance is rarely studied in a controlled setting, and never these changes have never been compared simultaneously. The performance of these high-level choices may also depend on low-level implementation details which might be silenced in the original publications [19, 29, 36, 42], as well as the hyperparameters (HPs) used. Thus, assessing whether the proposed changes are the reason for the presented improvements becomes extremely difficult. This lack of proper comparisons slows down the overall research in imitation learning and the industrial applicability of these methods. ",
+        "bbox": [
+            174,
+            747,
+            825,
+            844
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            92,
+            823,
+            119
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We investigate such high- and low-level choices in depth and study their impact on the algorithm performance. Hence, as our key contributions, we (1) implement a highly-configurable generic AIL algorithm, with various axes of variation $( > 5 0 \\mathrm { H P s } )$ ), including 4 different RL algorithms and 7 regularization schemes for the discriminator, (2) conduct a large-scale $\\mathrm { 5 5 0 0 k }$ trained agents) experimental study on 10 continuous-control tasks and (3) analyze the experimental results to provide practical insights and recommendations for designing novel and using existing AIL algorithms. We release this generic AIL agent, implemented in JAX [25] as part of the Acme [49] framework: https://github.com/deepmind/acme/blob/master/acme/agents/jax/ail . ",
+        "bbox": [
+            174,
+            126,
+            825,
+            237
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Most surprising finding #1: regularizers. While many of our findings confirm common practices in AIL research, some of them are surprising or even contradict prior work. In particular, we find that standard regularizers from Supervised Learning — dropout [10] and weight decay [1] often perform similarly to the regularizers designed specifically for adversarial learning like gradient penalty [18]. Moreover, for easier environments (which were often the only ones used in prior work), we find that it is possible to achieve excellent results without using any explicit discriminator regularization. ",
+        "bbox": [
+            174,
+            252,
+            825,
+            335
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Most surprising finding #2: human demonstrations. Not only does the performance of AIL heavily depend on whether the demonstrations were collected from a human operator or generated by an RL algorithm, but the relative performance of algorithmic choices also depends on the demonstration source. Our results suggest that artificial demonstrations are not a good proxy for human data and that the very common practice of evaluating IL algorithms only with synthetic demonstrations may lead to algorithms which perform poorly in the more realistic scenarios with human demonstrations. ",
+        "bbox": [
+            174,
+            352,
+            825,
+            435
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Experimental design ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            455,
+            377,
+            473
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Environments. We focus on continuous-control tasks as robotics appears as one of the main potential applications of IL and a vast majority of the IL literature thus focuses on it. In particular, we run experiments with five widely used environments from OpenAI Gym [13]: HalfCheetah-v2, Hopper-v2, Walker2d-v2, Ant-v2, and Humanoid-v2 and three manipulation environments from Adroit [21]: pen-v0, door-v0, and hammer-v0. The Adroit tasks consist in aligning a pen with a target orientation, opening a door and hammering a nail with a 5-fingered hand. ",
+        "bbox": [
+            173,
+            488,
+            825,
+            571
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Demonstrations. For the Gym tasks, we generate demonstrations with a SAC [28] agent trained on the environment reward. For the Adroit environments, we use the “expert” and “human” datasets from D4RL [45], which are, respectively, generated by an RL agent and collected from a human operator. As far as we know, our work is the first to solve these tasks with human datasets in the imitation setup (most of the prior work concentrated on Offline RL). For all environments, we use 11 demonstration trajectories. Following prior work [14, 31, 46], we subsample expert demonstrations by only using every $2 0 ^ { \\mathrm { t h } }$ state-action pair to make the tasks harder. ",
+        "bbox": [
+            174,
+            588,
+            825,
+            685
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Adversarial Imitation Learning algorithms. We researched prior work on AIL algorithms and made a list of commonly used design decisions like policy objectives or discriminator regularization techniques. We also included a number of natural options which we have not encountered in literature (e.g. dropout [10] in the discriminator or clipping rewards bigger than a threshold). All choices are listed and explained in App. D. Then, we implemented a single highly-configurable AIL agent which exposes all these choices as configuration options in the Acme framework [49] using JAX [25] for automatic differentiation and Flax [47] for neural networks computation. The configuration space is so wide that it covers the whole family of AIL algorithms, in particular, it mostly covers the setups from AIRL [17] and DAC [31]. We plan to open source the agent implementation. ",
+        "bbox": [
+            174,
+            700,
+            825,
+            827
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Experimental design. We created a large HP sweep (57 HPs swept, ${ > } 1 2 0 \\mathrm { k }$ agents trained) in which each HP is sampled uniformly at random from a discrete set and independently from the other HPs. We manually ensured that the sampling ranges of all HPs are appropriate and cover the optimal values. Then, we analyzed the results of this initial experiment (called wide, detailed description and results in App. G), removed clearly suboptimal options and ran another experiment with the pruned sampling ranges (called main, $4 3 \\mathrm { H P s }$ swept, ${ > } 2 5 0 \\mathrm { k }$ agents trained, detailed description and results in App. H). The latter experiment serves as the basis for most of the conclusions drawn in this paper but we also run a few additional experiments to investigate some additional questions (App. I and App. J). ",
+        "bbox": [
+            174,
+            842,
+            825,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            823,
+            132
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "This pruning of the HP space guarantees that we draw conclusions based on training configurations which are highly competitive (training curves can be found in Fig. 24) while using a large HP sweep (including, for example, multiple different RL algorithms) ensures that our conclusions are robust and valid not only for a single RL algorithm and specific values of HPs, but are more generally applicable. Moreover, many choices may have strong interactions with other related choices, for example we find a surprisingly strong interaction between the discriminator regularization scheme and the discriminator learning rate (Sec. 4). This means that such choices need to be tuned together (as it is the case in our study) and experiments where only a single choice is varied but the interacting choices are kept fixed may lead to misleading conclusions. ",
+        "bbox": [
+            174,
+            140,
+            825,
+            263
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Performance measure. For each HP configuration and each of the 10 environment-dataset pairs we train a policy and evaluate it 10 times through the training by running it for 50 episodes and computing the average undiscounted return using the environment reward. We then average these scores to obtain a single performance score which approximates the area under the learning curve. This ensures we assign higher scores to HP configurations that learn quickly. ",
+        "bbox": [
+            174,
+            280,
+            825,
+            349
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Analysis. We consider two different analyses for each choice4: ",
+        "bbox": [
+            178,
+            366,
+            594,
+            381
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Conditional 95th percentile: For each potential value of that choice (e.g., RL Algorithm $= { \\tt P P 0 }$ ), we look at the performance distribution of sampled configurations with that value. We report the 95th percentile of the performance as well as error bars based on bootstrapping.5 This corresponds to an estimate of the performance one can expect if all other choices were tuned with random search and a limited budget of roughly $1 3 \\mathrm { H P }$ configurations6. All scores are normalized so that 0 corresponds to a random policy and 1 to the expert performance (expert scores can be found in App. F). ",
+        "bbox": [
+            174,
+            387,
+            825,
+            470
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Distribution of choice within top $5 \\%$ configurations. We further consider for each choice the distribution of values among the top $5 \\%$ HP configurations. In particular, we measure the ratio of the frequency of the given value in the top $5 \\%$ of HP configurations with the best performance to the frequency of this value among all HP configurations. If certain values are over-represented in the top models (ratio higher than 1), this indicates that the specific choice is important for good performance. ",
+        "bbox": [
+            174,
+            477,
+            825,
+            546
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We release the raw results of our experiments7 along with a Notebook allowing to load and study it8. ",
+        "bbox": [
+            176,
+            551,
+            818,
+            566
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 What matters for the agent training? ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            587,
+            514,
+            604
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Summary of key findings. The AIRL reward function perform best for synthetic demonstrations while $- \\ln ( 1 - D )$ is better for human demonstrations. Using explicit absorbing state is crucial in environments with variable length episodes. Observation normalization strongly affects the performance. Using an off-policy RL algorithm is necessary for good sample complexity while replaying expert data and pretraining with BC improves the performance only slightly. ",
+        "bbox": [
+            174,
+            619,
+            825,
+            689
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Implicit reward function. In this section, we investigate choices related to agent training with AIL, the most salient of which is probably the choice of the implicit reward function. Let $D ( s , a )$ be the probability of classifying the given state-action pair as expert by the discriminator. In particular, we run experiments with the following reward functions: $\\bar { r ( s , a ) = - \\log ( 1 - D ( s , a ) ) }$ (used in the original GAIL paper [14]), $r ( s , a ) \\bar { = } \\log D ( s , a ) - \\log ( 1 - D ( s , a ) )$ (called the AIRL reward [17]), $r ( s , a ) = \\log D ( s , a )$ (a natural choice we have not encountered in literature), and the FAIRL [46] reward function $r ( s , a ) = - h ( s , a ) \\cdot e ^ { h ( s , a ) }$ , where $h ( s , a )$ is the discriminator logit. It can be shown that, under the assumption that all episodes have the same length, maximizing these reward functions corresponds to the minimization of different divergences between the marginal state-action distribution of the expert and the policy. See [46] for an in-depth discussion on this topic. We also consider clipping the rewards with absolute values bigger than a threshold which is a HP. ",
+        "bbox": [
+            173,
+            705,
+            825,
+            805
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            90,
+            825,
+            147
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/0294a4d81ac5ba0b88d700af4e1fbf8304e0099061bf33f6c1ecf26a590fbe7d.jpg",
+        "image_caption": [
+            "Figure 1: Comparison of different reward functions. The bars show the 95th percentile across HPs sampling of the average policy performance during training. Plot (a) shows the results averaged across all 10 tasks. Plots (b) and (c) show the performance on the subset of environments with variable length episodes when the absorbing state is disabled (b) or enabled (c). See Fig. 12 and Fig. 72 for the individual results in all environments. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            187,
+            174,
+            807,
+            334
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The FAIRL reward performed much worse than all others in the initial wide experiment (Fig. 1a) and therefore was not included in our main experiment. This is mostly caused by its inferior performance with off-policy RL algorithms (Fig. 22). Moreover, reward clipping significantly helps the FAIRL reward (Fig. 23) while it does not help the other reward functions apart from some small gains for $- \\ln ( 1 - D )$ (Fig. 82). Therefore, we suspect that the poor performance of the FAIRL reward function may be caused by its exponential term which may have very high magnitudes. Moreover, the FAIRL paper [46] mentions that the FAIRL reward is more sensitive to HPs than other reward functions which could also explain its poor performance in our experiments. ",
+        "bbox": [
+            173,
+            426,
+            825,
+            537
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Fig. 25 shows that the $\\ln ( D )$ reward functions performs a bit worse than the other two reward functions in the main experiment. Five out of the ten tasks used in our experiments have variable length episodes with longer episodes correlated with better behaviour (Hopper, Walker2d, Ant, Humanoid, pen) — on these tasks we can notice that $r ( s , a ) = - \\ln ( 1 - \\bar { D ( s , a ) } )$ often performs best and $r ( \\bar { s } , a ) = \\ln D ( s , a )$ worst. This can be explained by the fact that $- \\ln ( 1 - D ( s , a ) ) > 0$ and $\\ln D ( s , a ) < 0$ which means that the former reward encourages longer episodes and the latter one shorter ones [31]. Absorbing state (described in App. D.2) is a technique introduced in the DAC paper [31] to mitigate the mentioned bias and encourage the policy to generate episodes of similar length to demonstrations. In Fig. 1b-c we show how the performance of different reward functions compares in the environments with variable length episodes depending on whether the absorbing state is used. We can notice that without the absorbing state $\\bar { r } ( s , a ) \\bar { = } - \\ln ( 1 - D ( s , a ) ) > \\bar { 0 }$ performs much better in the environments with variable episode length which suggests that the learning is driven to a large extent by the reward bias and not actual imitation of the expert behaviour [31]. This effect disappears when the absorbing state is enabled (Fig. 1c). ",
+        "bbox": [
+            173,
+            544,
+            826,
+            738
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Fig. 72 shows the performance of different reward functions in all environments conditioned on whether the absorbing state is used. If the absorbing state is used, the AIRL reward function performs best in all the environments with RL-generated demonstrations, and $\\ln ( D )$ performs only marginally worse. The $- \\ln ( 1 - D )$ reward function underperforms on the Humanoid and pen tasks while performing best with human datasets. We provide some hypothesis for this behaviour in Sec. 5, where we discuss human demonstrations in more details. ",
+        "bbox": [
+            173,
+            743,
+            825,
+            827
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Observation normalization. We consider observation normalization which is applied to the inputs of all neural networks involved in AIL (policy, critic and discriminator). The normalization aims to transform the observations so that that each observation coordinate has mean 0 and standard deviation 1. In particular, we consider computing the normalization statistics either using only the expert demonstrations so that the normalization is fixed throughout the training, or using data from the policy being trained (called online). See App. D.6 for more details. Fig. 26 shows that input normalization significantly influences the performance with the effects on performance being often much larger than those of algorithmic choices like the reward function or RL algorithm used. Surprisingly, normalizing observations can either significantly improve or diminish performance and whether the fixed or online normalization performs better is also environment dependent. ",
+        "bbox": [
+            174,
+            842,
+            823,
+            911
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            92,
+            825,
+            160
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Replaying expert data. When demonstrations as well as external rewards are available, it is common for RL algorithms to sample batches for off-policy updates from the demonstrations in addition to the replay buffer [30, 39]. We varied the ratio of the policy to expert data being replayed but found only very minor gains (Fig. 83). Moreover, in the cases when we see some benefits, it is usually best to replay 16–64 times more policy than expert data. On some tasks (Humanoid) replaying even a single expert transitions every 256 agent ones significantly hurts performance. We suspect that, in contrast to RL with demonstrations, we see little benefit from replaying expert data in the setup with learned rewards because (1) replaying expert data mostly helps when the reward signal is sparse (not the case for discriminator-based rewards), and (2) discriminator may overfit to the expert demonstrations which could result in incorrectly high rewards being assigned to expert transitions. ",
+        "bbox": [
+            174,
+            175,
+            825,
+            314
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Pretraining with BC. We also experiment with pretraining a policy with Behavioral Cloning (BC, [2]) at the beginning of training. Despite starting from a much better policy than a random one, we usually observe that the policy quality deteriorates quickly at the beginning of training (see the pen task in Fig. 3) due to being updated using randomly initialized critic and discriminator networks, and the overall gain from pretraining is very small in most environments (Fig. 27). ",
+        "bbox": [
+            174,
+            328,
+            825,
+            398
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "RL algorithms. We run experiments with four different RL algorithms, three of which are off-policy algorithms (SAC [28], TD3 [26] and D4PG [24]), as well as PPO [22] which is nearly on-policy. Fig. 7 shows that the sample complexity of PPO is significantly worse than that of the off-policy algorithms while all off-policy algorithms perform overall similarly. ",
+        "bbox": [
+            174,
+            412,
+            823,
+            469
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "RL algorithms HPs. Fig. 8 shows that the discount factor is one of the most important HPs with the values of $0 . 9 7 - 0 . 9 9$ performing well on all tasks. Fig. 29 shows that in most environments it is better not to erase any data from the RL replay buffer and always sample from all the experience encountered so far. It is common in RL to use a noise-free version of the policy during evaluation and we observe that it indeed improves the performance (Fig. 30). The policy MLP size does not matter much (Figs. 31-32) while bigger critic networks perform significantly better (Figs. 9-10). Regarding activation functions, relu performs on par or better than tanh in all environments apart from door in which tanh is significantly better (Fig. 33). Our implementation of TD3 optionally applies gradient clipping but it does not affect the performance much (Fig. 34). D4PG can use n-step returns, this improves the performance on the Adroit tasks but hurts on the Gym suite (Fig. 35). ",
+        "bbox": [
+            174,
+            483,
+            825,
+            622
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 What matters for the discriminator training? ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            642,
+            581,
+            659
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Summary of key findings. MLP discriminators perform on par or better than AIL-specific architectures. Explicit discriminator regularization is only important in more complicated environments (Humanoid and harder ones). Spectral norm is overall the best regularizer but standard regularizers from supervised learning often perform on par. Optimal learning rate for the discriminator may be 2–2.5 orders of magnitude lower than the one for the RL agent. ",
+        "bbox": [
+            174,
+            672,
+            825,
+            742
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Discriminator input. In this section we look at the choices related to the discriminator training. Fig. 49 shows how the performance depends on the discriminator input. We can observe that while it is beneficial to feed actions as well as states to the discriminator, the state-only demonstrations perform almost as well. Interestingly, on the door task with human data, it is better to ignore the expert actions. We explore the results with human demonstrations in more depth in Sec. 5. ",
+        "bbox": [
+            174,
+            757,
+            825,
+            827
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Discriminator architecture. Regarding the discriminator network, our basic architecture is an MLP but we also consider two modifications introduced in AIRL [17]: a reward shaping term and a $\\log \\pi ( a | s )$ logit shift which introduces a dependence on the current policy (only applicable to RL algorithms with stochastic policies, which in our case are PPO and SAC). See App. D.3 for a detailed description of these techniques. Fig. 13 shows that the logit shift significantly hurts the performance. ",
+        "bbox": [
+            174,
+            842,
+            825,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "This is mainly due to the fact that it does not work well with SAC which is off-policy (Fig. 21). Fig. 50 shows that the shaping term does not affect the performance much. While the modifications from AIRL does not improve the sample complexity in our experiments, it is worth mentioning that they were introduced for another purpose, namely the recovery of transferable reward functions. ",
+        "bbox": [
+            174,
+            90,
+            825,
+            147
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Regarding the size of the discriminator MLP(s), the best results on all tasks are obtained with a single hidden layer (Fig. 51), while the size of the hidden layer is of secondary importance (if it is not very small) with the exception of the tasks with human data where fewer hidden units perform significantly better (Fig. 52). All tested discriminator activation functions perform overall similarly while sigmoid performs best with human demonstrations (Fig. 53). ",
+        "bbox": [
+            174,
+            152,
+            825,
+            223
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Discriminator training. Fig. 54 shows that it is best to use as large as possible replay buffers for sampling negative examples (i.e. agent transitions). Prior work has claimed the initialization of the last policy layer can significantly influence the performance in RL [42], thus we tried initializing the last discriminator layer with smaller weights but it does not make much difference (Fig 55). ",
+        "bbox": [
+            174,
+            238,
+            825,
+            295
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Discriminator regularization. An overfit or too accurate discriminator can make agent’s training challenging, and therefore it is common to use additional regularization techniques when training the AIL discriminator (or GANs in general). We run experiments with a number of regularizers commonly used with AIL, namely Gradient Penalty [18] (GP, used e.g. in [31]), spectral norm [35] (e.g. in [44]), Mixup [23] (e.g. in [52]), as well as using the PUGAIL loss [41] instead of the standard cross entropy loss to train the discriminator. Apart from the above regularizers, we also run experiments with regularizers commonly used in Supervised Learning, namely dropout [10], the weight decay [1] variant from AdamW [33] as well as the entropy bonus of the discriminator output treated as a Bernoulli distribution. The detailed description of all these regularization techniques can be found in App. D.5. ",
+        "bbox": [
+            173,
+            310,
+            826,
+            435
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/c39447023d7968d0529aa7c9857d7a8c0207ab8047cb80e05a5eb2ac492b89c9.jpg",
+        "image_caption": [
+            "Figure 2: The 95th percentile of performance for different discriminator regularizers. The central plot shows the average performance across 5 tasks from OpenAI Gym and the right one the average performance across 5 tasks from the Adroit suite. See Fig. 56 for the plots for individual environments. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            453,
+            823,
+            648
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Fig. 2 shows how the performance depends on the regularizer. Spectral normalization performs overall best, while GP, dropout and weight decay all perform on par with each other and only a bit worse than spectral normalization. We find this conclusion to be quite surprising given that we have not seen dropout or weight decay being used with AIL in literature. We also notice that the regularization is generally more important on harder tasks like Humanoid or the tasks in the Adroit suite (Fig. 56). ",
+        "bbox": [
+            173,
+            717,
+            825,
+            787
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Most of the regularizers investigated in this section have their own HPs and therefore the comparison of different regularizers depends on how these HPs are sampled. As we randomly sample the regularizer-specific HPs in this analysis, our approach favours regularizers that are not too sensitive to their HPs. At the same time, there might be regularizers that are sensitive to their HPs but for which good settings may be easily found. Fig. 67 shows that even if we condition on choosing the optimal HPs for each regularizer, the relative ranking of regularizers does not change. ",
+        "bbox": [
+            174,
+            792,
+            825,
+            877
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Moreover, there might be correlations between the regularizer and other HPs, therefore their relative performance may depend on the distribution of all other HPs. In fact, we have found two such surprising correlations. Fig. 73 shows the performance conditioned on the regularizer used as well as the discriminator learning rate. We notice that for PUGAIL, entropy and no regularization, the performance significantly increases for lower discriminator learning rates and the best performing discriminator learning rate $( 1 0 ^ { - 6 } )$ is in fact 2-2.5 orders of magnitude lower than the best learning rate for the RL algorithm (0.0001–0.0003, Figs. 14, 38, 39, 41, 47).9 On the other hand, the remaining regularizers are not too sensitive to the discriminator learning rate. This means that the performance gap between PUGAIL, entropy and no regularization and the other regularizers is to some degree caused by the fact that the former ones are more sensitive to the learning rate and may be smaller than suggested by Fig. 2 if we adjust for the appropriate choice of the discriminator learning rate. We can notice that PUGAIL and entropy are the only regularizers which only change the discriminator loss but do not affect the internals of the discriminator neural network. Given that they are the only two regularizers benefiting from very low discriminator learning rate, we suspect that it means that a very low learning rate can play a regularizing role in the absence of an explicit regularization inside the network. ",
+        "bbox": [
+            174,
+            883,
+            821,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            90,
+            825,
+            271
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Another surprising correlation is that in some environments, the regularizer interacts strongly with observation normalization (described App. D.6) employed on discriminator inputs (see Fig. 74 for an example on Ant). These two correlations highlight the difficulty of comparing regularizers, and algorithmic choices more broadly, as their performance significantly depends on the distribution of other HPs. ",
+        "bbox": [
+            174,
+            277,
+            825,
+            333
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We also supplement our analysis by comparing the performance of different regularizers for the best found HPs. More precisely, we choose the best value for each HP in the main experiment (listed in App. E) and run them with different regularizers. To account for the mentioned correlations with the discriminator learning rate and observation normalization, we also include these two choices in the HP sweep and choose the best performing variant (as measure by the area under the learning curve) for each regularizer and each environment. ",
+        "bbox": [
+            173,
+            339,
+            825,
+            422
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/9f738e4e0f330137f939be30ce289f818ad9b77d6373ce40f4a55cc1cb8a2f01.jpg",
+        "image_caption": [
+            "Figure 3: Learning curves for different discriminator regularizers when the other HPs are set to the best performing value across all tasks. The y-axis shows the average policy return normalized so that 0 corresponds to a random policy and 1 to the expert. See App. E for the HPs used. The plots shows the averages across 30 random seeds. Best seen in color. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            434,
+            823,
+            597
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "While it is not guaranteed that the performance is going to be good at all because we greedily choose the best performing value for each HP and there might be some unaccounted HP correlations, we find that the performance is very competitive (Fig. 3). Notice that we use the same HPs in all environments and the performance can be probably improved by varying some HPs between the environments, or at least between the two environment suites. ",
+        "bbox": [
+            174,
+            674,
+            825,
+            743
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We notice that on the four easiest tasks (HalfCheetah, Hopper, Walker2d, Ant), investigated discriminator regularizers provide no, or only minor performance improvements and excellent results can be achieved without them. On the tasks where regularization is beneficial, we usually see that there are multiple regularizers performing similarly well, with spectral normalization being one of the best regularizers in all tasks apart from the two tasks with human data where PUGAIL performs better. ",
+        "bbox": [
+            174,
+            750,
+            825,
+            819
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Regularizers-specific HPs. For GP, the target gradient norm of 1 is slightly better in most environments but the value of 0 is significantly better in hammer-human (Fig. 57), while the penalty strength of 1 performs best overall (Fig. 58). For dropout, it is important to apply it not only to hidden layers but also to inputs (Fig. 59) and the best results are obtained for $50 \\%$ input dropout and $7 5 \\%$ hidden activations dropout (Figs. 59, 60 and 67). For weight decay, the optimal decay coefficient in the AIL setup is much larger than the values typically used for Supervised Learning, the value $\\lambda = 1 0$ performs best in our experiments (Fig. 61). For Mixup, $\\alpha = 1$ outperforms the other values on almost all tested environments (Fig. 62). For PUGAIL, the unbounded version performs much better on the Adroit suite, while the bounded version is better on the Gym tasks (Fig. 63), and positive class prior of $\\eta = 0 . 7$ performs well on most tasks (Fig. 64). For the discriminator entropy bonus, the values around 0.03 performed best overall (Fig. 65). All experiments with spectral normalization enforce the Lipschitz constant of 1 for each weight matrix. ",
+        "bbox": [
+            174,
+            833,
+            825,
+            876
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            90,
+            825,
+            215
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "How to train efficiently? So far we have analysed how HPs affect the sample complexity of AIL algorithms. For the analysis of the HPs which influence sample complexity as well as the computational cost of running an algorithm see App. A. In particular, we describe there a simple code optimization relying on processing multiple batches at once which makes training $2 { - } 3 \\mathbf { x }$ faster in wall clock time without affecting the sample complexity (Fig. 5). ",
+        "bbox": [
+            174,
+            231,
+            825,
+            300
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 Are synthetic demonstrations a good proxy for human data? ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            319,
+            707,
+            337
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Summary of key findings Human demonstrations significantly differ from synthetic ones. Learning from human demonstrations benefits more from discriminator regularization and may work better with different discriminator inputs and reward functions than RL-generated demonstrations. ",
+        "bbox": [
+            174,
+            351,
+            826,
+            392
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Using a dataset of human demonstrations comes with a number of additional challenges. Compared to synthetic demonstrations, the human policy can be multi-modal in that for a given state different decisions might be chosen. A typical example occurs when the human demonstrator remains idle for some time (for example to think about the next action) before taking the actual relevant action: we have two modes in that state, the relevant action has a low probability while the idle action has a very high probability. The human policy might not be exactly markovian either. Those differences are significant enough that the conclusions on synthetic datasets might not hold anymore. ",
+        "bbox": [
+            174,
+            398,
+            825,
+            496
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this section, we focus on the Adroit door and hammer environments for which we run experiments with human as well as synthetic demonstrations. 10 Note that on top of the aforementioned challenges, the setup with the Adroit environments using human demonstrations exhibits a few additional specifics. The demonstrations were collected letting the human decide when the task is completed: said in a different way, the demonstrator is offered an additional action to jump directly to a terminal state and this action is not available to the agent imitating the expert. The end result is a dataset of demonstrations of variable length while the agent can only generate episodes consisting of exactly 200 transitions. Note that there was no time limit imposed on the demonstrator and some of the demonstrations have a length greater than 200 transitions. Getting to the exact same state distribution as the human expert may be impossible, and imitation learning algorithms may have to make some trade-offs. The additional specificity of that setup is that the reward of the environment is not exactly what the human demonstrator optimized. In the door environment, the reward provided by the environment is the highest when the door is fully opened while the human might abort the task slightly before getting the highest reward. However, overall, we consider the reward provided by the environment as a reasonable metric to assess the quality of the trained policies. Moreover, in the hammer environment, some demonstrations have a low return and we suspect those are not successful demonstrations.11 ",
+        "bbox": [
+            174,
+            503,
+            825,
+            736
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Discriminator regularization. When comparing the results for RL-generated (adroit-expert12) and human demonstrations (adroit-human) we can notice differences on a number of HPs related to the discriminator training. Human demonstrations benefit more from using discriminator regularizers (Fig. 56) and they also work better with smaller discriminator networks (Fig. 52) trained with lower learning rates (Fig. 66). The increased need for regularization suggest that it is easier to overfit to the idiosyncrasies of human demonstrations than to those of RL policies. ",
+        "bbox": [
+            173,
+            751,
+            825,
+            835
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/1900ff5a7e1b5a04b03832649b9fdf09dad1f97f7f92fd103e915552ff77f0aa.jpg",
+        "image_caption": [
+            "Figure 4: Comparison of discriminator inputs (a) and reward functions (b) for environments with human demonstrations. See Fig. 49 and Fig. 25 for the individual results in all environments. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            103,
+            820,
+            251
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Discriminator input. Fig. 4a shows the performance given the discriminator input depending on the demonstration source. For most tasks with RL-generated demonstrations, feeding actions as well as states improves the performance (Fig. 49). Yet, the opposite holds when human demonstrations are used. We suspect that it might be caused by the mentioned issue with demonstrations lengths which forces the policy to repeat a similar movement but with a different speed than the demonstrator. ",
+        "bbox": [
+            174,
+            320,
+            825,
+            390
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Reward functions. Finally, we look at how the relative performance of different reward functions depends on the demonstration source. Fig. 4b shows that for RL-generated demonstrations the best reward function is AIRL while $- \\ln ( 1 - D )$ performs better with human demonstrations. Under the assumption that the discriminator is optimal, these two reward functions correspond to the minimization of different divergences between the state (or state-action depending on the discriminator input) occupancy measures of the policy (denoted $\\pi$ ) and the expert (denoted $E$ ) . ",
+        "bbox": [
+            174,
+            412,
+            825,
+            496
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The reward function performing best with human demonstrations $( - \\ln ( 1 - D ) )$ corresponds to the minimization of the Jensen-Shannon divergence (proof in [14]). Interestingly, this divergence is symmetric $( D _ { \\mathrm { J S } } ( \\pi | | E ) = D _ { \\mathrm { J S } } ( E | | \\pi ) )$ and bounded $( 0 \\leq D _ { \\mathrm { J S } } ( \\pi | | E ) \\leq \\ln ( 2 ) )$ . For AIL, the symmetry means that it penalizes the policy for doing things the expert never does with exactly the same weight as for not doing some of the things the expert does while the boundedness means that the penalty for not visiting a single state is always finite. We suspect that this boundedness is beneficial for learning with human demonstrations because it may not be possible to exactly match the human distribution for the reasons explained earlier. ",
+        "bbox": [
+            174,
+            502,
+            825,
+            613
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In contrast to Jensen-Shannon, the $D _ { \\mathrm { K L } } ( \\pi | | E )$ divergence which is optimized by the AIRL reward (proof in [46]) is neither symmetric, nor bounded — it penalizes the policy much more heavily for doing the things the expert never does that for not doing all the things the expert does and the penalty for visiting a single state the expert never visits is infinite (assuming a perfect discriminator). ",
+        "bbox": [
+            174,
+            619,
+            825,
+            675
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "While it is hard to draw any general conclusions only from the two investigated environments for which we had access to human demonstrations, our analysis shows that the differences between synthetic and human-generated demonstrations can influence the relative performance of different algorithmic choices. This suggests that RL-generated data are not a good proxy for human demonstrations and that the very common practice of evaluating IL only with synthetic demonstrations may lead to algorithms which perform poorly in the more realistic scenarios with human demonstrations. ",
+        "bbox": [
+            174,
+            681,
+            825,
+            765
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 Related work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            791,
+            316,
+            809
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The most similar work to ours is probably [44] which compares the performance of different discriminator regularizers and concludes that gradient penalty is necessary for achieving good performance with off-policy AIL algorithms. In contrast to [44], which uses a single HP configuration, we run large-scale experiments with very wide HP sweeps which allows us to reach more robust conclusions. In particular, we are able to achieve excellent sample complexity on all the environments used in [44] without using any explicit discriminator regularizer (Fig. 3). ",
+        "bbox": [
+            174,
+            827,
+            825,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The methodology of our study is mostly based on [42] which analyzed the importance of different choices for on-policy actor-critic methods. Our work is also similar to other large-scale studies done in other fields of Deep Learning, e.g. model-based RL [38], GANs [34], NLP [50], disentangled representations [32] and convolution network architectures [51]. ",
+        "bbox": [
+            174,
+            90,
+            825,
+            147
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "7 Conclusions ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            166,
+            307,
+            183
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this empirical study, we investigate in depth many aspects of the AIL framework including discriminator architecture, training and regularization as well as many choices related to the agent training. Our key findings can be divided into three categories: (1) Corroborating prior work, e.g. for the underlying RL problem, off-policy algorithms are more sample efficient than on-policy ones; (2) Adding nuances to previous studies, e.g. while the regularization schemes encouraging Lipschitzness improve the performance, more classical regularizers like dropout or weight decay often perform on par; (3) Raising concerns: we observe a high discrepancy between the results for RL-generated and human data. We hope this study will be helpful to anyone using or designing AIL algorithms. ",
+        "bbox": [
+            173,
+            196,
+            825,
+            321
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Additionally we released the [1] unified AIL agent we implemented in JAX within the Acme framework as well as [2] the raw data of our experiment, along with [3] a Notebook that allows to load and study them. ",
+        "bbox": [
+            176,
+            328,
+            823,
+            371
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "[1] https://github.com/deepmind/acme/tree/master/acme/agents/jax/ail [2] https://storage.googleapis.com/what-matters-in-imitation-learning/data.json [3] https://storage.googleapis.com/what-matters-in-imitation-learning/analysis_ colab.ipynb ",
+        "bbox": [
+            174,
+            378,
+            784,
+            441
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgments ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            460,
+            328,
+            478
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We thank Kamyar Ghasemipour for the discussions related to the FAIRL reward function and Lucas Beyer for the feedback on an earlier version of the manuscript. ",
+        "bbox": [
+            171,
+            492,
+            823,
+            520
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            90,
+            267,
+            106
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "back-propagation”. In: Advances in neural information processing systems 1 (1988), pp. 177– 185.   \n[2] Dean A Pomerleau. “Efficient training of artificial neural networks for autonomous navigation”. In: Neural computation 3.1 (1991), pp. 88–97.   \n[3] Stuart Russell. “Learning agents for uncertain environments”. In: Conference on Computational learning theory. 1998.   \n[4] Stefan Schaal. “Is imitation learning the route to humanoid robots?” In: Trends in Cognitive Sciences 3.6 (1999), pp. 233–242. ISSN: 1364-6613. DOI: https : / / doi . org / 10 . 1016 / S1364- 6613(99)01327- 3. URL: http://www.sciencedirect.com/science/article/pii/ S1364661399013273.   \n[5] Andrew Y Ng, Stuart J Russell, et al. “Algorithms for inverse reinforcement learning.” In: Icml. Vol. 1. 2000, p. 2.   \n[6] Brian D Ziebart et al. “Maximum entropy inverse reinforcement learning.” In: Aaai. Vol. 8. Chicago, IL, USA. 2008, pp. 1433–1438.   \n[7] Brenna D Argall et al. “A survey of robot learning from demonstration”. In: Robotics and autonomous systems 57.5 (2009), pp. 469–483.   \n[8] Brian D Ziebart. “Modeling purposeful adaptive behavior with the principle of maximum causal entropy”. In: (2010).   \n[9] Ian J Goodfellow et al. “Generative adversarial networks”. In: arXiv preprint arXiv:1406.2661 (2014).   \n[10] Nitish Srivastava et al. “Dropout: a simple way to prevent neural networks from overfitting”. In: The journal of machine learning research 15.1 (2014), pp. 1929–1958.   \n[11] Diederik P. Kingma and Jimmy Ba. “Adam: A Method for Stochastic Optimization”. In: 3rd International Conference on Learning Representations, ICLR 2015, San Diego, CA, USA, May 7-9, 2015, Conference Track Proceedings. 2015. URL: http://arxiv.org/abs/1412.6980.   \n[12] John Schulman et al. “High-dimensional continuous control using generalized advantage estimation”. In: arXiv preprint arXiv:1506.02438 (2015).   \n[13] Greg Brockman et al. “Openai gym”. In: arXiv preprint arXiv:1606.01540 (2016).   \n[14] Jonathan Ho and Stefano Ermon. “Generative adversarial imitation learning”. In: arXiv preprint arXiv:1606.03476 (2016).   \n[15] David Silver et al. “Mastering the game of Go with deep neural networks and tree search”. In: nature 529.7587 (2016), p. 484.   \n[16] Marc G Bellemare, Will Dabney, and Rémi Munos. “A distributional perspective on reinforcement learning”. In: International Conference on Machine Learning. PMLR. 2017, pp. 449– 458.   \n[17] Justin Fu, Katie Luo, and Sergey Levine. “Learning robust rewards with adversarial inverse reinforcement learning”. In: arXiv preprint arXiv:1710.11248 (2017).   \n[18] Ishaan Gulrajani et al. “Improved training of wasserstein gans”. In: arXiv preprint arXiv:1704.00028 (2017).   \n[19] Riashat Islam et al. “Reproducibility of benchmarked deep reinforcement learning tasks for continuous control”. In: arXiv preprint arXiv:1708.04133 (2017).   \n[20] Ivaylo Popov et al. “Data-efficient deep reinforcement learning for dexterous manipulation”. In: arXiv preprint arXiv:1704.03073 (2017).   \n[21] Aravind Rajeswaran et al. “Learning complex dexterous manipulation with deep reinforcement learning and demonstrations”. In: arXiv preprint arXiv:1709.10087 (2017).   \n[22] John Schulman et al. “Proximal policy optimization algorithms”. In: arXiv preprint arXiv:1707.06347 (2017).   \n[23] Hongyi Zhang et al. “mixup: Beyond empirical risk minimization”. In: arXiv preprint arXiv:1710.09412 (2017).   \n[24] Gabriel Barth-Maron et al. “Distributed distributional deterministic policy gradients”. In: arXiv preprint arXiv:1804.08617 (2018).   \n[25] James Bradbury et al. JAX: composable transformations of Python $^ +$ NumPy programs. Version 0.2.5. 2018. URL: http://github.com/google/jax.   \n[26] Scott Fujimoto, Herke Hoof, and David Meger. “Addressing function approximation error in actor-critic methods”. In: International Conference on Machine Learning. PMLR. 2018, pp. 1587–1596.   \n[27] Tuomas Haarnoja et al. “Soft actor-critic algorithms and applications”. In: arXiv preprint arXiv:1812.05905 (2018).   \n[28] Tuomas Haarnoja et al. “Soft Actor-Critic: Off-Policy Maximum Entropy Deep Reinforcement Learning with a Stochastic Actor”. In: International Conference on Machine Learning. 2018, pp. 1861–1870.   \n[29] Peter Henderson et al. “Deep reinforcement learning that matters”. In: Thirty-Second AAAI Conference on Artificial Intelligence. 2018.   \n[30] Todd Hester et al. “Deep q-learning from demonstrations”. In: Proceedings of the AAAI Conference on Artificial Intelligence. Vol. 32. 1. 2018.   \n[31] Ilya Kostrikov et al. “Discriminator-actor-critic: Addressing sample inefficiency and reward bias in adversarial imitation learning”. In: arXiv preprint arXiv:1809.02925 (2018).   \n[32] Francesco Locatello et al. “Challenging common assumptions in the unsupervised learning of disentangled representations”. In: arXiv preprint arXiv:1811.12359 (2018).   \n[33] Ilya Loshchilov and Frank Hutter. “Fixing weight decay regularization in adam”. In: (2018).   \n[34] Mario Lucic et al. “Are gans created equal? a large-scale study”. In: Advances in neural information processing systems. 2018, pp. 700–709.   \n[35] Takeru Miyato et al. “Spectral normalization for generative adversarial networks”. In: arXiv preprint arXiv:1802.05957 (2018).   \n[36] George Tucker et al. “The mirage of action-dependent baselines in reinforcement learning”. In: arXiv preprint arXiv:1802.10031 (2018).   \n[37] Christopher Berner et al. “Dota 2 with large scale deep reinforcement learning”. In: arXiv preprint arXiv:1912.06680 (2019).   \n[38] Eric Langlois et al. “Benchmarking model-based reinforcement learning”. In: arXiv preprint arXiv:1907.02057 (2019).   \n[39] Tom Le Paine et al. “Making efficient use of demonstrations to solve hard exploration problems”. In: arXiv preprint arXiv:1909.01387 (2019).   \n[40] Oriol Vinyals et al. “Grandmaster level in StarCraft II using multi-agent reinforcement learning”. In: Nature 575.7782 (2019), pp. 350–354.   \n[41] Danfei $\\mathrm { X u }$ and Misha Denil. “Positive-unlabeled reward learning”. In: arXiv preprint arXiv:1911.00459 (2019).   \n[42] Marcin Andrychowicz et al. “What matters in on-policy reinforcement learning? a large-scale empirical study”. In: arXiv preprint arXiv:2006.05990 (2020).   \n[43] OpenAI: Marcin Andrychowicz et al. “Learning dexterous in-hand manipulation”. In: The International Journal of Robotics Research 39.1 (2020), pp. 3–20.   \n[44] Lionel Blondé, Pablo Strasser, and Alexandros Kalousis. “Lipschitzness Is All You Need To Tame Off-policy Generative Adversarial Imitation Learning”. In: arXiv preprint arXiv:2006.16785 (2020).   \n[45] Justin Fu et al. “D4rl: Datasets for deep data-driven reinforcement learning”. In: arXiv preprint arXiv:2004.07219 (2020).   \n[46] Seyed Kamyar Seyed Ghasemipour, Richard Zemel, and Shixiang Gu. “A divergence minimization perspective on imitation learning methods”. In: Conference on Robot Learning. PMLR. 2020, pp. 1259–1277.   \n[47] Jonathan Heek et al. Flax: A neural network library and ecosystem for JAX. Version 0.3.3. 2020. URL: http://github.com/google/flax.   \n[48] Matteo Hessel et al. Optax: composable gradient transformation and optimisation, in JAX! Version 0.0.1. 2020. URL: http://github.com/deepmind/optax.   \n[49] Matt Hoffman et al. “Acme: A research framework for distributed reinforcement learning”. In: arXiv preprint arXiv:2006.00979 (2020).   \n[50] Jared Kaplan et al. “Scaling laws for neural language models”. In: arXiv preprint arXiv:2001.08361 (2020).   \n[51] Ilija Radosavovic et al. “Designing Network Design Spaces”. In: arXiv preprint arXiv:2003.13678 (2020). ",
+        "bbox": [
+            171,
+            130,
+            828,
+            911
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            97,
+            828,
+            914
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[52] Annie Chen et al. “Batch exploration with examples for scalable robotic reinforcement learning”. In: IEEE Robotics and Automation Letters (2021). ",
+        "bbox": [
+            171,
+            90,
+            825,
+            119
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Checklist ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            138,
+            254,
+            155
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "1. For all authors... ",
+        "bbox": [
+            214,
+            165,
+            341,
+            180
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   \n(b) Did you describe the limitations of your work? [Yes]   \n(c) Did you discuss any potential negative societal impacts of your work? [N/A] We study general purpose imitation algorithms which are not related to any particular application.   \n(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes] ",
+        "bbox": [
+            238,
+            185,
+            825,
+            290
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "2. If you are including theoretical results... ",
+        "bbox": [
+            214,
+            294,
+            493,
+            309
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you state the full set of assumptions of all theoretical results? [N/A] (b) Did you include complete proofs of all theoretical results? [N/A] ",
+        "bbox": [
+            238,
+            313,
+            738,
+            343
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "3. If you ran experiments... ",
+        "bbox": [
+            212,
+            348,
+            393,
+            362
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [No]   \n(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes]   \n(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [Yes]   \n(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [No] ",
+        "bbox": [
+            238,
+            366,
+            825,
+            484
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... ",
+        "bbox": [
+            218,
+            489,
+            823,
+            505
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) If your work uses existing assets, did you cite the creators? [Yes]   \n(b) Did you mention the license of the assets? [No] D4RL demonstrations are available under Apache License 2.0   \n(c) Did you include any new assets either in the supplemental material or as a URL? [No]   \n(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A]   \n(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A] ",
+        "bbox": [
+            238,
+            507,
+            823,
+            628
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "5. If you used crowdsourcing or conducted research with human subjects... ",
+        "bbox": [
+            214,
+            633,
+            705,
+            648
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   \n(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   \n(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A] ",
+        "bbox": [
+            238,
+            651,
+            825,
+            741
+        ],
+        "page_idx": 12
+    }
+]

parse/train/HbZTcIuiMAG/HbZTcIuiMAG.md

@@ -0,0 +1,481 @@
+# FUSION 360 GALLERY: A DATASET AND ENVIRONMENT FOR PROGRAMMATIC CAD RECONSTRUCTION
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Parametric computer-aided design (CAD) is a standard paradigm used for the design of manufactured objects. CAD designers perform modeling operations, such as sketch and extrude, to form a construction sequence that makes up a final design. Despite the pervasiveness of parametric CAD and growing interest from the research community, a dataset of human designed 3D CAD construction sequences has not been available to-date. In this paper we present the Fusion 360 Gallery reconstruction dataset and environment for learning CAD reconstruction. We provide a dataset of 8,625 designs, comprising sequential sketch and extrude modeling operations, together with a complementary environment called the $F u$ - sion $3 6 0 G y m$ , to assist with performing CAD reconstruction. We outline a standard CAD reconstruction task, together with evaluation metrics, and present results from a novel method using neurally guided search to recover a construction sequence from a target geometry.
+
+# 1 INTRODUCTION
+
+The manufactured objects that surround us in everyday life are created in computer-aided design (CAD) software using common modeling operations such as sketch and extrude. With just these two modeling operations, a highly expressive range of 3D designs can be created (Figure 1). Parametric CAD files contain construction sequence information that is critical for documenting design intent, maintaining editablity, and downstream simulation and manufacturing. Despite the value of this information, it is often lost due to data translation or error and must be reverse engineered from geometry or even raw 3D scan data. The task of reconstructing CAD operations from geometry has been pursued for over 40 years (Shah et al., 2001) and is available in commercial CAD software using heuristic approaches (Autodesk, 2012; Dassault, 2019). Recent advances in neural networks for 3D shape generation has spurred new interest in CAD reconstruction, due to the potential to generalize better and further automate this challenging problem. However, learning-based approaches to CAD reconstruction have not yet had access to a human-designed dataset of 3D CAD construction sequences, instead relying on synthetic data for both training and testing purposes, e.g. Li et al. (2020). The absence of real world data has limited work on CAD reconstruction using common sketch and extrude modeling operations. Instead a focus has been on reconstruction from simple geometric primitives (Sharma et al., 2017; Tian et al., 2019; Ellis et al., 2019) that lack the rich parametric sketches commonly used in mechanical CAD (e.g. Figure 2). As there is no existing learning-based approach to reconstruct sketch and extrude sequences, we take a first step towards this goal by introducing data, a supporting software environment, and a novel action representation for reconstructing sketch and extrude designs.
+
+![](images/e72951873fd6f2b5bef65ad487808031e05d7ef050c35a63e1e2104968b1b2d5.jpg)  
+Figure 1: Top: A subset of designs containing 3D CAD construction sequences from the Fusion $3 6 0$ Gallery reconstruction dataset. Bottom: An example construction sequence using sketch and extrude modeling operations.
+
+In this paper we present the Fusion 360 Gallery reconstruction dataset and environment for learning CAD reconstruction. The dataset contains 8,625 designs created by users of Autodesk Fusion 360 using a simple subset of CAD modeling operations: sketch and extrude. To the best of our knowledge this dataset is the first to provide human designed 3D CAD construction sequence data for use with machine learning. To support research with the dataset we provide an environment called the Fusion 360 Gym for working with CAD reconstruction. A key motivation of this work is to provide insights into the process of how people design objects. Furthermore, our goal is to provide a universal benchmark for research and evaluation of learning-based CAD reconstruction algorithms, bridging the gap between the computer graphics and machine learning community. To this end we describe a standard CAD reconstruction task and associated evaluation metrics with respect to the ground truth construction sequence. We also introduce a novel action representation for CAD reconstruction of sketch and extrude designs using neurally guided search. This search employs a policy, trained using imitation learning, consisting of a graph neural network encoding of CAD geometry.
+
+This paper makes the following contributions:
+
+• We present the Fusion 360 Gallery reconstruction dataset containing construction sequence information for 8,625 human-designed sketch and extrude CAD models.   
+• We introduce an environment called the Fusion 360 Gym, standardizing the CAD reconstruction task in a Markov Decision Process formulation.   
+• We introduce a novel action representation to enable neurally guided CAD reconstruction trained on real world construction sequences for the first time.
+
+# 2 RELATED WORK
+
+CAD Datasets Existing 3D CAD datasets have largely focused on providing mesh geometry (Chang et al., 2015; Wu et al., 2015; Zhou & Jacobson, 2016; Mo et al., 2019b; Kim et al., 2020). However, the de facto standard for parametric CAD is the boundary representation (B-Rep) format, containing valuable analytic representations of surfaces and curves suitable for high level control of 3D shapes. B-Reps are collections of trimmed parametric surfaces along with topological information which describes adjacency relationships and the ordering of elements such as faces, loops, edges, and vertices (Weiler, 1986). B-Rep datasets have recently been made available with both human-designed (Koch et al., 2019) and synthetic data (Zhang et al., 2018; Jayaraman et al., 2020; Starly, 2020). Missing from these datasets is construction sequence information. We believe it is critical to understand not only what is designed, but how that design came about.
+
+Parametric CAD files contain valuable information on the construction history of a design. Schulz et al. (2014) provide a standard collection of human designs with full parametric history, albeit a limited set of 67 designs in a proprietary format. SketchGraphs (Seff et al., 2020) constrains the broad area of parametric CAD by focusing on the underlying 2D engineering sketches, including sketch construction sequences. In the absence of 3D human design data, learning-based approaches have instead leveraged synthetic CAD construction sequences (Sharma et al., 2017; Li et al., 2020). The dataset presented in this paper is, to the best of our knowledge, the first to provide humandesigned 3D CAD construction sequence information suitable for use with machine learning.
+
+CAD Reconstruction The task of CAD reconstruction involves recovering the sequence of modeling operations used to construct a CAD model from geometry input, such as B-reps, triangle meshes, or point clouds. Despite extensive prior work (Shah et al., 2001), CAD reconstruction remains a challenging problem as it requires deductions on both continuous parameters (e.g., extracting the dimensions of primitives) and discrete operations (e.g., choosing a proper operation for the next step), leading to a mixed combinatorial search space. To recover the sequence of operations, traditional methods typically run global search methods (e.g., evolutionary algorithms as in Hamza & Saitou (2004), Weiss (2009), Friedrich et al. (2019), and Fayolle & Pasko (2016)) with heuristic rules to prune the search space (Shapiro & Vossler, 1993; Buchele, 2000; Buchele & Roles, 2001; Buchele & Crawford, 2003). Heuristic approaches are also available in a number of commercial software tools, often as a user-guided semi-automatic system (Autodesk, 2012; Dassault, 2019) to aid with file conversion between CAD systems. These traditional algorithms operate by removing faces from the B-rep body and reapplying them as parametric modeling operations. This strategy can recover the later modeling operations, but fail to completely rebuild the construction sequence from the first step. We instead tackle the task of recovering the entire construction sequence from the first extrusion. Another approach is using program synthesis (Du et al., 2018; Nandi et al., 2017; 2018; 2020) to infer CAD programs written in domain specific languages from given shapes. CAD reconstruction is also related to the inverse procedural modeling problem (Talton et al., 2011; Stava et al., 2014; Vanegas et al., 2012), which attempts to reverse-engineer procedures that can faithfully match a given target. Inverse procedural modeling methods typically work with synthetic data, while our paper tackles tasks on real CAD models and modeling operations.
+
+![](images/5076c117e7b33f98dc4b83e2774ab5a4312bd79d095ef2bc99d3ea777fe32970.jpg)  
+Figure 2: An example design sequence from the Fusion 360 Gallery reconstruction dataset. Sketch profiles are sequentially extruded to join (Extrude 1, Extrude 2) or cut (Extrude 3) geometry using Boolean operations. The colored areas show the sketch profiles that partake in each extrusion.
+
+Compared to the rule-based or grammar-based methods above, learning-based approaches can potentially learn the types of rules that are typically hard-coded, automate scenarios that require userinput, and generalize when confronted with unfamiliar geometry. One of the earliest such works is CSGNet (Sharma et al., 2017), which trains a neural network to infer the sequence of Constructive Solid Geometry (CSG) operations based on visual inputs. More recent works along this line of research include Ellis et al. (2019), Tian et al. (2019), and Kania et al. (2020). Typically associated with these methods are a customized, domain specific language (e.g., CSG) that parameterizes the space of geometry, some heuristic rules that limit the search space, and a neural network generative model (Zou et al., 2017; Mo et al., $2 0 1 9 \mathrm { a }$ ; Chen et al., 2020; Jones et al., 2020). Lin et al. (2020) reconstruct input shapes with a dual action representation that first positions cuboids and then edits edge-loops for refinement. Although editing edge-loops of cuboids may be a suitable modeling operation in artistic design, it is not as expressive or precise as the sketch and extrude operations used in real mechanical components. Additionally, Lin et al. (2020) chooses to train and evaluate their network on synthetic data due to the lack of a benchmark dataset of CAD construction sequences, a space that our work aims to fill. Our approach is, to the best of our knowledge, the first to apply a learning-based method to reconstruction using common sketch and extrude CAD modeling operations from real human designs.
+
+# 3 FUSION 360 GALLERY RECONSTRUCTION DATASET
+
+The Fusion 360 Gallery reconstruction dataset1 is produced from designs submitted by users of the CAD software Autodesk Fusion 360. The dataset contains CAD construction sequence information from a subset of sketch and extrude designs. We intentionally limit the data to the sketch and extrude modeling operations to reduce the complexity of the CAD reconstruction task. Figure 1 shows a random sampling of the designs in the dataset. Each design is provided in three different representations: B-Rep, mesh, and construction sequence JSON text format. An official 80:20 traintest split is provided with 6,900 and 1,725 designs respectively. We now briefly outline the sketch and extrude modeling operations and provide additional details in Section A.1 of the appendix.
+
+![](images/31a47c440fdca81881d3f6ff1a54c9e1b36c179ecd024d241da0bf2472400d85.jpg)  
+Figure 3: The Fusion 360 Gym interacts with an agent in a sequential decision making scenario (left) with the state containing geometries represented as face adjacency graphs (right).
+
+Sketch Unlike free-form sketches, sketches in CAD are composed of 2D geometric primitives (lines, circles, splines etc.), associated dimensions (distance, diameter, angle etc.) and constraints (symmetry, tangent, parallel etc.). Sketch geometry is represented by points, that create curves, that in turn form loops within profiles. The intersection of curves, as the user draws, automatically creates closed loops and profiles that are serialized as both raw curves and trimmed profiles. Sketch profiles form the basis for 3D extrusion as shown in (Figure 2).
+
+Extrude An extrude operation takes one or more sketch profiles and extrudes them from 2D into a 3D B-Rep body. A distance parameter defines how far the profile is extruded. A notable feature of extrude operations in Fusion 360 is the ability to perform Boolean operations in the same step. As a user extrudes a sketch profile, they choose to create a new body, join, cut, or intersect with other bodies in the design (Figure 2). Additional extrude options are available such as two-sided extrude, symmetrical extrude, and tapered extrude. The combination of expressive sketches and extrude operations with built in Boolean capability enables a wide variety of designs to be constructed.
+
+# 4 FUSION 360 GYM
+
+Together with the dataset we provide an open source environment, called the Fusion 360 Gym, for standardizing the CAD reconstruction task. The Fusion 360 Gym wraps the underlying Fusion 360 Python API (Autodesk, 2014) and serves as the environment that interacts with an intelligent agent for the task of CAD reconstruction (Figure 3). Specifically, the Fusion 360 Gym formalizes the following Markov Decision Process:
+
+• state: Contains the current geometry, and optionally, the target geometry to be reconstructed. We use a B-Rep face-adjacency graph as our state representation.   
+• action: A modeling operation that allows the agent to modify the current geometry. We consider two action representations: sketch extrusion and face extrusion.   
+• transition: Fusion 360 Gym implements the transition function that applies the modeling operation to the current geometry.   
+reward: The user can define custom reward functions depending on the task. We provide intersection over union (IoU) as one measure to compare the current and target geometry.
+
+# 4.1 STATE REPRESENTATION
+
+In order for an agent to successfully reconstruct the target geometry, it is important that we have a suitable state representation. In Fusion 360 Gym, we use a similar encoding scheme to Jayaraman et al. (2020) and represent the current and target geometry with a B-Rep face-adjacency graph (Ansaldi et al., 1985), illustrated in Figure 3, right. Crucial to this encoding are the geometric features of the elements, such as point-locations, and topological features specifying how these elements are connected to each other. Specifically, the vertices of the face-adjacency graph represent B-Rep faces (trimmed parametric surfaces) in the design, with graph vertex features representing the size, orientation, and curvature of the faces. The edges of the face-adjacency graph represents B-Rep edges in the design, that connect the adjacent B-Rep faces to each other.
+
+![](images/24149f06a3173cfa44707d2d87c68addd6f0c5e7f07aaef5d7d75972c0aaf33d.jpg)  
+Figure 4: Action representations supported by the Fusion 360 Gym include low-level sketch extrusion (top) and simplified face extrusion (bottom).
+
+# 4.2 ACTION REPRESENTATION
+
+In the Fusion 360 Gym we support two action representations encompassing different modeling operations: sketch extrusion and face extrusion.
+
+Sketch Extrusion In sketch extrusion, the agent must first select a sketch plane, draw on this plane using a sequence of curve primitives, such as lines and arcs, to form closed loop profiles. The agent then selects a profile to extrude a given distance and direction (Figure 4, top). Using this representation it is possible to construct novel geometries by generating the underlying sketch primitives and extruding them by an arbitrary amount. Although all designs in the Fusion 360 Gallery reconstruction dataset can be constructed using sketch extrusion, in practice this is challenging. Benko et al. (2002) show that to generate sketches suitable for mechanical engineering parts, the curve primitives often need to be constructed alongside a set of constraints which enforce regularities and symmetries in the design. Although the construction of the constraint graphs is feasible using techniques like the one shown by Liao et al. (2019), enforcing the constraints requires a complex interaction between the machine learning algorithm and a suitable geometric constraint solver, greatly increasing the algorithm complexity. We alleviate this problem by introducing a simplified action representation, called face extrusion, that is well suited to learning-based approaches.
+
+Face Extrusion In face extrusion, a face from the target design is used as the extrusion profile rather than a sketch profile (Figure 4, bottom). This is possible because the target design is known in advance during reconstruction. An action $a$ in this scheme is a triple $\{ \mathrm { f a c e } _ { s t a r t } , \mathrm { f a c e } _ { e n d } , \mathrm { o p } \}$ where the start and end faces are parallel faces referenced from the target geometry, and the operation type is one of the following: new body, join, cut, intersect. Target constrained reconstruction using face extrusion has the benefit of narrowly scoping the prediction problem with shorter action sequences and simpler actions. Conversely, not all geometries can be reconstructed with this simplified strategy due to insufficient information in the target, e.g., Extrude 3 in Figure 2 cuts across the entire design without leaving a start or end face. Of the design sequences in the reconstruction dataset, $5 9 . 2 \%$ can be directly converted to a face extrusion sequence. We estimate that approximately $80 \%$ of designs in our dataset can be reconstructed by finding alternative construction sequences.
+
+# 4.3 SYNTHETIC DATA GENERATION
+
+The Fusion 360 Gym supports generation of semi-synthetic data by taking existing designs and modifying or recombining them. For instance, we can randomly perturb the sketches and the extrusion distances, and even ‘graft’ sketches from one design onto another. We also support distribution matching of parameters, such as the number of faces, to ensure that synthetic designs match a human-designed dataset distribution. Learning-based systems can leverage semi-synthetic data to expand the number of samples in the Fusion 360 Gallery reconstruction dataset. We provide examples of synthetic data and commands for the Fusion 360 Gym in Section A.2 of the appendix.
+
+![](images/760ce9df3d32fe7919959a2a4324dadcb4159f6eb0f08c07c2f7a56895020208.jpg)  
+Figure 5: Given a state comprising the target geometry $G _ { t }$ and current geometry $G _ { c }$ , the agent uses a message passing network (MPN) to predict an action as a face extrusion modeling operation.
+
+# 5 CAD RECONSTRUCTION
+
+# 5.1 TASK
+
+The goal of CAD reconstruction is to recover the sequence of modeling operations used to construct a CAD model with only the geometry as input. This task can be specified using different input geometry representations, including B-Rep, mesh, or point cloud, with progressively lower fidelity. Each representation presents a realistic scenario where parametric CAD information is absent and needs to be recovered. Given a target geometry $G _ { t }$ , we wish to find a sequence of CAD modeling operations (actions) $\mathcal { A } = \{ a _ { 0 } , a _ { 1 } , \cdot \cdot \cdot \}$ that generates an output geometry $G$ , such that every point in space is in its interior, if and only if, it is also in the interior of $G _ { t }$ .
+
+Evaluation Metrics We prescribe three evaluation metrics, IoU, exact reconstruction, and conciseness. IoU measures the intersection over union of $G$ and $G _ { t }$ : $\mathsf { i o u } ( G , G _ { t } ) = | G \cap G _ { t } | / | G \cup G _ { t } |$ . Exact reconstruction measures whether $\mathsf { i o u } ( G , G _ { t } ) = 1$ . As multiple correct sequences of CAD modeling operations exist, a proposed reconstruction sequence $\mathcal { A }$ need not match the ground truth sequence $\hat { \mathcal { A } } _ { t }$ provided an exact reconstruction is found. To measure the quality of exact reconstructions we consider the conciseness of the construction sequence. Let conciseness $( \boldsymbol { \mathcal { A } } , \hat { \boldsymbol { \mathcal { A } } } _ { t } ) =$ $| \mathcal { A } | / | \hat { \mathcal { A } } _ { t } |$ , where a score $\leq 1$ indicates the agent found an exact reconstruction with equal or fewer steps than the ground truth, and a score $> 1$ indicates more inefficient exact reconstructions.
+
+# 5.2 METHOD
+
+We now present a method for CAD reconstruction using neurally-guided search (Ellis et al., 2019; Kalyan et al., 2018; Tang et al., 2019; Devlin et al., 2017) from $B$ -Rep input using face extrusion modeling operations. Rather than discovering a sequence of construction by exploration, the agent is trained to match known reconstruction sequences present in the training set using imitation learning. We leverage search at inference time to recover the given target geometry.
+
+Imitation Learning To perform imitation learning, we leverage the fact that we have the ground truth sequence of modeling operations (actions) $\hat { \mathcal { A } } _ { t } = \{ \hat { a } _ { t , 0 } \cdot \cdot \cdot \hat { a } _ { t , n - 1 } \}$ for each design $G _ { t }$ in the dataset. We feed the ground truth action sequence $\hat { A } _ { t }$ into the Fusion 360 Gym, starting from the empty geometry $G _ { 0 }$ , and output a sequence of partial constructions $G _ { t , 1 } \cdots G _ { t , n }$ where $G _ { t , n } = G _ { t }$ . We then collect the supervised dataset ${ \mathcal { D } } = \{ ( G _ { 0 } , G _ { t } ) \to { \hat { a } } _ { t , 0 } , ( G _ { t , 1 } , G _ { t } ) \to { \hat { a } } _ { t , 1 } \cdot \cdot \cdot \}$ and train a supervised agent $\pi _ { \theta }$ that takes the pair of current-target constructions $\left( G _ { c } , G _ { t } \right)$ to a modeling operation action $a _ { c }$ , which would transform the current geometry closer to the target. Formally, we optimize the expected log-likelihood of correct actions under the data distribution:
+
+$$
+\begin{array} { r } { E _ { ( G _ { c } , G _ { t } ) \sim \mathcal { D } } \biggl [ \log \pi _ { \theta } \Bigl ( \hat { a } _ { c } | \bigl ( G _ { c } , G _ { t } \bigr ) \Bigr ) \biggr ] } \end{array}
+$$
+
+Agent The agent takes a pair of geometries $\left( G _ { c } , G _ { t } \right)$ as state, and outputs the corresponding faceextrusion action $a = \{ \mathrm { f a c e } _ { s t a r t } , \mathrm { f a c e } _ { e n d } , \mathrm { o p } \}$ (Figure 5). The two geometries $G _ { c } , G _ { t }$ are given using a face-adjacency graph similar to Jayaraman et al. (2020), where the graph vertexes represent the faces of the geometry, with vertex features calculated from each face: $1 0 \times 1 0$ grid of 3D points, normals, and trimming mask, in addition to the face surface type. The edges define connectivity of adjacent faces. Inputs are encoded using two separate message passing networks (MPN) aggregating messages along the edges of the graph. The encoded vectors representing the current geometry are summed together ( $h _ { c }$ in Figure 5), and concatenated with the encoded vertexes of the target geometry $( h _ { t } ^ { 0 } \cdots h _ { t } ^ { 5 } )$ . The concatenated vectors are used to output the action using a multi-layer perceptron (MLP), with the end face conditioned on the vertex embedding of the predicted start face.
+
+Search Given a neural agent $\pi _ { \boldsymbol { \theta } } ( \boldsymbol { a } | ( G _ { c } , G _ { t } ) )$ capable of furthering a current geometry toward the target geometry, we can amplify its performance at test time using search. Here we report the result of the most basic of search strategies, random rollout, and provide results from additional search strategies in Section A.3 of the appendix. We let the agent interact with the environment by sampling a sequence of actions according to $\pi _ { \theta }$ up to a fixed rollout length of $\begin{array} { r } { \operatorname* { m a x } ( \frac { f _ { p } } { 2 } , 2 ) } \end{array}$ , where $f _ { p }$ is the number of planar faces in $G _ { t }$ . If the agent is successful at reconstructing the target, we stop. Otherwise, we repeat the process until we exhaust a global search budget.
+
+# 5.3 RESULTS
+
+We now present results on CAD reconstruction using the test set of the Fusion 360 Gallery reconstruction dataset. We seek to understand 1) how state-of-the-art baseline networks perform on the CAD reconstruction task, 2) how synthetic data performs compared to human designs. In each experiment we use different agents to reconstruct a target design, while holding the search strategy constant. For a target design $G _ { t }$ , each agent uses the random rollout search algorithm and attempts reconstruction over multiple rollouts. Each time the agent takes an action during search (a search step), we track the best IoU the agent has discovered so far, and whether exact reconstruction is achieved. We cap the total search budget to 100 steps.
+
+Baseline Comparison We evaluate five different agents to understand how state-of-the-art baseline networks perform on the CAD reconstruction task. The rand agent uniformly samples from the available actions to serve as a naive baseline without any learning. mlp is a simple MLP agent that does not take advantage of shape topology. gcn, gin, and gat are MPN agents that use a Graph Convolution Network (Kipf & Welling, 2016), Graph Isomorphism Network (Xu et al., 2018), and Graph Attention Network (Velickovi ˇ c et al., 2017) respectively. We use two MPN layers for all ´ comparisons, with standard layer settings as described in the appendix. We report the evaluation metrics of each agent as a function of the number of steps in Figure 6. We detail the exact results at step 20 and 100 in Table 1. Step 20 represents the point where it is possible to perform exact reconstructions for all designs in the test set. We also detail the conciseness of the recovered sequence for exact reconstructions. We note that all neurally guided agents outperform the random agent baseline. The topology information available with a MPN is found to improve reconstruction performance. The gat and gcn agents show the best performance but fall well short of exact reconstruction on all designs in the test set, demonstrating that the CAD reconstruction task is non-trivial and an open problem for future research.
+
+![](images/451e40de541456287ed0dc9af535f9d937ad44c9cfde42b743028cddd06e31de.jpg)  
+Figure 6: Reconstruction results over 100 search steps using random rollouts with different agents. For exact reconstructions, 0.8 is the estimated upper limit of the face extrusion action representation.
+
+Table 1: Reconstruction results for IoU and exact reconstruction at 20 and 100 search steps using random rollouts with different agents. Lower values are better for conciseness.   
+
+<table><tr><td>Agent</td><td colspan="2">IoU</td><td colspan="2">Exact Reconstruction %</td><td>Conciseness</td><td> # Parameters</td></tr><tr><td></td><td>20 Steps</td><td>100 Steps</td><td>20 Steps</td><td>100 Steps</td><td></td><td></td></tr><tr><td>gat</td><td>0.8742</td><td>0.9128</td><td>0.6191</td><td>0.6742</td><td>1.0206</td><td>3.03M</td></tr><tr><td>gcn</td><td>0.8644</td><td>0.9042</td><td>0.6232</td><td>0.6754</td><td>1.0168</td><td>3.02M</td></tr><tr><td>gin</td><td>0.8346</td><td>0.8761</td><td>0.5901</td><td>0.6301</td><td>1.0042</td><td>3.62M</td></tr><tr><td>mlp</td><td>0.8274</td><td>0.8596</td><td>0.5658</td><td>0.5965</td><td>0.9763</td><td>2.24M</td></tr><tr><td>rand</td><td>0.6840</td><td>0.8386</td><td>0.4157</td><td>0.5380</td><td>1.2824</td><td>:</td></tr></table>
+
+Synthetic Data Performance We evaluate four gcn agents trained on different data sources to understand how synthetic data performs compared to human design data. real is trained on the human design training set. syn is trained on synthetic data from procedurally generated sketches of rectangles and circles extruded randomly (Figure 8, left). semi-syn is trained on semi-synthetic designs that use existing sketches in the training set with two or more extrude operations to match the distribution of the number of faces in the training set (Figure 8, right). aug is trained on the human design training set mixed with additional semi-synthetic data. We hold the training data quantity constant across agents, with the exception of the aug agent that contains a larger quantity from two sources. All agents are evaluated on the human design test set.
+
+Figure 7 shows that training on human design data offers a significant advantage over synthetic and semi-synthetic data. For the aug agent reconstruction performance is aided early on by data augmentation. This is likely due to semi-synthetic designs with 1 or 2 extrusions appearing similar to human designs. Conversely, semi-synthetic designs with multiple randomly applied extrusions appear less and less similar to human design. This difference in distribution between human and synthetic designs becomes more prevalent as search progresses and adversely affects performance.
+
+Qualitative Results Figure 9 shows ground truth construction sequences compared with other agents using random search. The rollout with the highest IoU is shown with the IoU score and total search steps taken. Steps that don’t change the geometry or occur after the highest IoU are omitted from the visualization.
+
+![](images/0e2fa3c57b5fa20cfb91611bb6060b20666e8eb4b1b6b1b3dcf9483de2d702fd.jpg)  
+Figure 7: Reconstruction results over 100 search steps using random rollouts and gcn agents trained on human-designed data (real), a mixture of human-designed and semi-synthetic data (aug), semisynthetic data (semi-syn), and synthetic data (syn).
+
+![](images/3061e61811633bca31264357e9f6b8b615425fee9d0ec0cce5d1df7c414071a5.jpg)  
+Figure 8: Example synthetic (left) and semi-synthetic data (right).
+
+Discussion For practical application of CAD reconstruction it is necessary to have an exact reconstruction where all details of a design are reconstructed in a concise way. It is notable that incorrect reconstructions can score well with the IoU metric, but omit important design details. We therefore suggest IoU should be a secondary metric, with future work focusing on improving exact reconstruction performance with concise construction sequences. Conciseness should always be considered alongside exact reconstruction performance as naive approaches that only reconstruct short sequences can achieve good conciseness scores.
+
+# 6 CONCLUSION AND FUTURE DIRECTIONS
+
+In this paper we presented the Fusion 360 Gallery reconstruction dataset and environment for learning CAD reconstruction from sequential 3D CAD data. We outlined a standard CAD reconstruction task, together with evaluation metrics, and presented results from a neurally guided search approach. We envision a number of future directions that could leverage the reconstruction dataset: new representations for sequential geometry capable of performing CAD reconstruction and generation from B-Rep, mesh, point cloud, or image data; reinforcement learning approaches that mimic and improvise sequential modeling operations; and sketch and constraint synthesis from 3D geometry or images. Finally, beyond the simplified design space of sketch and extrude lies the full breadth of rich sequential CAD modeling operations.
+
+![](images/1605e86419e527e3432b54ea385ecadaa1c6c9d6e8531a1b7e62ce46c37f9dc8.jpg)  
+Figure 9: Qualitative construction sequence results comparing the ground truth (gt) to reconstructions using different agents with random search.
+
+# REFERENCES
+
+Silvia Ansaldi, Leila De Floriani, and Bianca Falcidieno. Geometric modeling of solid objects by using a face adjacency graph representation. ACM SIGGRAPH Computer Graphics, 19(3):131– 139, 1985.
+
+Autodesk. Inventor Feature Recognition, 2012. URL https://apps.autodesk.com/ INVNTOR/en/Detail/Index?id $\underline { { \underline { { \mathbf { \Pi } } } } } =$ 9172877436288348979.
+
+Autodesk. Fusion 360 API, 2014. URL http://help.autodesk.com/view/fusion360/ ENU/?guid $\underline { { \underline { { \mathbf { \Pi } } } } } =$ GUID-7B5A90C8-E94C-48DA-B16B-430729B734DC.
+
+Pal Benko, Geza Kos, Pál Benko, Laszlo Andor, Géza Kós, Tamas Varady, László Andor, and Ralph ˝ Martin. Constrained fitting in reverse engineering, 2002.
+
+Suzanne F Buchele and Richard H Crawford. Three-dimensional halfspace constructive solid geometry tree construction from implicit boundary representations. In Proceedings of the eighth ACM symposium on Solid modeling and applications, pp. 135–144, 2003.
+
+Suzanne F Buchele and Angela C Roles. Binary space partitioning tree and constructive solid geometry representations for objects bounded by curved surfaces. In CCCG, pp. 49–52. Citeseer, 2001.
+
+Suzanne Fox Buchele. Three-dimensional binary space partitioning tree and constructive solid geometry tree construction from algebraic boundary representations. 2000.
+
+Angel X Chang, Thomas Funkhouser, Leonidas Guibas, Pat Hanrahan, Qixing Huang, Zimo Li, Silvio Savarese, Manolis Savva, Shuran Song, Hao Su, et al. Shapenet: An information-rich 3d model repository. arXiv preprint arXiv:1512.03012, 2015.
+
+Zhiqin Chen, Andrea Tagliasacchi, and Hao Zhang. Bsp-net: Generating compact meshes via binary space partitioning. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 45–54, 2020.
+
+Dassault. Solidworks FeatureWorks, 2019. URL https://help.solidworks.com/2019/ english/SolidWorks/fworks/c_Overview_of_FeatureWorks.htm.
+
+Jacob Devlin, Jonathan Uesato, Surya Bhupatiraju, Rishabh Singh, Abdel-rahman Mohamed, and Pushmeet Kohli. Robustfill: Neural program learning under noisy i/o. arXiv preprint arXiv:1703.07469, 2017.
+
+Tao Du, Jeevana Priya Inala, Yewen Pu, Andrew Spielberg, Adriana Schulz, Daniela Rus, Armando Solar-Lezama, and Wojciech Matusik. Inversecsg: Automatic conversion of 3d models to csg trees. ACM Transactions on Graphics (TOG), 37(6):1–16, 2018.
+
+Kevin Ellis, Maxwell Nye, Yewen Pu, Felix Sosa, Josh Tenenbaum, and Armando Solar-Lezama. Write, execute, assess: Program synthesis with a repl. In Advances in Neural Information Processing Systems, pp. 9169–9178, 2019.
+
+Pierre-Alain Fayolle and Alexander Pasko. An evolutionary approach to the extraction of object construction trees from 3d point clouds. Computer-Aided Design, 74:1–17, 2016.
+
+Markus Friedrich, Pierre-Alain Fayolle, Thomas Gabor, and Claudia Linnhoff-Popien. Optimizing evolutionary csg tree extraction. In Proceedings of the Genetic and Evolutionary Computation Conference, pp. 1183–1191, 2019.
+
+Karim Hamza and Kazuhiro Saitou. Optimization of constructive solid geometry via a tree-based multi-objective genetic algorithm. In Genetic and Evolutionary Computation Conference, pp. 981–992. Springer, 2004.
+
+Pradeep Kumar Jayaraman, Aditya Sanghi, Joseph Lambourne, Thomas Davies, Hooman Shayani, and Nigel Morris. Uv-net: Learning from curve-networks and solids. arXiv preprint arXiv:2006.10211, 2020.
+
+R. Kenny Jones, Theresa Barton, Xianghao Xu, Kai Wang, Ellen Jiang, Paul Guerrero, Niloy Mitra, and Daniel Ritchie. Shapeassembly: Learning to generate programs for 3d shape structure synthesis. ACM Transactions on Graphics (TOG), Siggraph Asia 2020, 39(6):Article 234, 2020.
+
+Ashwin Kalyan, Abhishek Mohta, Oleksandr Polozov, Dhruv Batra, Prateek Jain, and Sumit Gulwani. Neural-guided deductive search for real-time program synthesis from examples. arXiv preprint arXiv:1804.01186, 2018.
+
+Kacper Kania, Maciej Zi˛eba, and Tomasz Kajdanowicz. Ucsg-net–unsupervised discovering of constructive solid geometry tree. arXiv preprint arXiv:2006.09102, 2020.
+
+Sangpil Kim, Hyung-gun Chi, Xiao Hu, Qixing Huang, and Karthik Ramani. A large-scale annotated mechanical components benchmark for classification and retrieval tasks with deep neural networks. In Proceedings of 16th European Conference on Computer Vision (ECCV), 2020.
+
+Thomas N Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. arXiv preprint arXiv:1609.02907, 2016.
+
+Sebastian Koch, Albert Matveev, Zhongshi Jiang, Francis Williams, Alexey Artemov, Evgeny Burnaev, Marc Alexa, Denis Zorin, and Daniele Panozzo. Abc: A big cad model dataset for geometric deep learning. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 9601–9611, 2019.
+
+Changjian Li, Hao Pan, Adrien Bousseau, and Niloy J. Mitra. Sketch2cad: Sequential cad modeling by sketching in context. ACM Trans. Graph. (Proceedings of SIGGRAPH Asia 2020), 39(6): 164:1–164:14, 2020. doi: https://doi.org/10.1145/3414685.3417807.
+
+Renjie Liao, Yujia Li, Yang Song, Shenlong Wang, Will Hamilton, David K Duvenaud, Raquel Urtasun, and Richard Zemel. Efficient graph generation with graph recurrent attention networks. In Advances in Neural Information Processing Systems, pp. 4255–4265, 2019.
+
+Cheng Lin, Tingxiang Fan, Wenping Wang, and Matthias Nießner. Modeling 3d shapes by reinforcement learning. ECCV, 2020.
+
+Kaichun Mo, Paul Guerrero, Li Yi, Hao Su, Peter Wonka, Niloy J. Mitra, and Leonidas J. Guibas. Structurenet: Hierarchical graph networks for 3d shape generation. ACM Trans. Graph., 38(6), November 2019a. ISSN 0730-0301. doi: 10.1145/3355089.3356527.
+
+Kaichun Mo, Shilin Zhu, Angel X Chang, Li Yi, Subarna Tripathi, Leonidas J Guibas, and Hao Su. Partnet: A large-scale benchmark for fine-grained and hierarchical part-level 3d object understanding. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 909–918, 2019b.
+
+Chandrakana Nandi, Anat Caspi, Dan Grossman, and Zachary Tatlock. Programming language tools and techniques for 3d printing. In 2nd Summit on Advances in Programming Languages (SNAPL 2017). Schloss Dagstuhl-Leibniz-Zentrum fuer Informatik, 2017.
+
+Chandrakana Nandi, James R Wilcox, Pavel Panchekha, Taylor Blau, Dan Grossman, and Zachary Tatlock. Functional programming for compiling and decompiling computer-aided design. Proceedings of the ACM on Programming Languages, 2(ICFP):1–31, 2018.
+
+Chandrakana Nandi, Max Willsey, Adam Anderson, James R. Wilcox, Eva Darulova, Dan Grossman, and Zachary Tatlock. Synthesizing structured cad models with equality saturation and inverse transformations. In Proceedings of the 41st ACM SIGPLAN Conference on Programming Language Design and Implementation, pp. 31–44, 2020.
+
+Adriana Schulz, Ariel Shamir, David I. W. Levin, Pitchaya Sitthi-Amorn, and Wojciech Matusik. Design and fabrication by example. ACM Transactions on Graphics (Proceedings SIGGRAPH 2014), 33(4), 2014.
+
+Ari Seff, Yaniv Ovadia, Wenda Zhou, and Ryan P. Adams. Sketchgraphs: A large-scale dataset for modeling relational geometry in computer-aided design. In ICML 2020 Workshop on ObjectOriented Learning. 2020.
+
+Jami J Shah, David Anderson, Yong Se Kim, and Sanjay Joshi. A discourse on geometric feature recognition from cad models. J. Comput. Inf. Sci. Eng., 1(1):41–51, 2001.
+
+Vadim Shapiro and Donald L Vossler. Separation for boundary to csg conversion. ACM Transactions on Graphics (TOG), 12(1):35–55, 1993.
+
+Gopal Sharma, Rishabh Goyal, Difan Liu, Evangelos Kalogerakis, and Subhransu Maji. Csgnet: Neural shape parser for constructive solid geometry. corr abs/1712.08290 (2017). arXiv preprint arXiv:1712.08290, 2017.
+
+Binil Starly. FabWave - 3D Part Repository, 2020. URL https://www.dimelab.org/ fabwave.
+
+O. Stava, S. Pirk, J. Kratt, B. Chen, R. Mundefinedch, O. Deussen, and B. Benes. Inverse procedural modelling of trees. Comput. Graph. Forum, 33(6):118–131, September 2014. ISSN 0167-7055. doi: 10.1111/cgf.12282. URL https://doi.org/10.1111/cgf.12282.
+
+Jerry O. Talton, Yu Lou, Steve Lesser, Jared Duke, Radomír Mech, and Vladlen Koltun. Metropolis ˇ procedural modeling. ACM Trans. Graph., 30(2), April 2011. ISSN 0730-0301. doi: 10.1145/ 1944846.1944851. URL https://doi.org/10.1145/1944846.1944851.
+
+Yunhao Tang, Shipra Agrawal, and Yuri Faenza. Reinforcement learning for integer programming: Learning to cut. arXiv preprint arXiv:1906.04859, 2019.
+
+Yonglong Tian, Andrew Luo, Xingyuan Sun, Kevin Ellis, William T. Freeman, Joshua B. Tenenbaum, and Jiajun Wu. Learning to infer and execute 3d shape programs. In International Conference on Learning Representations, 2019.
+
+Carlos A. Vanegas, Ignacio Garcia-Dorado, Daniel G. Aliaga, Bedrich Benes, and Paul Waddell. Inverse design of urban procedural models. ACM Trans. Graph., 31(6), November 2012. ISSN 0730-0301. doi: 10.1145/2366145.2366187. URL https://doi.org/10.1145/ 2366145.2366187.
+
+Petar Velickovi ˇ c, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Lio, and Yoshua ´ Bengio. Graph attention networks. arXiv preprint arXiv:1710.10903, 2017.
+
+K.J. Weiler. Topological structures for geometric modeling. Technical report RPI, Center for Interactive Computer Graphics. University Microfilms, 1986.
+
+Daniel Weiss. Geometry-based structural optimization on CAD specification trees. PhD thesis, ETH Zurich, 2009.
+
+Zhirong Wu, Shuran Song, Aditya Khosla, Fisher Yu, Linguang Zhang, Xiaoou Tang, and Jianxiong Xiao. 3d shapenets: A deep representation for volumetric shapes. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 1912–1920, 2015.
+
+Keyulu Xu, Weihua Hu, Jure Leskovec, and Stefanie Jegelka. How powerful are graph neural networks? arXiv preprint arXiv:1810.00826, 2018.
+
+Zhibo Zhang, Prakhar Jaiswal, and Rahul Rai. Featurenet: machining feature recognition based on 3d convolution neural network. Computer-Aided Design, 101:12–22, 2018.
+
+Qingnan Zhou and Alec Jacobson. Thingi10k: A dataset of 10,000 3d-printing models. arXiv preprint arXiv:1605.04797, 2016.
+
+Chuhang Zou, Ersin Yumer, Jimei Yang, Duygu Ceylan, and Derek Hoiem. 3d-prnn: Generating shape primitives with recurrent neural networks. In Proceedings of the IEEE International Conference on Computer Vision, pp. 900–909, 2017.
+
+# A APPENDIX
+
+# A.1 FUSION 360 GALLERY RECONSTRUCTION DATASET
+
+In this section we provide additional details on the Fusion 360 Gallery reconstruction dataset.
+
+# A.1.1 DATA PROCESSING
+
+We acquire the Fusion 360 designs from the Autodesk Online Gallery2. From the approximately 20,000 designs available we derive several datasets focused on specific areas of research. This paper introduces the reconstruction dataset as a new baseline dataset for CAD reconstruction. We use the Fusion 360 Python API to parse the native .f3d files. We divide multi-component assemblies into separate designs and suppress modeling operations other than sketch and extrude to expand the data quantity. Figure 10 shows an example assembly that is split up to produce multiple designs with independent construction sequences. The rounded edges are removed by suppressing fillets in the parametric CAD file.
+
+After each construction sequence has been extracted we perform reconstruction and compare the reconstructed design to the original to ensure data validity. Failure cases and any duplicate designs, are not included in the dataset. We consider a design a duplicate when there is an exact match in all of the following: body count, face count, surface area to one decimal point, volume to one decimal point, and for each extrude in the construction sequence: extrude profile count, extrude body count, extrude face count, extrude side face count, extrude end face count, and extrude start face count. This process allows us to match designs that have been translated or rotated, while considering designs unique if they have matching geometry but different construction sequences. Deduplication removes approximately 5,000 designs. Figure 11 shows a random sampling of designs from the reconstruction dataset.
+
+# A.1.2 GEOMETRY DATA FORMAT
+
+We provide geometry in several data formats that we discuss in this section. Geometry is provided for the final design and after each extrude operation.
+
+Boundary Representation A B-Rep consists of faces, edges, loops, coedges and vertices (Weiler, 1986). A face is a connected region of the model’s surface. An edge defines the curve where two faces meet and a vertex defines the point where edges meet. Faces have an underlying parametric surface which is divided into visible and hidden regions by a series of boundary loops. A set of connected faces forms a body. Designs in the dataset may contain multiple bodies.
+
+![](images/946b57407cdca7e319baec468b65858b091f9b5440ba72351fd565d0b60d6790.jpg)  
+Figure 10: An example multi-component assembly that is broken up into separate designs (highlighted with color), each with an independent construction sequence.
+
+![](images/2d0c5c04936cc2b2c1f773c573675ae656cfdaee220e2e481c3d70c0eabe725b.jpg)  
+Figure 11: A random sampling of designs from the Fusion 360 Gallery reconstruction dataset.
+
+![](images/2de1c2ed3378ea9b8fc3ce365cfc48c375ec4bb249bb6f68aea21c2dd1ce93a1.jpg)  
+Figure 12: Left: The number of bodies per design shown as a distribution. Right: The number of B-Rep faces per design shown as a distribution.
+
+B-Rep data is provided as .smt files representing the ground truth geometry and .step as an alternate neutral B-Rep file format. The .smt file format is the native format used by Autodesk Shape Manager, the CAD kernel within Fusion 360, and has the advantage of minimizing conversion errors. Additionally the B-Rep entities, such as bodies and faces, can referenced from the construction sequence back to entities in the .smt file.
+
+Mesh Mesh data is provided in .obj format representing a triangulated version of the B-Rep. Each B-Rep face is triangulated separately and labeled as a group of triangles in the .obj file with the B-Rep face id as the group name. This approach allows the triangles to be traced back to the B-Rep face and associated extrude operation. Note that the .obj meshes provided are not manifold.
+
+Other representations, such as point clouds or voxels, can be generated using existing data conversion routines and are not included in the dataset. For convenience we include a thumbnail .png image file together with each geometry.
+
+Files are provided in a single directory, with a naming convention as follows: XXXXX_YYYYYYYY_ZZZZ[_1234].ext. Here XXXXX represents the project, YYYYYYYY the file, ZZZZ the component, and _1234 the extrude index. If _1234 is absent the file represents the final design.
+
+# A.1.3 DESIGN COMPLEXITY
+
+A key goal of the reconstruction dataset is to provide a suitably scoped baseline for learning-based approaches to CAD reconstruction. Restricting the modeling operations to sketch and extrude vastly narrows the design space and enables simpler shape grammars for reconstruction. Each design represents a component in Fusion 360 that can have multiple geometric bodies. Figure 12 (left) illustrates that the vast majority of designs have a single body. The number of B-Rep faces in each design gives a good indication of the complexity of the dataset. Figure 12 (right) shows the number of faces per design as a distribution, with the peak being between 5-10 faces per design. As we do not filter any of the designs based on complexity, this distribution reflects real designs where simple washers and flat plates are common components in mechanical assemblies.
+
+# A.1.4 CONSTRUCTION SEQUENCE
+
+The construction sequence is the series of sketch and extrude operations that are executed to produce the final geometry. We provide the construction sequence in a JSON format text file. Each step in the construction sequence has associated parameters that are stored in that entity. For example, sketch entities will store the curves that make up the sketch. Each construction sequence must have at least one sketch and one extrude step, for a minimum of two steps. The average number of steps is 4.74, the median 4, the mode 2, and the maximum 61. Figure 13 illustrates the distribution of construction sequence length and the most frequent construction sequence combinations.
+
+With access to the full parametric history, it is possible to extract numerous relationships from the dataset that can be used for learning. Starting at a high level, we know the order of modeling operations in the construction sequence. The sketch geometry, B-Rep faces, and triangles derived from them, can be traced back to a position in the construction sequence. The type of geometry created by each modeling operation is also known. For example, sketches create trimmed profiles where the curves intersect to form closed loops; extrude operations produce B-Rep faces with information such as which faces were on the side or ends of an extrusion. In addition, the sequence of B-Rep models themselves contain valuable topology information that can be leveraged, such as the connectivity of B-Rep faces and edges. Finally geometric information like points and normal vectors can be sampled from the parametric surfaces. Feature diversity enables many different learning representations and architectures to be leveraged and compared.
+
+![](images/de3e76295463db1f39b14df2178c229e28e9f480e9f40ee0330b27428831a5a6.jpg)  
+Figure 13: Left: The distribution of construction sequence length. Right: The distribution of common construction sequences. S indicates a Sketch and E indicates an Extrude operation.
+
+# A.1.5 SKETCH
+
+In this section we describe the sketch data in further detail and present statistics illustrating the data distribution. Figure 14 illustrates the geometric 2D primitives, described in section 3, that make up a sketch. Sketches are represented as a series of points (pt1...pt6), that create curves (c1...c5), that in turn create profiles (pr1...pr3), illustrated with separate colors. Profiles can have inner loops to create holes, $c 1$ is the inner loop of $p r 2$ and the outer loop of $p r 3$ . Profiles also have a trimmed representation that contains only closed loops without open curves. The trimmed representation is shown in the lower right of Figure 14 where the $c 5$ is trimmed and incorporated into pr1 and pr2.
+
+![](images/700f9a97f8489f01582fa47af77c9dfe71b6c435113771bf0135ca546ba2165f.jpg)  
+Figure 14: Sketch primitives.
+
+![](images/a7592eec95757e868a8f79a2e57333c4320d8a04c1f3f9d7874dc8f236a81410.jpg)  
+Figure 15: Left: The number of curves in each design, shown as a distribution. Right: Common curve combinations in each design, shown as a distribution. Each curve type is abbreviated as follows: C - SketchCircle, A - SketchArc, L - SketchLine, S - SketchFittedSpline.
+
+All sketch geometry is provided in a solved state, meaning a sketch constraint solver is not required for standard reconstruction. The as-designed ordering of sketch operations is not stored in the native design files, however a consistent ordering can be derived by traversing the sketch profiles in sequence.
+
+Points Each point is provided with a universally unique identifier (UUID) key and a Point3D data structure with $x , y$ , and $z$ . Sketch primitives are drawn in a local 2D coordinate system and later transformed into world coordinates. As such all sketch points have a $z$ value of 0.
+
+Curves Each curve has a UUID key and a SketchCurve that can represent the curve types listed below. The parameters for each curve type can be referenced via the Fusion 360 API documentation linked below.
+
+• SketchArc   
+• SketchCircle   
+• SketchConicCurve   
+• SketchEllipse   
+• SketchEllipticalArc   
+• SketchFittedSpline   
+• SketchFixedSpline   
+• SketchLine
+
+Figure 15 illustrates the distribution of curve count per design and the frequency that different curve combinations are used together in a design. It is notable that mechanical CAD sketches rely heavily on lines, circles, and arcs rather than spline curves.
+
+Profiles Profiles represent a collection of curves that join together to make a closed loop. In Fusion 360 profiles are automatically generated from arbitrary curves that don’t necessarily connect at the end points. In Figure 14 two profiles (pr1 and pr2) are generated when the line crosses the triangle. We provide both the original curves (Figure 14, top right) used to generate the profiles (Figure 14, bottom left) and the trimmed profile information containing just the closed profile loop (Figure 14, bottom right). Loops within profiles have a flag that can be set to specify holes.
+
+Dimensions User specified sketch dimensions are used to define set angles, diameters, distances etc. between sketch geometry to constraint the sketch as it is edited. Each dimension has a UUID key and a SketchDimension that can represent the dimension types listed below. Each dimension references one or more curves by UUID. The parameters for each dimension type can be referenced via the Fusion 360 API documentation linked below.
+
+• SketchAngularDimension • SketchConcentricCircleDimension • SketchDiameterDimension • SketchEllipseMajorRadiusDimension • SketchEllipseMinorRadiusDimension • SketchLinearDimension • SketchOffsetCurvesDimension • SketchOffsetDimension • SketchRadialDimension
+
+Constraints Constraints define geometric relationships between sketch geometry. For example, a symmetry constraint enables the user to have geometry mirrored, or a parallel constraint ensures two lines are always parallel. Each constraint has a UUID key and a GeometricConstraint that can represent the constraint types listed below. Each constraint references one or more curves by UUID. The parameters for each constraint type can be referenced via the Fusion 360 API documentation linked below.
+
+• CircularPatternConstraint   
+• CoincidentConstraint   
+• CollinearConstraint   
+• ConcentricConstraint EqualConstraint HorizontalConstraint   
+• HorizontalPointsConstraint MidPointConstraint OffsetConstraint ParallelConstraint   
+• PerpendicularConstraint PolygonConstraint   
+• RectangularPatternConstraint SmoothConstraint   
+• SymmetryConstraint   
+• TangentConstraint   
+• VerticalConstraint   
+• VerticalPointsConstraint
+
+# A.1.6 EXTRUDE
+
+In this section we describe the extrude data in further detail and present statistics illustrating the data distribution. Extrude operations have a number of parameters that are set by the user while designing. Figure 17 shows how a sketch (left) can be extruded a set distance on one side, symmetrically on two sides, with different distances on each side, as well as tapered. Once a single body has been created by an extrude operation, subsequent extrudes can interact with that body via Boolean operations. Figure 18 shows a starting body and sketch (left) that can be extruded to form two separate bodies, a single joined body, a cut through the starting body, or a body at the intersection. The first extrude operation of a construction sequence is always a new body, with any operation possible for subsequent operations.
+
+![](images/8d06f07bec2d3b89c66d116165c869384b523394db4a6b9be9425552bb8e3939.jpg)  
+Figure 16 illustrates the distribution of dimension and constraint types in the dataset.   
+Figure 16: The distribution of constraint (left) and dimension (right) types.
+
+![](images/1f143c4eda0bc9518e3f8cb05454273da34488242ee52a5fea9ddf3ec7d3ba62.jpg)  
+Figure 17: An extrude can be expressed in several different ways: perpendicular from a sketch for a set distance along one side, a symmetrical distance along both sides, or separate distances along two sides. Additionally the extrude can be tapered at an angle.
+
+![](images/5c94fe352412e1041a1a787b2ce1c0e0731eeab65e196d539702372147529b00.jpg)  
+Figure 18: Extrude operations include the ability to Boolean with other geometry. From the starting body shown on the left, a sketch is extruded to form a new body overlapping the starting body, joined with the starting body, cut out of the starting body, or intersected with the starting body.
+
+Figure 19 outlines the distribution of different extrude types and operations. Note that tapers can be applied in addition to any extrude type, so the overall frequency of each is shown rather than a relative percentage.
+
+# A.2 FUSION 360 GYM
+
+In this section we provide additional information about the functionality available in the Fusion 360 Gym. The Fusion 360 Gym requires the Autodesk Fusion 360 desktop CAD application, available on both macOS and Windows for free to the academic community. Although Fusion 360 is a cloud connected desktop application, the Fusion 360 Gym does all processing locally. The Fusion 360 Gym consists of a server that runs inside of Fusion 360 and receives commands from a client running externally. Multiple instances of the Fusion 360 Gym server can be run in parallel. The remainder of this section introduces the available commands from the client.
+
+![](images/38663c848d876cea21dc44dd2c1bf340a89c03faa2edd4be8414b3173b9159e3.jpg)  
+Figure 19: The distribution of extrude types (left) and operations (right).
+
+# A.2.1 RECONSTRUCTION COMMANDS
+
+Reconstruction commands can reconstruct the existing designs at different granularity levels from json files provided with the Fusion 360 Gallery reconstruction dataset.
+
+• reconstruct(file): reconstruct an entire design from the provided json file.   
+• reconstruct_sketch(json_data, sketch_name, sketch_plane, scale, translate, rotate): reconstruct a sketch from the provided json data and a sketch name. A sketch_plane can be either: (1) a string value representing a construction plane: XY, XZ, or YZ; (2) a B-Rep planar face id; or (3) a point3d on a planar face of a B-Rep. reconstruct_profile(json_data, sketch_name, profile_id, scale, translate, rotate): reconstruct a profile from the provide json data, a sketch name, and a profile id. reconstruct_curve(json_data, sketch_name, curve_id, scale, translate, rotate): reconstruct a curve from the provide json data, a sketch name, and a curve id.   
+• set_target(file): set the target to be reconstructed with a .step or .smt file. The call returns a face adjacency graph representing the B-Rep geometry/topology and a bounding_box of the target that can be used for normalization.   
+• revert_to_target(): revert to the target design, removing all reconstruction geometry.
+
+# A.2.2 SKETCH EXTRUSION COMMANDS
+
+Sketch extrusion commands allows users to incrementally create new designs by generating the underlying sketch primitives and extruding them by an arbitrary amount.
+
+• add_sketch(sketch_plane): add a sketch to the design. A sketch_plane can be either: (1) a string value representing a construction plane: XY, XZ, or YZ; (2) a B-Rep planar face id; or (3) a point3d on a planar face of a B-Rep.   
+• add_point(sketch_name, p1, transform): add a point to create a new sequential line in the given sketch. p1 is either a point in the 2D sketch space or a point in the 3D world coordinate space if transform $\underline { { \underline { { \mathbf { \Pi } } } } } =$ "world" is specified.   
+• add_line(sketch_name, p1, p2, transform): add a line to the given sketch. p1 and p2 are the same as defined in add_point().   
+• add_curve(sketch_name, curve_data, transform): add a curve to the given sketch. curve_data follows the format supplied to reconstruct_curve(). close_profile(sketch_name): close the current set of lines to create one or more profiles by joining the first point to the last point.   
+• add_extrude(sketch_name, profile_id, distance, operation, export_type, is_IoU): add an extrude to the design. Four operations are supported: JoinFeatureOperation, CutFeatureOperation, IntersectFeatureOperation, or NewBodyFeatureOperation. Two export formats are provided: (1) BRep to represent B-Rep vertices of the resulting body and B-Rep face information; (2) Graph to represent a face adjacency graph representing the B-Rep geometry/topology. An intersection over union (IoU) value between the target and the reconstruction is calculated and returned if is_IoU $\mathop { \bf { \bar { \mathbf { \Lambda } } } }$ "True" is specified.
+
+# A.2.3 FACE EXTRUSION COMMANDS
+
+Face extrusion commands enable a target design to be reconstructed using extrude operations from face to face.
+
+• add_extrude_by_target_face(start_face, end_face, operation): add an extrude between two faces of the target. Four operations are supported: JoinFeatureOperation, CutFeatureOperation, IntersectFeatureOperation, or NewBodyFeatureOperation.
+
+![](images/baa77eb1898e9ccee172fb3a66126b027553b567595361c79c5788c11c593ff5.jpg)  
+Figure 20: Example designs created using randomized reconstruction commands.
+
+• add_extrudes_by_target_face(actions, revert): execute multiple extrude operations, between two faces of the target, in sequence.
+
+# A.2.4 RANDOMIZED RECONSTRUCTION COMMANDS
+
+Randomized reonstruction commands allow users to sample designs, sketches, and profiles from existing designs in the Fusion 360 Gallery and support distribution matching of parameters, in support of generations of semi-synthetic data. Figure 20 shows example designs created using randomized reconstruction commands.
+
+• get_distributions(data_dir, filter): get a list of distributions from the provided dataset. The command currently supports the following distributions: the starting sketch place, the number of faces, the number of extrusions, the length of sequences, the number of curves, the number of bodies, the sketch areas, and the profile areas.
+
+• distribution_sampling(distributions, parameters): sample distribution matching parameters for one design from the distributions.   
+• sample_design(data_dir): randomly sample a json file from the given dataset.   
+• sample_sketch(json_file, sampling_type, area_distribution): sample one sketch from the provided design. Three sampling types are provided: (1) random, return a sketch randomly sampled from the provided design; (2) deterministic, return the largest sketch in the design; and (3) distributive, return a sketch that its area is in the distribution of the provided dataset.   
+• sample_profiles(sketch_name, max_number_profiles, sampling_type, area_distribution): sample profiles from the provided sketch. Three sampling types are provided: (1) random, return profiles randomly sampled from the provided sketch; (2) deterministic, return profiles that are larger than the average area of the profiles in the sketch; and (3) distributive, return profiles that the areas are in the distribution of the provided dataset.
+
+# A.2.5 EXPORT COMMANDS
+
+Export commands enable the existing designs to be exported in the following formats:
+
+• mesh(file): retrieve a mesh in .obj or .stl format and write it to the local file provided.   
+• brep(file): retrieve a brep in .step, .smt, or .f3d format and write it to a local file provided.   
+• sketches(dir, format): retrieve each sketch in .png or .dxf format and write them to a local directory provided. screenshot(file, width, height): retrieve a screenshot of the current design as a png image and write it to a local file provided.   
+graph(file, dir, format): retrieve a face adjacency graph in a given format and write it in a local directory provided.
+
+# A.3 CAD RECONSTRUCTION
+
+In this section we provide additional details of the experiments performed on the CAD reconstruction task described in Section 5.
+
+# A.3.1 DATA PREPARATION
+
+The agents are trained on a subset of the reconstruction dataset that has been converted into a face extrusion sequence. Due to the simplified face extrusion representation, not all designs from the dataset can be converted to a face extrusion sequence. Figure 21 shows several common conversion limitations where necessary face information (highlighted in red) is not present in the target geometry. The intermediate top face in Figure $2 1 \ \mathbf { B }$ disappears when merged with the top face of Extrude 2. In Figure $2 1 ~ \mathrm { { C } }$ a hole cut through the geometry means the intermediate top face of Extrude 1 is absent and there is no start or end face in the target geometry to perform the cut operation used in Extrude 2. Although it is possible to find alternate face extrusion sequences with heuristic rules, we instead try to maintain the user designed sequence with the exception of reversing the direction of the extrusion in some scenarios, e.g. the end face becomes the start face.
+
+# A.3.2 AGENT
+
+All MPN agents employ a network architecture able to exploit the graph structure of the data, consisting of two layers passing messages along the edges of the graph. The vertex features in the face-adjacency graph are as follows:
+
+• Points: A $1 0 \times 1 0$ grid of 3D points sampled from the UV coordinate space of the B-Rep face and normalized to the bounding box of the target geometry.   
+• Normals: A $1 0 \times 1 0$ grid of 3D normal vectors sampled from the UV coordinate space of the B-Rep face.   
+• Trimming Mask: A $1 0 \times 1 0$ grid of binary values representing samples that are inside/outside the B-Rep face trimming boundary.
+
+![](images/e48948e8c6505297a2af34af974da0528aaa6e29d87e8d05912614844806d3bb.jpg)  
+Figure 21: Different construction sequences (A-C) for the same geometry. During conversion to a face extrusion sequence, the necessary face information (highlighted in red) does not exist in the target, meaning B and C can not be converted. Green arrows indicate new body/join extrude operations, while red arrows indicate cut extrude operations.
+
+• Surface Type: A one-hot encoded flag indicating the type of surface represented by the BRep face: Cone, Cylinder, Elliptical, EllipticalCylinder, Nurbs, Plane, Sphere, Torus.
+
+We denote the learned vertex embedding vectors produced by the two MPN branches as $\{ \mathbf h _ { c } ^ { i } \}$ and $\{ \mathbf { h } _ { t } ^ { j } \}$ for the current output and target graphs, respectively. We estimate the probability of the $k$ -th operation type, and the $j$ -th face being the start face or end face as:
+
+$$
+\begin{array} { c } { { \displaystyle P _ { o p } ^ { k } = F _ { o p } \big ( { \bf h } _ { c } \big ) , ~ { \bf h } _ { c } = \sum _ { i } { \bf h } _ { c } ^ { i } } } \\ { { \displaystyle P _ { s t a r t } ^ { j } = \mathrm { s o f t r a x } \Big ( F _ { s t a r t } \big ( { \bf h } _ { t } ^ { j } , { \bf h } _ { c } \big ) \Big ) } } \end{array}
+$$
+
+$$
+P _ { e n d } ^ { j } = \operatorname { s o f } _ { j } \tan \alpha \Big ( F _ { e n d } \big ( \mathbf { h } _ { t } ^ { j } , \mathbf { h } _ { t } ^ { \widetilde { j } } , \mathbf { h } _ { c } \big ) \Big ) , s . t . \widetilde { j } = \arg \operatorname* { m a x } _ { j } P _ { s t a r t } ^ { j }
+$$
+
+where $F _ { o p }$ , $F _ { s t a r t }$ , and $F _ { e n d }$ denote linear layers that take the concatenated vectors as input.
+
+Using the face extrusion sequence data, we train the agents in an offline manner without interacting with the Fusion 360 Gym. The mlp and gcn agents have a hidden dimension of 256 across all layers. The gin agent has two 256-dimensional linear layers within its graph convolution layer. The gat has 8 heads of 64 hidden dimensions each. The agents are trained with a dropout rate of 0.1 and a learning rate of 0.0001 for 100 epochs with the model saved at the lowest training loss. The learning rate is decreased by a factor of 0.1 upon plateau within 10 most recent epochs. Training is performed on an NVIDIA Tesla V100 with an Adam optimizer and takes approximately 6-8 hours.
+
+# A.3.3 SEARCH
+
+In addition to the random rollout search (rand) described in Section 5.2 we implement beam search (beam) and best first search (best). Beam search explores multiple candidates in parallel, filtering the top- $\mathbf { \nabla } \cdot \mathbf { k }$ candidates, ranked by the generation probability, until a certain length. Best search explores the search space by expanding the most-likely sequence, also ranked by the generation probability.
+
+In all search algorithms we mask out the following invalid actions so they are never taken:
+
+![](images/6dc0a3f983e680080b580f91b7486670b6d8fc2351d4111b945f1459a365c4b9.jpg)  
+Figure 22: Average reconstruction time per design for combinations of agents and search strategies.
+
+• Start faces surface types that are non-planar   
+• End faces surface types that are non-planar   
+• Operation types other than new body when the current geometry is empty
+
+Other invalid actions that require geometric checks, such as specifying a start face and end face that are co-planar, are returned as invalid from the Fusion 360 Gym and count against the search budget.
+
+# A.3.4 EVALUATION
+
+We perform evaluation using the official test set containing 1725 designs. Evaluation is performed in an online manner using the Fusion 360 Gym. Figure 22 shows the average reconstruction time for each design with combinations of agents and search strategies. Time differences are due in part to the number of invalid actions chosen by an agent that can be quickly checked in the Fusion $3 6 0 G y m$ without geometry processing. The large majority of evaluation time is spent inside the Fusion 360 Gym executing modeling operations, graph generation, and IoU calculation. We set a hard time limit of 10 minutes per design, after which we halt search, affecting between 0-14 designs depending on the agent and search strategy. Between 0-15 designs cause software crashes. 17 designs in the test set cannot be represented as graphs due to our data pipeline not supporting edges with more than two adjacent faces. In all failure cases we use the best seen IoU, or 0 if no IoU score is available, and consider the design to fail at exact reconstruction.
+
+# A.3.5 RESULTS
+
+Table 2 details the full set of results for all agents and search strategies in the extendedbaseline comparison experiment from Section 5.3. Table 3 provides additional details of the synthetic data performance experiment from Section 5.3. Figure 23 visually compares three different search strategies side by side using the gcn agent. We observe that all search strategies perform similarly for reconstruction IoU, while random rollout search has a notable advantage in exact reconstructions. This advantage is due to the limited search budget we enforce to reflect a real-world scenario. We expect both best and beam search to improve with larger search budgets.
+
+# A.4 TASKS
+
+In addition to CAD reconstruction the Fusion 360 Gallery reconstruction dataset and Fusion 360 Gym can be used for a range tasks such as program synthesis, sequence modeling, generative models, and geometric deep learning. Other tasks include:
+
+• Modeling operation order prediction to recover the correct order of construction from raw geometry.   
+• Sketch synthesis to recover the original sketch, including constraints and dimensions, from the 3D geometry.   
+• Predicting next action in the design sequence for ‘CAD autocomplete’.   
+• Generative models that are aware of the design sequence and constraints.
+
+Table 2: Reconstruction results for multiple agent and search combinations. IoU and exact reconstruction are shown at 20 and 100 search steps. Lower values are better for conciseness.   
+
+<table><tr><td rowspan="2">Agent</td><td rowspan="2">Search</td><td colspan="2">IoU</td><td colspan="2">Exact Reconstruction.%</td><td rowspan="2">Conciseness</td><td rowspan="2">#Parameters.</td></tr><tr><td>20 Steps</td><td>100 Steps</td><td>20 Steps</td><td>100 Steps</td></tr><tr><td></td><td>rand</td><td>0.8644</td><td>0.9042</td><td>0.6232</td><td>0.6754</td><td>1.0168</td><td>3.02M</td></tr><tr><td>gcn gcn</td><td>beam</td><td>0.8640</td><td>0.8982</td><td>0.5739</td><td>0.6122</td><td>0.9275</td><td>3.02M</td></tr><tr><td>gcn</td><td>best</td><td>0.8831</td><td>0.9186</td><td>0.5971</td><td>0.6348</td><td>0.9215</td><td>3.02M</td></tr><tr><td>mlp</td><td>rand</td><td>0.8274</td><td>0.8596</td><td>0.5658</td><td>0.5965</td><td>0.9763</td><td>2.24M</td></tr><tr><td>mlp</td><td>beam</td><td>0.8619</td><td>0.8995</td><td>0.5525</td><td>0.5884</td><td>0.9271</td><td>2.24M</td></tr><tr><td>mlp</td><td>best</td><td>0.8712</td><td>0.8991</td><td>0.5675</td><td>0.5977</td><td>0.9305</td><td>2.24M</td></tr><tr><td>gat</td><td>rand</td><td>0.8742</td><td>0.9128</td><td>0.6191</td><td>0.6742</td><td>1.0206</td><td>3.03M</td></tr><tr><td>gat</td><td>beam</td><td>0.8691</td><td>0.9016</td><td>0.5791</td><td>0.6133</td><td>0.9261</td><td>3.03M</td></tr><tr><td>gat</td><td>best</td><td>0.8895</td><td>0.9139</td><td>0.5994</td><td>0.6354</td><td>0.9290</td><td>3.03M</td></tr><tr><td>gin</td><td>rand</td><td>0.8346</td><td>0.8761</td><td>0.5901</td><td>0.6301</td><td>1.0042</td><td>3.62M</td></tr><tr><td>gin</td><td>beam</td><td>0.8500</td><td>0.8913</td><td>0.5594</td><td>0.5983</td><td>0.9299</td><td>3.62M</td></tr><tr><td>gin</td><td>best</td><td>0.8693</td><td>0.9007</td><td>0.5803</td><td>0.6122</td><td>0.9340</td><td>3.62M</td></tr><tr><td>rand</td><td>rand</td><td>0.6840</td><td>0.8386</td><td>0.4157</td><td>0.5380</td><td>1.2824</td><td>=</td></tr><tr><td>rand</td><td>beam</td><td>0.4785</td><td>0.6277</td><td>0.2812</td><td>0.3896</td><td>0.9118</td><td>=</td></tr><tr><td>rand</td><td>best</td><td>0.6334</td><td>0.7994</td><td>0.3693</td><td>0.4887</td><td>0.8979</td><td>=</td></tr></table>
+
+Table 3: Reconstruction results using random rollouts and gcn agents trained on human-designed data (real), a mixture of human-designed and semi-synthetic data (aug), semi-synthetic data (semisyn), and synthetic data (syn).   
+
+<table><tr><td>Agent</td><td colspan="2">IoU</td><td colspan="2">Exact Reconstruction %</td><td rowspan="2">Conciseness 100 Steps</td><td rowspan="2"># Parameters</td></tr><tr><td></td><td></td><td>20 Steps</td><td>100 Steps</td><td>20 Steps</td></tr><tr><td>real</td><td>0.8644</td><td>0.9042</td><td>0.6232</td><td>0.6754</td><td>1.0168</td><td>3.02M</td></tr><tr><td>aug</td><td>0.8707</td><td>0.8928</td><td>0.6452</td><td>0.6701</td><td>0.9706</td><td>3.02M</td></tr><tr><td>semi-syn</td><td>0.8154</td><td>0.8473</td><td>0.5780</td><td>0.6104</td><td>1.0070</td><td>3.02M</td></tr><tr><td>syn</td><td>0.6646</td><td>0.7211</td><td>0.4383</td><td>0.4835</td><td>1.0519</td><td>3.02M</td></tr></table>
+
+![](images/a71044e918a4b2f29b9536fe37bfb2337e765e30828e718ab8a68f773d51e397.jpg)  
+Figure 23: Reconstruction results over 100 search steps using the gcn agent with best first search (best), random rollout search (rand) and beam search (beam).

parse/train/kB8DkEKSDH/kB8DkEKSDH.md

@@ -0,0 +1,350 @@
+# HELLINGER DISTANCE CONSTRAINED REGRESSION
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+This paper introduces an off-policy reinforcement learning method that uses Hellinger distance between sampling policy (from what samples were collected) and current policy (policy being optimized) as a constraint. Hellinger distance squared multiplied by two is greater than or equal to total variation distance squared and less than or equal to Kullback-Leibler divergence, therefore a lower bound for expected discounted return for the new policy is improved compared to the lower bound for training with KL. Also, Hellinger distance is less than or equal to 1, so there is a policy-independent lower bound for expected discounted return. HDCR is capable of training with Experience Replay, a common setting for distributed RL when collecting trajectories using different policies and learning from this data centralized. HDCR shows results comparable to or better than Advantage-weighted Behavior Model and Advantage-Weighted Regression on MuJoCo tasks using tiny offline datasets collected by random agents. On bigger datasets ( $1 0 0 \mathrm { k }$ timesteps) obtained by pretrained behavioral policy, HDCR outperforms ABM and AWR methods on 3 out of 4 tasks.
+
+# 1 INTRODUCTION
+
+Policy gradient algorithms are methods of model-free reinforcement learning that optimize policy through differentiating expected discounted return. Despite the simplicity, to converge, these methods should stay on-policy because of the first-order approximation of state visitation frequencies. This issue makes agents learn through trial-and-error, using data only once.
+
+To make policy gradient updates more off-policy, we can add a constraint on the update to decrease the step size if the current policy is too far from the sampling policy. One of the first methods was to add total variation distance squared as a constraint for mixture policies. Later it was proven that there is a lower bound for new policy’s expected discounted return (Kakade & Langford, 2002). Recently it was proven that this lower bound exists for all types of updates (Schulman et al., 2015).
+
+Next, total variation distance squared was replaced by Kullback-Leibler divergence that is greater than or equal to the previous one (Pinker’s inequality (Levin & Peres, 2017)), so that the lower bound was decreased (Schulman et al., 2015). Using Lagrangian, have been derived off-policy method called Advantage-Weighted Regression (Peng et al., 2019), which also used KL as a constraint.
+
+This article proposes a new method whose lower bound of expected discounted return is greater than or equal to the bound with KL. We achieve this by replacing total variation distance by Hellinger distance, which decreases lower bound. Therefore strictness stays the same. Then we derive an offpolicy method called Hellinger Distance Constrained Regression using the new constraint. It can be used on discrete and continuous action spaces since derivation uses Lebesgue integrals rather than a summation or Riemann integrals.
+
+# 2 PRELIMINARIES
+
+To better present the problem, we start from basic definitions, go through the history of improvements, and then describe the disadvantages of using KL divergence as a constraint.
+
+We consider an infinite-horizon discounted Markov decision process (MDP), defined by the tuple $( \mathcal { S } , \ \mathcal { A } , \ P , \ r , \ \rho _ { 0 } , \ \gamma )$ , where $s$ is a set of states (finite or infinite), $\mathcal { A }$ is a set of actions (finite or infinite), $P : \mathcal { S } \times \mathcal { A } \times \mathcal { S } \to \mathbb { R }$ is the transition probability distribution, $r : \mathcal { S } \ \to \ \mathbb { R }$ is
+
+the reward function, $\rho _ { 0 } : \mathcal { S } \ \to \ \mathbb { R }$ is the distribution of the initial state $s _ { 0 }$ , and $\gamma ~ \in ~ ( 0 , 1 )$ is the discount factor.
+
+Let $\pi$ denote a stochastic policy $\pi : \mathcal { S } \times \mathcal { A } \to [ 0 , 1 ]$ , and then its expected discounted return is:
+
+$$
+\begin{array} { r l } & { \eta ( \pi ) = \mathbb { E } _ { s _ { 0 } , a _ { 0 } , \ldots } \left[ \displaystyle \sum _ { t = 0 } ^ { \infty } \gamma ^ { t } r ( s _ { t } ) \right] \mathrm { , ~ w h e r e } } \\ & { s _ { 0 } \sim \rho _ { 0 } ( \cdot ) \mathrm { , ~ } a _ { t } \sim \pi ( \cdot | s _ { t } ) \mathrm { , ~ } s _ { t + 1 } \sim P ( \cdot | s _ { t } , a _ { t } ) \mathrm { . } } \end{array}
+$$
+
+This paper uses state-action value function $Q _ { \pi }$ , state value function $V _ { \pi }$ , and advantage function $A _ { \pi }$ with the following definitions:
+
+$$
+\begin{array} { c l } { \displaystyle Q _ { \pi } ( s _ { t } , a _ { t } ) = \mathbb { E } _ { s _ { t + 1 } , a _ { t + 1 } , \dots } \left[ \sum _ { l = 0 } ^ { \infty } \gamma ^ { l } r ( s _ { t + l } ) \right] } \\ { \displaystyle V _ { \pi } ( s _ { t } ) = \mathbb { E } _ { a _ { t } , s _ { t + 1 } , a _ { t + 1 } , \dots } \left[ \sum _ { l = 0 } ^ { \infty } \gamma ^ { l } r ( s _ { t + l } ) \right] } \\ { \displaystyle A _ { \pi } ( s _ { t } , a _ { t } ) = Q _ { \pi } ( s _ { t } , a _ { t } ) - V _ { \pi } ( s _ { t } ) . } \end{array}
+$$
+
+Let $\rho _ { \pi } ( s )$ be unnormalized visitation frequencies of state $s$ where actions are chosen according to $\pi$ :
+
+$$
+\rho _ { \pi } ( s ) = \sum _ { t = 0 } ^ { \infty } \gamma ^ { t } P ( s _ { t } = s ) .
+$$
+
+Following identity expresses the expected return of another policy $\tilde { \pi }$ in terms of the advantage over $\pi$ accumulated over states (see Schulman et al. (2015) for proof):
+
+$$
+\eta ( \tilde { \pi } ) = \eta ( \pi ) + \int \rho _ { \tilde { \pi } } ( s ) \int \tilde { \pi } ( a | s ) A _ { \pi } ( s , a ) d a d s .
+$$
+
+In approximately optimal learning, we replace state visitation frequency $\rho _ { \tilde { \pi } }$ by $\rho _ { \pi }$ , since this drastically decrease optimization complexity:
+
+$$
+L _ { \pi } ( \tilde { \pi } ) = \eta ( \pi ) + \int \rho _ { \pi } ( s ) \int \tilde { \pi } ( a | s ) A _ { \pi } ( s , a ) d a d s .
+$$
+
+Let $\pi _ { o l d }$ denote current policy, then the lower bound for the expected discounted return for the new policy $\pi _ { n e w }$ will be (see Schulman et al. (2015) for proof):
+
+$$
+\begin{array} { r l r } {  { \eta ( \pi _ { n e w } ) \geq L _ { \pi _ { o l d } } ( \pi _ { n e w } ) - \frac { 4 \epsilon \gamma } { ( 1 - \gamma ) ^ { 2 } } \alpha ^ { 2 } } } \\ & { } & { \mathrm { w h e r e } \epsilon = \operatorname* { m a x } _ { s , a } \vert A _ { \pi } ( s , a ) \vert , } \\ & { } & { \alpha = \operatorname* { m a x } _ { s } D _ { T V } ( \pi _ { o l d } ( \cdot \vert s ) \vert \vert \pi _ { n e w } ( \cdot \vert s ) ) , } \\ & { } & { D _ { T V } ( \pi _ { o l d } ( \cdot \vert s ) \vert \vert \pi _ { n e w } ( \cdot \vert s ) ) = \displaystyle \frac { 1 } { 2 } \int  \pi _ { o l d } ( a \vert s ) - \pi _ { n e w } ( a \vert s )  d a . } \end{array}
+$$
+
+Theoretical Trust-Region Policy Optimization algorithm relays on Pinsker’s inequality (see (Tsybakov, 2009) for proof):
+
+$$
+\begin{array} { c } { { \displaystyle D _ { K L } ( \pi _ { o l d } ( \cdot | s ) | | \pi _ { n e w } ( \cdot | s ) ) \geq D _ { T V } ( \pi _ { o l d } ( \cdot | s ) | | \pi _ { n e w } ( \cdot | s ) ) ^ { 2 } } } \\ { { \mathrm { w h e r e ~ } D _ { K L } ( \pi _ { o l d } ( \cdot | s ) | | \pi _ { n e w } ( \cdot | s ) ) = \displaystyle \int \pi _ { o l d } ( a | s ) \log \frac { \pi _ { o l d } ( a | s ) } { \pi _ { n e w } ( a | s ) } d a . } } \end{array}
+$$
+
+To retain strictness and decrease calculation complexity, total variation distance squared was replaced with Kullback-Leibler divergence $D _ { K L } ( \pi _ { o l d } ( \cdot | s ) | | \pi _ { n e w } ( \cdot | s ) )$ :
+
+$$
+\begin{array} { r l r } {  { \eta ( \pi _ { n e w } ) \geq L _ { \pi _ { o l d } } ( \pi _ { n e w } ) - C D _ { K L } ^ { m a x } ( \pi _ { o l d } | | \pi _ { n e w } ) } } \\ & { } & { \mathrm { w h e r e } \ \epsilon = \operatorname* { m a x } _ { s , a } | A _ { \pi } ( s , a ) | , } \\ & { } & { C = \frac { 4 \epsilon \gamma } { ( 1 - \gamma ) ^ { 2 } } , } \\ & { } & { D _ { K L } ^ { m a x } ( \pi _ { o l d } | | \pi _ { n e w } ) = \operatorname* { m a x } _ { s } D _ { K L } ( \pi _ { o l d } ( \cdot | s ) | | \pi _ { n e w } ( \cdot | s ) ) . } \end{array}
+$$
+
+However, this replacement greatly decreases the lower bound for the expected discounted return for the new policy. Moreover, Kullback-Leibler divergence has no upper bound. Therefore we have no policy-independent lower bound for this type of update.
+
+# 3 HELLINGER DISTANCE IN POLICY OPTIMIZATION
+
+We can improve lower bound (compared to KL) by replacing $D _ { T V } ( \pi _ { o l d } ( \cdot \mid s ) \mid \mid \pi _ { n e w } ( \cdot \mid s ) )$ with Hellinger distance $H ( \pi _ { o l d } ( \cdot | s ) \mid \mid \pi _ { n e w } ( \cdot \mid s ) )$ :
+
+$$
+H ( \pi _ { o l d } ( \cdot | s ) \mid | \pi _ { n e w } ( \cdot | s ) ) ^ { 2 } = 1 - \int \sqrt { \pi _ { o l d } ( a | s ) \pi _ { n e w } ( a | s ) } d a
+$$
+
+Theorem 1 (see Appendix A or (Tsybakov, 2009, section 2.4) for proof) proves correctness and improvement (compared to KL) to the lower bound.
+
+Let $p ( v )$ and $q ( v )$ be two probability density functions then:
+
+$$
+D _ { T V } ( p ( \cdot ) \mid \mid q ( \cdot ) ) ^ { 2 } \leq 2 H ( p ( \cdot ) \mid \mid q ( \cdot ) ) ^ { 2 } \leq D _ { K L } ( p ( \cdot ) \mid \mid q ( \cdot ) )
+$$
+
+Replacing $p ( v )$ and $q ( v )$ with $\pi _ { o l d } ( \cdot \mid s )$ and $\pi _ { n e w } ( \cdot \mid s )$ respectively, new lower bound follows:
+
+$$
+\begin{array} { r l } & { \eta ( \pi _ { n e w } ) \geq L _ { \pi _ { o l d } } ( \pi _ { n e w } ) - \frac { 8 \epsilon \gamma } { ( 1 - \gamma ) ^ { 2 } } \alpha ^ { 2 } } \\ & { \mathrm { ~ w h e r e ~ } \epsilon = \displaystyle \operatorname* { m a x } _ { s , a } | A _ { \pi } ( s , a ) | , } \\ & { \quad \quad \quad \alpha = \displaystyle \operatorname* { m a x } _ { s } H ( \pi _ { o l d } ( \cdot | s ) | | \pi _ { n e w } ( \cdot | s ) ) } \end{array}
+$$
+
+It is worth to note that $H ( \pi _ { o l d } ( \cdot \mid s ) \mid \mid \pi _ { n e w } ( \cdot \mid s ) ) \leq 1 .$
+
+# 4 HELLINGER DISTANCE CONSTRAINED REGRESSION (HDCR)
+
+We could use presented lower bound as in TRPO, but instead, we derive an offline regression algorithm by introducing the following optimization problem where $\mu$ is the sampling policy:
+
+$$
+\begin{array} { r l } {  { \arg \operatorname* { m a x } _ { \pi } \int \rho _ { \mu } ( s ) \int \pi ( a \vert s ) A _ { \mu } ( s , a ) d a d s } } \\ & { \quad \mathrm { s . t . } \int \rho _ { \mu } ( s ) H ( \pi ( \cdot \vert s ) \vert \vert \mu ( \cdot \vert s ) ) d s \leq \epsilon , } \\ & { \quad \quad \quad \int \pi ( a \vert s ) d a = 1 , \forall s \in \mathcal S . } \end{array}
+$$
+
+Constructing Lagrangian, differentiating it with respect to $\pi$ , and solving for $\pi$ gives us the following optimal policy (see Appendix $\mathbf { B }$ for derivation):
+
+$$
+\pi ^ { * } ( a | s ) = \mu ( a | s ) { \frac { \beta ^ { 2 } } { ( \beta - 2 A _ { \mu } ( s , a ) ) ^ { 2 } } } , { \mathrm { w h e r e ~ } } \beta { \mathrm { ~ i s ~ a ~ L a g r a n g i a n ~ m u l t i p l i e r . } }
+$$
+
+Constructing a regression problem of $\mathrm { K L }$ divergence between optimal policy $\pi ^ { * }$ and current policy $\pi$ and simplifying gives us the following supervised regression problem (see Appendix $\mathbf { B }$ for derivation):
+
+$$
+\underset { \pi } { \arg \operatorname* { m a x } } \mathbb { E } _ { s \sim \rho _ { \mu } ( \cdot ) } \mathbb { E } _ { a \sim \mu ( \cdot \vert s ) } \log \pi ( a \vert s ) \frac { 1 } { ( \beta - A _ { \mu } ( s , a ) ) ^ { 2 } }
+$$
+
+Using notation of ABM paper (Siegel et al., 2020) ”advantage-weighting” function is f (A(s, a)) = 1(β−A(s,a))2 .
+
+If we use HDCR with Experience Replay, in equation 14, we replace $\mu ( \cdot | s )$ in expectation $\mathbb { E } _ { a } \sim \mu ( \cdot \mid s )$ and advantage function $A _ { \mu } ( s , \ a )$ . Let $\begin{array} { r c l } { \Pi } & { = } & { \{ \pi _ { i } , \ \bar { \pi _ { i + 1 } } , \ \xrightarrow [ ] { } \ \pi _ { i + N } \} } \end{array}$ be a set of sampling policies from which actions were sampled, $w ( \pi _ { i } )$ probability of selecting policy $\pi _ { i }$ , then:
+
+$$
+\begin{array} { c l l } { { } } & { { } } & { { \displaystyle \mu ( s , a ) = \int _ { \Pi } w ( \pi ) \rho _ { \pi } ( s ) \pi ( a | s ) ~ d \pi } } \\ { { } } & { { } } & { { \displaystyle A _ { \mu } ( s , a ) = \frac { \int _ { \Pi } w ( \pi ) \rho _ { \pi } ( s ) ~ ( Q _ { \pi } ( s , a ) - V _ { \pi } ( s ) ) ~ d \pi } { \int _ { \Pi } w ( \pi ) \rho _ { \pi } ( s ) ~ d \pi } } } \\ { { } } & { { } } & { { \displaystyle \overline { { { V } } } ( s ) = \frac { \int _ { \Pi } w ( \pi ) \rho _ { \pi } ( s ) V _ { \pi } ( s ) ~ d \pi } { \int _ { \Pi } w ( \pi ) \rho _ { \pi } ( s ) ~ d \pi } } } \end{array}
+$$
+
+The proof will repeat the proof for AWR with Experience Replay (Peng et al., 2019).
+
+Practically we simply sample uniformly from the replay buffer and using a value function estimator.   
+This type of sampling provides us an approximation of expectation and state value function.
+
+Let $\mathcal { D }$ denote a set of stored trajectories (replay buffer), $A ( s , a ; \phi )$ is an advantage function parameterized by vector $\phi$ .
+
+The most popular method to obtain $A ( s , a ; \phi )$ for offline learning is to use state-action function estimator $Q ( s , a ; \phi )$ parameterized by $\phi$ :
+
+$$
+A ( s , a ; \phi ) = Q ( s , a ; \phi ) - \int \pi ( a ^ { \prime } | s ; \theta _ { k } ) Q ( s , a ^ { \prime } ; \phi _ { k } ) d a ^ { \prime }
+$$
+
+Despite $Q ( s , a ; \phi )$ being closer to the expectation of discounted return following policy $\pi$ (because of ”taking” the first action according to $\pi$ rather then $\mu$ ), we found Monte-Carlo return more efficient on tiny offline datasets. Greater performance using MC return can be explained by a lack of experience ”produced” by certain actions.
+
+Monte-Carlo estimation of $A ( s , a ; \phi )$ can be described as follows where $\begin{array} { r } { \mathcal { R } _ { s _ { t } , a _ { t } } ^ { \mathcal { D } } ~ = ~ \sum _ { l = 0 } ^ { T } \gamma ^ { l } r _ { t + l } } \end{array}$ is a state value function estimator parameterized by vector
+
+$$
+A ( s , a ; \phi ) = \mathcal { R } _ { s , a } ^ { \mathcal { D } } - V ( s ; \phi )
+$$
+
+Also, we can use Generalized Advantage Estimation (Schulman et al., 2016), where $\gamma \in \ [ 0 , 1 ]$ and $\delta _ { t } ^ { \phi _ { k } }$ is a one-step temporal difference for state $s _ { t }$ calculated using old vector $\phi _ { k }$ :
+
+$$
+\begin{array} { c } { { \delta _ { t } ^ { \phi _ { k } } = r _ { t } + \gamma V ( s _ { t + 1 } ; \phi _ { k } ) - V ( s _ { t } ; \phi _ { k } ) } } \\ { { { } } } \\ { { \displaystyle \hat { A } ( s _ { t } , a _ { t } ; \phi _ { k } ) = \sum _ { l = 0 } ^ { T } ( \gamma \lambda ) ^ { l } \delta _ { t + l } ^ { \phi _ { k } } } } \\ { { { } } } \\ { { { } A ( s _ { t } , a _ { t } ; \phi ) = \hat { A } ( s _ { t } , a _ { t } ; \phi _ { k } ) + V ( s _ { t } ; \phi _ { k } ) - V ( s _ { t } ; \phi ) } } \end{array}
+$$
+
+Finally, we propose the following reinforcement learning algorithm:
+
+# Algorithm 1: Hellinger Distance Constrained Regression
+
+<table><tr><td>0←randominitial weights D↑の</td></tr><tr><td>for iteration k = 1,..., kmax do add trajectories {Ti} sampled via π0k to D</td></tr><tr><td>Φk+1 ← arg minf Es,a~DA²(s,a;)</td></tr><tr><td>0k+1 ← arg maxθ Es,a~D [logTe(a|s)(β-A(s,a;Φx))] end</td></tr></table>
+
+![](images/92044249a5e261e1b7f35762fc724ef17bdd1838b3e5fe9a7dc4a0ff46f28e8d.jpg)  
+Figure 1: Learning curves of ABM, AWR, and HDCR averaged across results of learning from 10 different datasets of 10k timestamps (also 5 seeds used to generate each dataset).
+
+<table><tr><td rowspan=1 colspan=1>Task</td><td rowspan=1 colspan=1>ABM</td><td rowspan=1 colspan=1>AWR</td><td rowspan=1 colspan=1>HDCR (Ours)</td></tr><tr><td rowspan=1 colspan=1>Ant-v2</td><td rowspan=1 colspan=1>468±72</td><td rowspan=1 colspan=1>495 ± 84</td><td rowspan=1 colspan=1>569± 64</td></tr><tr><td rowspan=1 colspan=1>HalfCheetah-v2</td><td rowspan=1 colspan=1>-7±3</td><td rowspan=1 colspan=1>-7±4</td><td rowspan=1 colspan=1>-8±6</td></tr><tr><td rowspan=1 colspan=1>Hopper-v2</td><td rowspan=1 colspan=1>184 ± 72</td><td rowspan=1 colspan=1>209 ± 31</td><td rowspan=1 colspan=1>223±141</td></tr><tr><td rowspan=1 colspan=1>Walker2d-v2</td><td rowspan=1 colspan=1>132 ± 76</td><td rowspan=1 colspan=1>125 ± 92</td><td rowspan=1 colspan=1>145 ± 117</td></tr></table>
+
+Table 1: Final returns for different algorithms, with $\pm$ corresponding to one standard deviation of the average return across 10 datasets of 10k timestamps.
+
+# 5 EXPERIMENTS
+
+In our experiments, we evaluate the algorithm on MuJoCo (Todorov et al., 2012) tasks.
+
+# 5.1 TINY DATASETS
+
+For evaluating on extremely small datasets we use setting inspired by Behavioral Modelling Priors for Offline Reinforcement Learning paper (Siegel et al., 2020) but instead of using actions from a behaviorial policy we use random actions while generating buffer.
+
+First, we collect 2048 timestamps or more, until episode termination (whichever occurred later), from each of 5 seeds using random actions. Then we load collected trajectories to a replay buffer for the agent training. Separate networks with the same architecture (except the last layer) represent the policy and value function and consist of 2 hidden layers of 256 ELU units. Each train iteration uses only old data obtained by random agents. Each iteration, the value function is updating with 5 gradient steps and policy with 50 steps using a uniformly sampled batches of 512 samples using all data from the replay buffer. Learning rates for Adam optimizer are $2 \times 1 0 ^ { - 3 }$ and $2 \times 1 \bar { 0 } ^ { - 4 }$ for critic and actor, respectively.
+
+We compare 3 different ”advantage-weight” functions $f ( A ( s , a ) )$ :
+
+• Hellinger Distance Constrained Regression, where f (A(s, a)) = 1(β−A(s,a))2 ; • Advantage-weighted Behavior Model, where $f ( A ( s , a ) ) = I _ { A ( s , a ) > 0 }$ , $I _ { x > 0 } = 1$ if $x > 0$ otherwise $I _ { x > 0 } = 0$ ; • Advantage-Weighted Regression, where $\begin{array} { r } { f ( A ( s , a ) ) = \exp ( \frac { 1 } { \beta } A ( s , a ) ) } \end{array}$ .
+
+AWR method uses $\beta = 1 . 0$ as it is in implementation released by authors. HDCR uses $\beta = 1 . 0$ . For $\mathrm { T D } ( \lambda )$ we use $\lambda = 0 . 9 5$ .
+
+On simple tasks as Hopper-v2, all methods are able to learn (Figure 1), and HDCR shows slightly better results (Table 1). While on difficult tasks as Ant-v2, all algorithms do not improve their results through iterations. Moreover, evaluation returns decrease.
+
+# 5.2 LARGE DATASETS
+
+Next, we perform tests using buffers with the size of 100k timesteps. Buffer is filled by running a pretrained behavioral policy. This setting replicates the setting from Off-Policy Deep Reinforce
+
+![](images/41cd88b6b8977bcc608ad040c4f8b59c3ecd513ee6dbda0b5c7d48588997ffc4.jpg)  
+Figure 2: Curves of BCQ, ABM, AWR, and HDCR evaluation results averaged across 3 seeds.
+
+<table><tr><td rowspan=1 colspan=1>Task</td><td rowspan=1 colspan=1>ABM</td><td rowspan=1 colspan=1>AWR</td><td rowspan=1 colspan=1>HDCR (Ours)</td></tr><tr><td rowspan=1 colspan=1>Ant-v2</td><td rowspan=1 colspan=1>179 ± 45</td><td rowspan=1 colspan=1>281± 25</td><td rowspan=1 colspan=1>217 ± 54</td></tr><tr><td rowspan=1 colspan=1>HalfCheetah-v2</td><td rowspan=1 colspan=1>3358 ± 76</td><td rowspan=1 colspan=1>3365 ± 193</td><td rowspan=1 colspan=1>3485± 205</td></tr><tr><td rowspan=1 colspan=1>Hopper-v2</td><td rowspan=1 colspan=1>495 ± 115</td><td rowspan=1 colspan=1>478±94</td><td rowspan=1 colspan=1>576± 123</td></tr><tr><td rowspan=1 colspan=1>Walker2d-v2</td><td rowspan=1 colspan=1>592 ± 139</td><td rowspan=1 colspan=1>762 ± 64</td><td rowspan=1 colspan=1>805± 62</td></tr></table>
+
+Table 2: Final returns for different algorithms, with $\pm$ corresponding to one standard deviation of the average return across 3 seeds.
+
+ment Learning without Exploration (Fujimoto et al., 2019) paper. Therefore we also provide results of BCQ method achieved by authors’ implementation trained from the same datasets. For calculating advantage we use equation 16 where we approximate integral by taking mean of $1 0 \ \mathrm { Q }$ -values obtained by 10 actions sampled from the policy.
+
+While BCQ outperforms all the presented methods, it uses a gradient of Q-value function in actor training, which provides better generalization. This provides better results on evaluation but affects stability and performance. Against other methods that update the policy function directly, HDCR shows better results on 3 environments out of 4 (Figure 2 and Table 2).
+
+# 6 DISCUSSION
+
+We theoretically proved that Hellinger distance improves the lower bound of expected discounted return compared to Kullback-Leibler divergence and proposed a simple off-policy reinforcement learning method that uses Hellinger distance as a constraint. The expected discounted return for a new policy now has a policy-independent lower bound. This bound guarantees that return will not decrease in ”one” shot.
+
+Experiments show that HDCR outperforms both ABM and AWR on tiny datasets obtained by random agents. This performance proves the efficiency of using Hellinger distance by allowing bigger step sizes, retaining lower bound.
+
+On bigger datasets, HDCR shows comparable or better results than AWR and ABM.
+
+# REFERENCES
+
+Scott Fujimoto, David Meger, and Doina Precup. Off-policy deep reinforcement learning without exploration, 2019.
+
+Sham Kakade and John Langford. Approximately optimal approximate reinforcement learning. In Proceedings of the Nineteenth International Conference on Machine Learning, ICML ’02, pp. 267–274, San Francisco, CA, USA, 2002. Morgan Kaufmann Publishers Inc. ISBN 1558608737.
+
+David Levin and Yuval Peres. Markov Chains and Mixing Times. 2017. doi: 10.1090/mbk/107.
+
+Xue Bin Peng, Aviral Kumar, Grace Zhang, and Sergey Levine. Advantage-weighted regression: Simple and scalable off-policy reinforcement learning, 2019.
+
+John Schulman, Sergey Levine, Pieter Abbeel, Michael Jordan, and Philipp Moritz. Trust region policy optimization. volume 37 of Proceedings of Machine Learning Research, pp. 1889–1897,
+
+Lille, France, 07–09 Jul 2015. PMLR. URL http://proceedings.mlr.press/v37/ schulman15.html.
+
+John Schulman, Philipp Moritz, Sergey Levine, Michael Jordan, and Pieter Abbeel. Highdimensional continuous control using generalized advantage estimation. In Proceedings of the International Conference on Learning Representations (ICLR), 2016.
+
+Noah Siegel, Jost Tobias Springenberg, Felix Berkenkamp, Abbas Abdolmaleki, Michael Neunert, Thomas Lampe, Roland Hafner, Nicolas Heess, and Martin Riedmiller. Keep doing what worked: Behavior modelling priors for offline reinforcement learning. In International Conference on Learning Representations, 2020. URL https://openreview.net/forum?id $=$ rke7geHtwH.
+
+E. Todorov, T. Erez, and Y. Tassa. Mujoco: A physics engine for model-based control. In 2012 IEEE/RSJ International Conference on Intelligent Robots and Systems, pp. 5026–5033, 2012.
+
+Alexandre B. Tsybakov. Introduction to Nonparametric Estimation. Springer New York, 2009. doi: 10.1007/b13794. URL https://doi.org/10.1007%2Fb13794.
+
+# A THEOREM 1 PROOF
+
+Let $( \Omega , A )$ be a measurable space, $P$ and $Q$ be two probability measures on that space, $v$ be a $\sigma$ -finite measure on $( \Omega , A )$ such that $P \ll v ( P ( A ) = 0$ for any $A \in { \mathcal { A } }$ such that $\mu ( A ) = 0 ,$ ) and $Q \ll v$ . And let us denote Radon–Nikodym derivatives (in our derivations we can assume them as probability density functions) as follows:
+
+$$
+\begin{array} { c } { p = \displaystyle \frac { d P } { d v } } \\ { q = \displaystyle \frac { d Q } { d v } } \end{array}
+$$
+
+So, $p$ and $q$ satisfy following conditions:
+
+$$
+\begin{array} { l } { { P ( A ) = \displaystyle \int _ { A } p ( v ) ~ d v ~ \forall A \in { \mathcal A } } } \\ { { Q ( A ) = \displaystyle \int _ { A } q ( v ) ~ d v ~ \forall A \in { \mathcal A } } } \end{array}
+$$
+
+Then we define distances between probability measures:
+
+$$
+\begin{array} { l } { { \displaystyle D _ { T V } ( P \parallel Q ) = \operatorname* { s u p } _ { A \in \mathcal { A } } | P ( A ) - Q ( A ) | } } \\ { { \displaystyle H ( P \parallel Q ) ^ { 2 } = \frac { 1 } { 2 } \int ( \sqrt { p ( v ) } - \sqrt { q ( v ) } ) ^ { 2 } d v = 1 - \int \sqrt { p ( v ) q ( v ) } d v } } \\ { { \displaystyle D _ { K L } ( P \parallel Q ) = \int \log \frac { d P } { d Q } d P = \int p ( v ) \log \frac { p ( v ) } { q ( v ) } d v } } \end{array}
+$$
+
+Following Lemmas will be used in Theorem 1 proof:
+
+Lemma 1. Given two probability distributions $p$ and $q$ total variance divergence can be calculated as follows:
+
+$$
+D _ { T V } ( P \parallel Q ) = \operatorname* { s u p } _ { A \in { \mathcal A } } \left| P ( A ) - Q ( A ) \right| = \frac 1 2 \int \left| p ( v ) - q ( v ) \right| d v
+$$
+
+$$
+\begin{array} { c } { { P ( A ) - Q ( A ) \leq P ( A \cap B ) - Q ( A \cap B ) \leq P ( B ) - Q ( B ) } } \\ { { P ( A ) - Q ( A ) \leq Q ( A \cap B ^ { c } ) - P ( A \cap B ^ { c } ) \leq Q ( B ^ { c } ) - P ( B ^ { c } ) } } \\ { { \displaystyle \operatorname* { s u p } _ { A \in { \cal A } } | P ( A ) - Q ( A ) | = P ( B ) - Q ( B ) = Q ( B ^ { c } ) - P ( B ^ { c } ) } } \\ { { \displaystyle D _ { T V } ( P \mid \mid Q ) = \frac { 1 } { 2 } [ P ( B ) - Q ( B ) + Q ( B ^ { c } ) - P ( B ^ { c } ) ] } } \\ { { \displaystyle \qquad = \frac { 1 } { 2 } \int \left| p ( v ) - q ( v ) \right| d v } } \end{array}
+$$
+
+Lemma 2.
+
+$$
+D _ { T V } ( P \mid | Q ) = 1 - \int \operatorname* { m i n } ( p ( v ) , q ( v ) ) \ d v
+$$
+
+Proof.
+
+$$
+\begin{array} { l } { { \displaystyle D _ { T V } ( P \mid \mid Q ) = \frac { 1 } { 2 } \int \left. p ( v ) - q ( v ) \right. d v = \int _ { \{ v : p ( v ) > q ( v ) \} } [ p ( v ) - q ( v ) ] d v } } \\ { { \displaystyle \qquad = 1 - \int _ { \{ v : p ( v ) < q ( v ) \} } p ( v ) d v - \int _ { \{ v : p ( v ) > q ( v ) \} } q ( v ) d v } } \\ { { \displaystyle \qquad = 1 - \int \operatorname* { m i n } ( p ( v ) , q ( v ) ) d v } } \end{array}
+$$
+
+Lemma 3.
+
+$$
+\int \operatorname* { m a x } ( p ( v ) , q ( v ) ) d v + \int \operatorname* { m i n } ( p ( v ) , q ( v ) ) d v = 2
+$$
+
+Proof. Rewriting left part in 4 integrals over following sets $\begin{array} { r l r } { \{ \operatorname* { m a x } ( p ( v ) , q ( v ) ) } & { { } = { } } & { p ( v ) \} } \end{array}$ , $\{ \operatorname* { m a x } ( p ( v ) , q ( v ) ) ~ = ~ \bar { q } ( v ) \}$ , $\{ \operatorname* { m i n } ( \bar { p ( \boldsymbol { v } ) } , \boldsymbol { q } ( \boldsymbol { v } ) ) = q ( \boldsymbol { v } ) \bar  \}$ and $\{ \operatorname* { m i n } ( p ( v ) , q ( v ) ) \ = \ q ( v ) \}$ and stacking integrals back gives us $P ( \Omega ) + Q ( \Omega ) = 2$ . □
+
+Theorem 1. For any two probability density functions $p$ and $q$ , the following double inequality is true:
+
+$$
+D _ { T V } ( p \vert \vert q ) ^ { 2 } \leq 2 H ( p \vert \vert q ) ^ { 2 } \leq D _ { K L } ( p \vert \vert q )
+$$
+
+Proof. First inequality can be proved as follows:
+
+$$
+\begin{array} { r l } { ( 1 - H ( P | | Q | ^ { 2 } ) ^ { 2 } ) = \left[ \int \sqrt { p ( v ) q ( v ) } d v \right] ^ { 2 } } \\ & { = \left[ \int \sqrt { \operatorname* { m i n } ( p ( v ) , q ( v ) ) \operatorname* { m a x } ( p ( v ) , q ( v ) ) } d v \right] ^ { 2 } } \\ & { \leq \int \operatorname* { m i n } ( p ( v ) , q ( v ) ) d v \int \operatorname* { m a x } ( p ( v ) , q ( v ) ) d v } \\ & { = \int \operatorname* { m i n } ( p ( v ) , q ( v ) ) d v \left[ 2 - \int \operatorname* { m i n } ( p ( v ) , q ( v ) ) d v \right] } \\ & { = ( 1 - D _ { T V } ( P | | Q ) ) ( 1 + D _ { T V } ( P | | Q ) ) } \\ & { = 1 - D _ { T V } ( P | | Q ) ^ { 2 } } \\ { D v _ { T V } ( P | | Q ) ^ { 2 } \leq H ( P | | Q ) ^ { 2 } ( 2 - H ( P | | Q ) ^ { 2 } ) } \\ & { D _ { T V } ( P | | Q ) ^ { 2 } \leq 2 H ( P | | Q ) ^ { 2 } . } \end{array}
+$$
+
+Proof of the second inequality:
+
+$$
+\begin{array} { r l } & { D _ { K L } ( P \parallel Q ) = \displaystyle \int p ( v ) \log \frac { p ( v ) } { q ( v ) } d v = 2 \int p ( v ) \log \sqrt { \frac { p ( v ) } { q ( v ) } } d v } \\ & { \qquad = - 2 \int p ( v ) \log \left( \left[ \sqrt { \frac { q ( v ) } { p ( v ) } } - 1 \right] + 1 \right) d v } \\ & { \qquad \geq - 2 \int p ( v ) \left[ \sqrt { \frac { q ( v ) } { p ( v ) } } - 1 \right] \ d v = - 2 \int \left[ \sqrt { q ( v ) p ( v ) } - 1 \right] \ d v } \\ & { \qquad = 2 \left[ 1 - \int \sqrt { p ( v ) q ( v ) } \ d v \right] = 2 H ( P \parallel Q ) ^ { 2 } } \\ & { D _ { K L } ( P \parallel Q ) \geq 2 H ( P \parallel Q ) ^ { 2 } } \end{array}
+$$
+
+# B HDCR DERIVATION
+
+Given optimization problem:
+
+$$
+\begin{array} { r l } {  { \arg \operatorname* { m a x } _ { \pi } \int \rho _ { \mu } ( s ) \int \pi ( a \vert s ) A _ { \mu } ( s , a ) d a d s } } \\ & { \quad \mathrm { s . t . } \int \rho _ { \mu } ( s ) H ( \pi ( \cdot \vert s ) \vert \vert \mu ( \cdot \vert s ) ) d s \leq \epsilon , } \\ & { \quad \quad \quad \int \pi ( a \vert s ) d a = 1 , \forall s \in \mathcal S . } \end{array}
+$$
+
+Constructing Lagrangian where $\alpha : \mathcal { S } \ \to \ \mathbb { R }$ is a function for obtaining Lagrange multiplier for every state, $\beta$ is also a Lagrange multiplier:
+
+$$
+\begin{array} { l } { \displaystyle \mathcal { L } ( \pi , \beta , \alpha ) = \int _ { s } \rho _ { \mu } ( s ) \int _ { a } \pi ( a | s ) A _ { \mu } ( s , a ) d a d s } \\ { \displaystyle \qquad + \beta \left( \epsilon - \int _ { s } \rho _ { \mu } ( s ) \left[ 1 - \int \sqrt { \pi ( a | s ) \mu ( a | s ) } d a \right] d s \right) } \\ { \displaystyle \qquad + \int _ { s } \alpha _ { s } \left( 1 - \int _ { a } \pi ( a | s ) d a \right) d s } \end{array}
+$$
+
+Differentiating with respect to $\pi ( a | s )$ gives us following result:
+
+$$
+\frac { \partial \mathcal { L } } { \partial \pi ( a | s ) } = \rho _ { \mu } ( s ) A _ { \mu } ( s , a ) + \beta \rho _ { \mu } ( s ) \frac { \mu ( a | s ) } { 2 \sqrt { \pi ( a | s ) \mu ( a | s ) } } - \alpha _ { s } = 0
+$$
+
+Solving for $\pi ( a | s )$ :
+
+$$
+\begin{array} { r l r } & { } & { \beta \rho _ { \mu } ( s ) \frac { \mu ( a | s ) } { 2 \sqrt { \pi ( a | s ) \mu ( a | s ) } } = \alpha _ { s } - \rho _ { \mu } ( s ) A _ { \mu } ( s , a ) } \\ & { } & { \frac { \sqrt { \mu ( a | s ) } } { \sqrt { \pi ( a | s ) } } = 2 \frac { \frac { \alpha _ { s } } { \rho _ { \mu } ( s ) } - A _ { \mu } ( s , a ) } { \beta } } \end{array}
+$$
+
+Substituting $\pi ( a | s ) = \mu ( \cdot | s )$ and taking expectation over actions taken according to $\mu$ gives us expression for $\alpha _ { s }$ :
+
+$$
+\begin{array} { c } { { 1 = 2 \displaystyle \frac { \frac { \alpha _ { s } } { \rho _ { \mu } ( s ) } - A _ { \mu } ( s , a ) } { \beta } } } \\ { { { } } } \\ { { \mathbb { E } _ { a \sim \mu ( \cdot | s ) } \alpha _ { s } = \alpha _ { s } = \rho _ { \mu } ( s ) \mathbb { E } _ { a \sim \mu ( \cdot | s ) } \left[ \displaystyle \frac { 1 } { 2 } \beta + A _ { \mu } ( s , a ) \right] = \displaystyle \frac { 1 } { 2 } \beta \rho _ { \mu } ( s ) } } \end{array}
+$$
+
+Then optimal policy $\pi ^ { * } ( a | s )$ can be written as follows:
+
+$$
+\pi ^ { * } ( a | s ) = \mu ( a | s ) { \frac { \beta ^ { 2 } } { ( \beta - 2 A _ { \mu } ( s , a ) ) ^ { 2 } } }
+$$
+
+To obtain regression problem we construct Kullback–Leibler divergence between optimal policy $\pi ^ { * }$ and current policy $\pi$ :
+
+$$
+\begin{array} { r l } &  \begin{array} { r l } & { \mathrm { a r g } _ { \alpha } ^ { \mathrm { L i n } } \mathrm { i n } \mathbb { E } _ { s \sim p _ { \ell } ( s ) } \mathcal { D } _ { K L } ( \overline { { \mathbf { x } } } ^ { \star } ( \cdot | s ) | ) \pi ( \cdot | s ) } \\ & { = \mathrm { a r g } _ { \alpha } ^ { \mathrm { L i n } } \mathrm { i n } \mathbb { E } _ { s \sim p _ { \ell } ( s ) } \int \pi ^ { \star } ( a | s ) \log \frac { \pi ^ { \star } ( a | s ) } { \pi ( a | s ) } d a } \\ & { = \mathrm { a r g } _ { \alpha } ^ { \mathrm { n i n } } \mathrm { E } _ { s \sim p _ { \ell } ( s ) } \int \mu ( a | s ) \frac { \beta ^ { 2 } } { ( \beta - 2 A _ { \nu } ( s , a ) ) ^ { 2 } } \log \frac { \mu ( a | s ) \frac { \beta ^ { 2 } } { ( \beta - 2 A _ { \nu } ( s , a ) ) ^ { 2 } } } { \pi ( a | s ) } d a } \\ & { = \mathrm { a r g } _ { \alpha } ^ { \mathrm { n i n } } \mathrm { E } _ { s \sim p _ { \ell } ( s ) } \mathbb { E } _ { \alpha \sim p _ { \ell } ( s ) } \frac { 1 } { \mathrm { B a s } \pi ( s , a ) ( \beta - 2 A _ { \nu } ( s , a ) ) ^ { 2 } } \left[ \log \left( \mu ( a | s ) \frac { \beta ^ { 2 } } { ( \beta - 2 A _ { \nu } ( s , a ) ) ^ { 2 } } \right) - \log \pi ( a | s ) \right] } \\ & { = \mathrm { a r g } _ { \alpha } ^ { \mathrm { n i n } } \mathrm { E } _ { s \sim p _ { \ell } ( s ) } \mathbb { E } _ { \alpha \sim p _ { \ell } ( s ) } \log \pi ( a | s ) \frac { 1 } { ( \beta - 2 A _ { \nu } ( s , a ) ) ^ { 2 } } \left[ \log \left( \mu ( a | s ) \frac { \beta ^ { 2 } } { ( \beta - 2 A _ { \mu } ( s , a ) ) ^ { 2 } } \right) - \log \pi ( a | s ) \right] } \\ & { = \mathrm { a r g } _ { \alpha } ^ { \mathrm { n a x } } \mathbb { E } _ { s \sim p _ { \ell } ( s ) } \mathbb { E } _ { \alpha \sim p _ { \ell } ( s ) } \log \pi ( a | s ) \frac { 1 } { ( \beta - 2 A _ { \mu } ( s , a ) ) ^ { 2 } } } \\ &   \end{array} \end{array}
+$$
+
+Regression problem follows:
+
+$$
+\underset { \pi } { \arg \operatorname* { m a x } } \mathbb { E } _ { s \sim \rho _ { \mu } ( \cdot ) } \mathbb { E } _ { a \sim \mu ( \cdot \vert s ) } \log \pi ( a \vert s ) \frac { 1 } { ( \beta - A _ { \mu } ( s , a ) ) ^ { 2 } }
+$$

parse/train/kB8DkEKSDH/kB8DkEKSDH_content_list.json

@@ -0,0 +1,1614 @@
+[
+    {
+        "type": "text",
+        "text": "HELLINGER DISTANCE CONSTRAINED REGRESSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            795,
+            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,
+            224
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "This paper introduces an off-policy reinforcement learning method that uses Hellinger distance between sampling policy (from what samples were collected) and current policy (policy being optimized) as a constraint. Hellinger distance squared multiplied by two is greater than or equal to total variation distance squared and less than or equal to Kullback-Leibler divergence, therefore a lower bound for expected discounted return for the new policy is improved compared to the lower bound for training with KL. Also, Hellinger distance is less than or equal to 1, so there is a policy-independent lower bound for expected discounted return. HDCR is capable of training with Experience Replay, a common setting for distributed RL when collecting trajectories using different policies and learning from this data centralized. HDCR shows results comparable to or better than Advantage-weighted Behavior Model and Advantage-Weighted Regression on MuJoCo tasks using tiny offline datasets collected by random agents. On bigger datasets ( $1 0 0 \\mathrm { k }$ timesteps) obtained by pretrained behavioral policy, HDCR outperforms ABM and AWR methods on 3 out of 4 tasks. ",
+        "bbox": [
+            233,
+            242,
+            764,
+            449
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            477,
+            336,
+            492
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Policy gradient algorithms are methods of model-free reinforcement learning that optimize policy through differentiating expected discounted return. Despite the simplicity, to converge, these methods should stay on-policy because of the first-order approximation of state visitation frequencies. This issue makes agents learn through trial-and-error, using data only once. ",
+        "bbox": [
+            174,
+            507,
+            823,
+            564
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "To make policy gradient updates more off-policy, we can add a constraint on the update to decrease the step size if the current policy is too far from the sampling policy. One of the first methods was to add total variation distance squared as a constraint for mixture policies. Later it was proven that there is a lower bound for new policy’s expected discounted return (Kakade & Langford, 2002). Recently it was proven that this lower bound exists for all types of updates (Schulman et al., 2015). ",
+        "bbox": [
+            174,
+            570,
+            823,
+            640
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Next, total variation distance squared was replaced by Kullback-Leibler divergence that is greater than or equal to the previous one (Pinker’s inequality (Levin & Peres, 2017)), so that the lower bound was decreased (Schulman et al., 2015). Using Lagrangian, have been derived off-policy method called Advantage-Weighted Regression (Peng et al., 2019), which also used KL as a constraint. ",
+        "bbox": [
+            174,
+            647,
+            823,
+            704
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "This article proposes a new method whose lower bound of expected discounted return is greater than or equal to the bound with KL. We achieve this by replacing total variation distance by Hellinger distance, which decreases lower bound. Therefore strictness stays the same. Then we derive an offpolicy method called Hellinger Distance Constrained Regression using the new constraint. It can be used on discrete and continuous action spaces since derivation uses Lebesgue integrals rather than a summation or Riemann integrals. ",
+        "bbox": [
+            174,
+            710,
+            825,
+            795
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "2 PRELIMINARIES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            815,
+            339,
+            830
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "To better present the problem, we start from basic definitions, go through the history of improvements, and then describe the disadvantages of using KL divergence as a constraint. ",
+        "bbox": [
+            174,
+            847,
+            820,
+            875
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We consider an infinite-horizon discounted Markov decision process (MDP), defined by the tuple $( \\mathcal { S } , \\ \\mathcal { A } , \\ P , \\ r , \\ \\rho _ { 0 } , \\ \\gamma )$ , where $s$ is a set of states (finite or infinite), $\\mathcal { A }$ is a set of actions (finite or infinite), $P : \\mathcal { S } \\times \\mathcal { A } \\times \\mathcal { S } \\to \\mathbb { R }$ is the transition probability distribution, $r : \\mathcal { S } \\ \\to \\ \\mathbb { R }$ is ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "the reward function, $\\rho _ { 0 } : \\mathcal { S } \\ \\to \\ \\mathbb { R }$ is the distribution of the initial state $s _ { 0 }$ , and $\\gamma ~ \\in ~ ( 0 , 1 )$ is the discount factor. ",
+        "bbox": [
+            171,
+            102,
+            823,
+            133
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Let $\\pi$ denote a stochastic policy $\\pi : \\mathcal { S } \\times \\mathcal { A } \\to [ 0 , 1 ]$ , and then its expected discounted return is: ",
+        "bbox": [
+            171,
+            137,
+            816,
+            155
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0052cfaedb95beaa961d95514a30c3f4e9d24146c82991f66f9cf33ce87be91f.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\eta ( \\pi ) = \\mathbb { E } _ { s _ { 0 } , a _ { 0 } , \\ldots } \\left[ \\displaystyle \\sum _ { t = 0 } ^ { \\infty } \\gamma ^ { t } r ( s _ { t } ) \\right] \\mathrm { , ~ w h e r e } } \\\\ & { s _ { 0 } \\sim \\rho _ { 0 } ( \\cdot ) \\mathrm { , ~ } a _ { t } \\sim \\pi ( \\cdot | s _ { t } ) \\mathrm { , ~ } s _ { t + 1 } \\sim P ( \\cdot | s _ { t } , a _ { t } ) \\mathrm { . } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            346,
+            161,
+            650,
+            224
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "This paper uses state-action value function $Q _ { \\pi }$ , state value function $V _ { \\pi }$ , and advantage function $A _ { \\pi }$ with the following definitions: ",
+        "bbox": [
+            174,
+            237,
+            821,
+            266
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c04f02692b09da8f310e28ac9790b0f639a1bc9ecd849903add1458a6b242132.jpg",
+        "text": "$$\n\\begin{array} { c l } { \\displaystyle Q _ { \\pi } ( s _ { t } , a _ { t } ) = \\mathbb { E } _ { s _ { t + 1 } , a _ { t + 1 } , \\dots } \\left[ \\sum _ { l = 0 } ^ { \\infty } \\gamma ^ { l } r ( s _ { t + l } ) \\right] } \\\\ { \\displaystyle V _ { \\pi } ( s _ { t } ) = \\mathbb { E } _ { a _ { t } , s _ { t + 1 } , a _ { t + 1 } , \\dots } \\left[ \\sum _ { l = 0 } ^ { \\infty } \\gamma ^ { l } r ( s _ { t + l } ) \\right] } \\\\ { \\displaystyle A _ { \\pi } ( s _ { t } , a _ { t } ) = Q _ { \\pi } ( s _ { t } , a _ { t } ) - V _ { \\pi } ( s _ { t } ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            346,
+            273,
+            651,
+            381
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Let $\\rho _ { \\pi } ( s )$ be unnormalized visitation frequencies of state $s$ where actions are chosen according to $\\pi$ : ",
+        "bbox": [
+            171,
+            387,
+            823,
+            402
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2b338864a72a3f01df9be93ca362f414f5114d3000b20cf6270717590b39c234.jpg",
+        "text": "$$\n\\rho _ { \\pi } ( s ) = \\sum _ { t = 0 } ^ { \\infty } \\gamma ^ { t } P ( s _ { t } = s ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            410,
+            409,
+            588,
+            452
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Following identity expresses the expected return of another policy $\\tilde { \\pi }$ in terms of the advantage over $\\pi$ accumulated over states (see Schulman et al. (2015) for proof): ",
+        "bbox": [
+            173,
+            458,
+            821,
+            487
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b3fc04ddd686a3de42d48500b70ff837fbb907a656c75bb4de2e5668609cd5b3.jpg",
+        "text": "$$\n\\eta ( \\tilde { \\pi } ) = \\eta ( \\pi ) + \\int \\rho _ { \\tilde { \\pi } } ( s ) \\int \\tilde { \\pi } ( a | s ) A _ { \\pi } ( s , a ) d a d s .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            331,
+            493,
+            666,
+            527
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In approximately optimal learning, we replace state visitation frequency $\\rho _ { \\tilde { \\pi } }$ by $\\rho _ { \\pi }$ , since this drastically decrease optimization complexity: ",
+        "bbox": [
+            171,
+            541,
+            821,
+            570
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fe218804befb34686099918745734c8762d3a83b190bae979a0935fddc7a9c86.jpg",
+        "text": "$$\nL _ { \\pi } ( \\tilde { \\pi } ) = \\eta ( \\pi ) + \\int \\rho _ { \\pi } ( s ) \\int \\tilde { \\pi } ( a | s ) A _ { \\pi } ( s , a ) d a d s .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            326,
+            577,
+            671,
+            611
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Let $\\pi _ { o l d }$ denote current policy, then the lower bound for the expected discounted return for the new policy $\\pi _ { n e w }$ will be (see Schulman et al. (2015) for proof): ",
+        "bbox": [
+            171,
+            625,
+            825,
+            654
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e4654ac36e44a7580d4a49f2cbabef47d0819f9cb3f8378dcac3119d2a4ee994.jpg",
+        "text": "$$\n\\begin{array} { r l r } {  { \\eta ( \\pi _ { n e w } ) \\geq L _ { \\pi _ { o l d } } ( \\pi _ { n e w } ) - \\frac { 4 \\epsilon \\gamma } { ( 1 - \\gamma ) ^ { 2 } } \\alpha ^ { 2 } } } \\\\ & { } & { \\mathrm { w h e r e } \\epsilon = \\operatorname* { m a x } _ { s , a } \\vert A _ { \\pi } ( s , a ) \\vert , } \\\\ & { } & { \\alpha = \\operatorname* { m a x } _ { s } D _ { T V } ( \\pi _ { o l d } ( \\cdot \\vert s ) \\vert \\vert \\pi _ { n e w } ( \\cdot \\vert s ) ) , } \\\\ & { } & { D _ { T V } ( \\pi _ { o l d } ( \\cdot \\vert s ) \\vert \\vert \\pi _ { n e w } ( \\cdot \\vert s ) ) = \\displaystyle \\frac { 1 } { 2 } \\int  \\pi _ { o l d } ( a \\vert s ) - \\pi _ { n e w } ( a \\vert s )  d a . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            289,
+            661,
+            707,
+            777
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Theoretical Trust-Region Policy Optimization algorithm relays on Pinsker’s inequality (see (Tsybakov, 2009) for proof): ",
+        "bbox": [
+            171,
+            790,
+            825,
+            819
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1e0b16562e8bdc16bd5f4a132eafbdb3d0fee58a12b446623a557733b40f7dbe.jpg",
+        "text": "$$\n\\begin{array} { c } { { \\displaystyle D _ { K L } ( \\pi _ { o l d } ( \\cdot | s ) | | \\pi _ { n e w } ( \\cdot | s ) ) \\geq D _ { T V } ( \\pi _ { o l d } ( \\cdot | s ) | | \\pi _ { n e w } ( \\cdot | s ) ) ^ { 2 } } } \\\\ { { \\mathrm { w h e r e ~ } D _ { K L } ( \\pi _ { o l d } ( \\cdot | s ) | | \\pi _ { n e w } ( \\cdot | s ) ) = \\displaystyle \\int \\pi _ { o l d } ( a | s ) \\log \\frac { \\pi _ { o l d } ( a | s ) } { \\pi _ { n e w } ( a | s ) } d a . } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            269,
+            825,
+            723,
+            883
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To retain strictness and decrease calculation complexity, total variation distance squared was replaced with Kullback-Leibler divergence $D _ { K L } ( \\pi _ { o l d } ( \\cdot | s ) | | \\pi _ { n e w } ( \\cdot | s ) )$ : ",
+        "bbox": [
+            173,
+            895,
+            823,
+            926
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8427c222ee936f1aaf409ebf217049c5ed8b448d26bac16853996dc748faa63f.jpg",
+        "text": "$$\n\\begin{array} { r l r } {  { \\eta ( \\pi _ { n e w } ) \\geq L _ { \\pi _ { o l d } } ( \\pi _ { n e w } ) - C D _ { K L } ^ { m a x } ( \\pi _ { o l d } | | \\pi _ { n e w } ) } } \\\\ & { } & { \\mathrm { w h e r e } \\ \\epsilon = \\operatorname* { m a x } _ { s , a } | A _ { \\pi } ( s , a ) | , } \\\\ & { } & { C = \\frac { 4 \\epsilon \\gamma } { ( 1 - \\gamma ) ^ { 2 } } , } \\\\ & { } & { D _ { K L } ^ { m a x } ( \\pi _ { o l d } | | \\pi _ { n e w } ) = \\operatorname* { m a x } _ { s } D _ { K L } ( \\pi _ { o l d } ( \\cdot | s ) | | \\pi _ { n e w } ( \\cdot | s ) ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            295,
+            114,
+            699,
+            217
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "However, this replacement greatly decreases the lower bound for the expected discounted return for the new policy. Moreover, Kullback-Leibler divergence has no upper bound. Therefore we have no policy-independent lower bound for this type of update. ",
+        "bbox": [
+            174,
+            226,
+            821,
+            268
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 HELLINGER DISTANCE IN POLICY OPTIMIZATION ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            286,
+            619,
+            304
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We can improve lower bound (compared to KL) by replacing $D _ { T V } ( \\pi _ { o l d } ( \\cdot \\mid s ) \\mid \\mid \\pi _ { n e w } ( \\cdot \\mid s ) )$ with Hellinger distance $H ( \\pi _ { o l d } ( \\cdot | s ) \\mid \\mid \\pi _ { n e w } ( \\cdot \\mid s ) )$ : ",
+        "bbox": [
+            173,
+            316,
+            823,
+            348
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2b7ce269f4e55eb70ff10e42cebf0feac917050684afec256582cff2be09693c.jpg",
+        "text": "$$\nH ( \\pi _ { o l d } ( \\cdot | s ) \\mid | \\pi _ { n e w } ( \\cdot | s ) ) ^ { 2 } = 1 - \\int \\sqrt { \\pi _ { o l d } ( a | s ) \\pi _ { n e w } ( a | s ) } d a\n$$",
+        "text_format": "latex",
+        "bbox": [
+            290,
+            348,
+            707,
+            381
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Theorem 1 (see Appendix A or (Tsybakov, 2009, section 2.4) for proof) proves correctness and improvement (compared to KL) to the lower bound. ",
+        "bbox": [
+            171,
+            390,
+            823,
+            419
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Let $p ( v )$ and $q ( v )$ be two probability density functions then: ",
+        "bbox": [
+            173,
+            424,
+            568,
+            440
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/919ae461c01cb0cd196394dc1df6db9e00b6822ad84f847a96805b20959f58cf.jpg",
+        "text": "$$\nD _ { T V } ( p ( \\cdot ) \\mid \\mid q ( \\cdot ) ) ^ { 2 } \\leq 2 H ( p ( \\cdot ) \\mid \\mid q ( \\cdot ) ) ^ { 2 } \\leq D _ { K L } ( p ( \\cdot ) \\mid \\mid q ( \\cdot ) )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            300,
+            441,
+            697,
+            462
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Replacing $p ( v )$ and $q ( v )$ with $\\pi _ { o l d } ( \\cdot \\mid s )$ and $\\pi _ { n e w } ( \\cdot \\mid s )$ respectively, new lower bound follows: ",
+        "bbox": [
+            174,
+            469,
+            799,
+            486
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f5ff55f97cdfa980e55007d7111994c6d922298de2b881e6548bdf7b130f042b.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\eta ( \\pi _ { n e w } ) \\geq L _ { \\pi _ { o l d } } ( \\pi _ { n e w } ) - \\frac { 8 \\epsilon \\gamma } { ( 1 - \\gamma ) ^ { 2 } } \\alpha ^ { 2 } } \\\\ & { \\mathrm { ~ w h e r e ~ } \\epsilon = \\displaystyle \\operatorname* { m a x } _ { s , a } | A _ { \\pi } ( s , a ) | , } \\\\ & { \\quad \\quad \\quad \\alpha = \\displaystyle \\operatorname* { m a x } _ { s } H ( \\pi _ { o l d } ( \\cdot | s ) | | \\pi _ { n e w } ( \\cdot | s ) ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            361,
+            487,
+            632,
+            569
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "It is worth to note that $H ( \\pi _ { o l d } ( \\cdot \\mid s ) \\mid \\mid \\pi _ { n e w } ( \\cdot \\mid s ) ) \\leq 1 .$ ",
+        "bbox": [
+            171,
+            577,
+            547,
+            594
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "4 HELLINGER DISTANCE CONSTRAINED REGRESSION (HDCR) ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            611,
+            717,
+            630
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We could use presented lower bound as in TRPO, but instead, we derive an offline regression algorithm by introducing the following optimization problem where $\\mu$ is the sampling policy: ",
+        "bbox": [
+            171,
+            642,
+            820,
+            672
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a38868c35d2d5c744f02d5d41daf9db60d97ca34a53818888bb52fe3c96f25fc.jpg",
+        "text": "$$\n\\begin{array} { r l } {  { \\arg \\operatorname* { m a x } _ { \\pi } \\int \\rho _ { \\mu } ( s ) \\int \\pi ( a \\vert s ) A _ { \\mu } ( s , a ) d a d s } } \\\\ & { \\quad \\mathrm { s . t . } \\int \\rho _ { \\mu } ( s ) H ( \\pi ( \\cdot \\vert s ) \\vert \\vert \\mu ( \\cdot \\vert s ) ) d s \\leq \\epsilon , } \\\\ & { \\quad \\quad \\quad \\int \\pi ( a \\vert s ) d a = 1 , \\forall s \\in \\mathcal S . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            354,
+            674,
+            642,
+            773
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Constructing Lagrangian, differentiating it with respect to $\\pi$ , and solving for $\\pi$ gives us the following optimal policy (see Appendix $\\mathbf { B }$ for derivation): ",
+        "bbox": [
+            169,
+            780,
+            825,
+            809
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0f54ad0d679fd54c7ab49f857f0cee78a35c4dca0d05184fff444f4e786ff34a.jpg",
+        "text": "$$\n\\pi ^ { * } ( a | s ) = \\mu ( a | s ) { \\frac { \\beta ^ { 2 } } { ( \\beta - 2 A _ { \\mu } ( s , a ) ) ^ { 2 } } } , { \\mathrm { w h e r e ~ } } \\beta { \\mathrm { ~ i s ~ a ~ L a g r a n g i a n ~ m u l t i p l i e r . } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            261,
+            810,
+            738,
+            848
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Constructing a regression problem of $\\mathrm { K L }$ divergence between optimal policy $\\pi ^ { * }$ and current policy $\\pi$ and simplifying gives us the following supervised regression problem (see Appendix $\\mathbf { B }$ for derivation): ",
+        "bbox": [
+            174,
+            854,
+            826,
+            897
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/692ddbb84c9c8ae224a39cca32ec55c0a172e0fb2409aafeb8a1af4cf06ea99f.jpg",
+        "text": "$$\n\\underset { \\pi } { \\arg \\operatorname* { m a x } } \\mathbb { E } _ { s \\sim \\rho _ { \\mu } ( \\cdot ) } \\mathbb { E } _ { a \\sim \\mu ( \\cdot \\vert s ) } \\log \\pi ( a \\vert s ) \\frac { 1 } { ( \\beta - A _ { \\mu } ( s , a ) ) ^ { 2 } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            316,
+            895,
+            681,
+            928
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Using notation of ABM paper (Siegel et al., 2020) ”advantage-weighting” function is f (A(s, a)) = 1(β−A(s,a))2 . ",
+        "bbox": [
+            173,
+            102,
+            825,
+            136
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "If we use HDCR with Experience Replay, in equation 14, we replace $\\mu ( \\cdot | s )$ in expectation $\\mathbb { E } _ { a } \\sim \\mu ( \\cdot \\mid s )$ and advantage function $A _ { \\mu } ( s , \\ a )$ . Let $\\begin{array} { r c l } { \\Pi } & { = } & { \\{ \\pi _ { i } , \\ \\bar { \\pi _ { i + 1 } } , \\ \\xrightarrow [ ] { } \\ \\pi _ { i + N } \\} } \\end{array}$ be a set of sampling policies from which actions were sampled, $w ( \\pi _ { i } )$ probability of selecting policy $\\pi _ { i }$ , then: ",
+        "bbox": [
+            174,
+            142,
+            825,
+            199
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b2d0d062973bd567be59ce10f86c2dd8c43456ec8f266ed486b1847d59b7404c.jpg",
+        "text": "$$\n\\begin{array} { c l l } { { } } & { { } } & { { \\displaystyle \\mu ( s , a ) = \\int _ { \\Pi } w ( \\pi ) \\rho _ { \\pi } ( s ) \\pi ( a | s ) ~ d \\pi } } \\\\ { { } } & { { } } & { { \\displaystyle A _ { \\mu } ( s , a ) = \\frac { \\int _ { \\Pi } w ( \\pi ) \\rho _ { \\pi } ( s ) ~ ( Q _ { \\pi } ( s , a ) - V _ { \\pi } ( s ) ) ~ d \\pi } { \\int _ { \\Pi } w ( \\pi ) \\rho _ { \\pi } ( s ) ~ d \\pi } } } \\\\ { { } } & { { } } & { { \\displaystyle \\overline { { { V } } } ( s ) = \\frac { \\int _ { \\Pi } w ( \\pi ) \\rho _ { \\pi } ( s ) V _ { \\pi } ( s ) ~ d \\pi } { \\int _ { \\Pi } w ( \\pi ) \\rho _ { \\pi } ( s ) ~ d \\pi } } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            330,
+            200,
+            668,
+            313
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The proof will repeat the proof for AWR with Experience Replay (Peng et al., 2019). ",
+        "bbox": [
+            173,
+            319,
+            730,
+            335
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Practically we simply sample uniformly from the replay buffer and using a value function estimator.   \nThis type of sampling provides us an approximation of expectation and state value function. ",
+        "bbox": [
+            171,
+            340,
+            820,
+            369
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Let $\\mathcal { D }$ denote a set of stored trajectories (replay buffer), $A ( s , a ; \\phi )$ is an advantage function parameterized by vector $\\phi$ . ",
+        "bbox": [
+            171,
+            376,
+            821,
+            405
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The most popular method to obtain $A ( s , a ; \\phi )$ for offline learning is to use state-action function estimator $Q ( s , a ; \\phi )$ parameterized by $\\phi$ : ",
+        "bbox": [
+            174,
+            411,
+            823,
+            440
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4adf042f26ce21a8d56ad406aa40a9c480034235a4f0615810c84fb80c88fc05.jpg",
+        "text": "$$\nA ( s , a ; \\phi ) = Q ( s , a ; \\phi ) - \\int \\pi ( a ^ { \\prime } | s ; \\theta _ { k } ) Q ( s , a ^ { \\prime } ; \\phi _ { k } ) d a ^ { \\prime }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            315,
+            444,
+            681,
+            477
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Despite $Q ( s , a ; \\phi )$ being closer to the expectation of discounted return following policy $\\pi$ (because of ”taking” the first action according to $\\pi$ rather then $\\mu$ ), we found Monte-Carlo return more efficient on tiny offline datasets. Greater performance using MC return can be explained by a lack of experience ”produced” by certain actions. ",
+        "bbox": [
+            173,
+            488,
+            826,
+            544
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Monte-Carlo estimation of $A ( s , a ; \\phi )$ can be described as follows where $\\begin{array} { r } { \\mathcal { R } _ { s _ { t } , a _ { t } } ^ { \\mathcal { D } } ~ = ~ \\sum _ { l = 0 } ^ { T } \\gamma ^ { l } r _ { t + l } } \\end{array}$ is a state value function estimator parameterized by vector ",
+        "bbox": [
+            168,
+            551,
+            823,
+            583
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/782f8fd067c9d4b5546687e390e1b005ab8cc3d61d9740768c84fa1803a3a30f.jpg",
+        "text": "$$\nA ( s , a ; \\phi ) = \\mathcal { R } _ { s , a } ^ { \\mathcal { D } } - V ( s ; \\phi )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            401,
+            588,
+            596,
+            608
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Also, we can use Generalized Advantage Estimation (Schulman et al., 2016), where $\\gamma \\in \\ [ 0 , 1 ]$ and $\\delta _ { t } ^ { \\phi _ { k } }$ is a one-step temporal difference for state $s _ { t }$ calculated using old vector $\\phi _ { k }$ : ",
+        "bbox": [
+            174,
+            618,
+            826,
+            651
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/655077e77539d6e033a8e0ccf0a233450776e06b987635ff9d6015cf3a797379.jpg",
+        "text": "$$\n\\begin{array} { c } { { \\delta _ { t } ^ { \\phi _ { k } } = r _ { t } + \\gamma V ( s _ { t + 1 } ; \\phi _ { k } ) - V ( s _ { t } ; \\phi _ { k } ) } } \\\\ { { { } } } \\\\ { { \\displaystyle \\hat { A } ( s _ { t } , a _ { t } ; \\phi _ { k } ) = \\sum _ { l = 0 } ^ { T } ( \\gamma \\lambda ) ^ { l } \\delta _ { t + l } ^ { \\phi _ { k } } } } \\\\ { { { } } } \\\\ { { { } A ( s _ { t } , a _ { t } ; \\phi ) = \\hat { A } ( s _ { t } , a _ { t } ; \\phi _ { k } ) + V ( s _ { t } ; \\phi _ { k } ) - V ( s _ { t } ; \\phi ) } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            321,
+            655,
+            678,
+            742
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Finally, we propose the following reinforcement learning algorithm: ",
+        "bbox": [
+            173,
+            751,
+            620,
+            767
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1: Hellinger Distance Constrained Regression ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            785,
+            552,
+            800
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/7b2b4fc1a46a2017a3e52b60b18cc664ad7ba3135c9d59e0c76f6ca3e9c415bc.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>0←randominitial weights D↑の</td></tr><tr><td>for iteration k = 1,..., kmax do add trajectories {Ti} sampled via π0k to D</td></tr><tr><td>Φk+1 ← arg minf Es,a~DA²(s,a;)</td></tr><tr><td>0k+1 ← arg maxθ Es,a~D [logTe(a|s)(β-A(s,a;Φx))] end</td></tr></table>",
+        "bbox": [
+            173,
+            804,
+            560,
+            914
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/92044249a5e261e1b7f35762fc724ef17bdd1838b3e5fe9a7dc4a0ff46f28e8d.jpg",
+        "image_caption": [
+            "Figure 1: Learning curves of ABM, AWR, and HDCR averaged across results of learning from 10 different datasets of 10k timestamps (also 5 seeds used to generate each dataset). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            108,
+            820,
+            218
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/a6b42f54ffa7cbb2ddc2d62249e8223698b36bcf25f7254588cd7b48aeee30ca.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Task</td><td rowspan=1 colspan=1>ABM</td><td rowspan=1 colspan=1>AWR</td><td rowspan=1 colspan=1>HDCR (Ours)</td></tr><tr><td rowspan=1 colspan=1>Ant-v2</td><td rowspan=1 colspan=1>468±72</td><td rowspan=1 colspan=1>495 ± 84</td><td rowspan=1 colspan=1>569± 64</td></tr><tr><td rowspan=1 colspan=1>HalfCheetah-v2</td><td rowspan=1 colspan=1>-7±3</td><td rowspan=1 colspan=1>-7±4</td><td rowspan=1 colspan=1>-8±6</td></tr><tr><td rowspan=1 colspan=1>Hopper-v2</td><td rowspan=1 colspan=1>184 ± 72</td><td rowspan=1 colspan=1>209 ± 31</td><td rowspan=1 colspan=1>223±141</td></tr><tr><td rowspan=1 colspan=1>Walker2d-v2</td><td rowspan=1 colspan=1>132 ± 76</td><td rowspan=1 colspan=1>125 ± 92</td><td rowspan=1 colspan=1>145 ± 117</td></tr></table>",
+        "bbox": [
+            294,
+            268,
+            702,
+            344
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Table 1: Final returns for different algorithms, with $\\pm$ corresponding to one standard deviation of the average return across 10 datasets of 10k timestamps. ",
+        "bbox": [
+            173,
+            361,
+            825,
+            390
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "5 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            411,
+            326,
+            428
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In our experiments, we evaluate the algorithm on MuJoCo (Todorov et al., 2012) tasks. ",
+        "bbox": [
+            174,
+            443,
+            740,
+            458
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "5.1 TINY DATASETS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            473,
+            326,
+            488
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For evaluating on extremely small datasets we use setting inspired by Behavioral Modelling Priors for Offline Reinforcement Learning paper (Siegel et al., 2020) but instead of using actions from a behaviorial policy we use random actions while generating buffer. ",
+        "bbox": [
+            174,
+            500,
+            823,
+            542
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "First, we collect 2048 timestamps or more, until episode termination (whichever occurred later), from each of 5 seeds using random actions. Then we load collected trajectories to a replay buffer for the agent training. Separate networks with the same architecture (except the last layer) represent the policy and value function and consist of 2 hidden layers of 256 ELU units. Each train iteration uses only old data obtained by random agents. Each iteration, the value function is updating with 5 gradient steps and policy with 50 steps using a uniformly sampled batches of 512 samples using all data from the replay buffer. Learning rates for Adam optimizer are $2 \\times 1 0 ^ { - 3 }$ and $2 \\times 1 \\bar { 0 } ^ { - 4 }$ for critic and actor, respectively. ",
+        "bbox": [
+            173,
+            549,
+            825,
+            661
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We compare 3 different ”advantage-weight” functions $f ( A ( s , a ) )$ : ",
+        "bbox": [
+            174,
+            666,
+            607,
+            683
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "• Hellinger Distance Constrained Regression, where f (A(s, a)) = 1(β−A(s,a))2 ; • Advantage-weighted Behavior Model, where $f ( A ( s , a ) ) = I _ { A ( s , a ) > 0 }$ , $I _ { x > 0 } = 1$ if $x > 0$ otherwise $I _ { x > 0 } = 0$ ; • Advantage-Weighted Regression, where $\\begin{array} { r } { f ( A ( s , a ) ) = \\exp ( \\frac { 1 } { \\beta } A ( s , a ) ) } \\end{array}$ . ",
+        "bbox": [
+            217,
+            691,
+            825,
+            765
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "AWR method uses $\\beta = 1 . 0$ as it is in implementation released by authors. HDCR uses $\\beta = 1 . 0$ . For $\\mathrm { T D } ( \\lambda )$ we use $\\lambda = 0 . 9 5$ . ",
+        "bbox": [
+            173,
+            775,
+            823,
+            803
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "On simple tasks as Hopper-v2, all methods are able to learn (Figure 1), and HDCR shows slightly better results (Table 1). While on difficult tasks as Ant-v2, all algorithms do not improve their results through iterations. Moreover, evaluation returns decrease. ",
+        "bbox": [
+            174,
+            810,
+            825,
+            853
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "5.2 LARGE DATASETS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            869,
+            338,
+            883
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Next, we perform tests using buffers with the size of 100k timesteps. Buffer is filled by running a pretrained behavioral policy. This setting replicates the setting from Off-Policy Deep Reinforce",
+        "bbox": [
+            176,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/41cd88b6b8977bcc608ad040c4f8b59c3ecd513ee6dbda0b5c7d48588997ffc4.jpg",
+        "image_caption": [
+            "Figure 2: Curves of BCQ, ABM, AWR, and HDCR evaluation results averaged across 3 seeds. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            108,
+            820,
+            218
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/9e5de773cfecc61605c26cdd1fca15a49a0200f80635ba348aaa5cdde438539f.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Task</td><td rowspan=1 colspan=1>ABM</td><td rowspan=1 colspan=1>AWR</td><td rowspan=1 colspan=1>HDCR (Ours)</td></tr><tr><td rowspan=1 colspan=1>Ant-v2</td><td rowspan=1 colspan=1>179 ± 45</td><td rowspan=1 colspan=1>281± 25</td><td rowspan=1 colspan=1>217 ± 54</td></tr><tr><td rowspan=1 colspan=1>HalfCheetah-v2</td><td rowspan=1 colspan=1>3358 ± 76</td><td rowspan=1 colspan=1>3365 ± 193</td><td rowspan=1 colspan=1>3485± 205</td></tr><tr><td rowspan=1 colspan=1>Hopper-v2</td><td rowspan=1 colspan=1>495 ± 115</td><td rowspan=1 colspan=1>478±94</td><td rowspan=1 colspan=1>576± 123</td></tr><tr><td rowspan=1 colspan=1>Walker2d-v2</td><td rowspan=1 colspan=1>592 ± 139</td><td rowspan=1 colspan=1>762 ± 64</td><td rowspan=1 colspan=1>805± 62</td></tr></table>",
+        "bbox": [
+            281,
+            252,
+            715,
+            328
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Table 2: Final returns for different algorithms, with $\\pm$ corresponding to one standard deviation of the average return across 3 seeds. ",
+        "bbox": [
+            173,
+            344,
+            823,
+            372
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "ment Learning without Exploration (Fujimoto et al., 2019) paper. Therefore we also provide results of BCQ method achieved by authors’ implementation trained from the same datasets. For calculating advantage we use equation 16 where we approximate integral by taking mean of $1 0 \\ \\mathrm { Q }$ -values obtained by 10 actions sampled from the policy. ",
+        "bbox": [
+            174,
+            396,
+            825,
+            452
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "While BCQ outperforms all the presented methods, it uses a gradient of Q-value function in actor training, which provides better generalization. This provides better results on evaluation but affects stability and performance. Against other methods that update the policy function directly, HDCR shows better results on 3 environments out of 4 (Figure 2 and Table 2). ",
+        "bbox": [
+            174,
+            459,
+            825,
+            515
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "6 DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            534,
+            310,
+            550
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We theoretically proved that Hellinger distance improves the lower bound of expected discounted return compared to Kullback-Leibler divergence and proposed a simple off-policy reinforcement learning method that uses Hellinger distance as a constraint. The expected discounted return for a new policy now has a policy-independent lower bound. This bound guarantees that return will not decrease in ”one” shot. ",
+        "bbox": [
+            174,
+            565,
+            825,
+            636
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Experiments show that HDCR outperforms both ABM and AWR on tiny datasets obtained by random agents. This performance proves the efficiency of using Hellinger distance by allowing bigger step sizes, retaining lower bound. ",
+        "bbox": [
+            176,
+            642,
+            823,
+            684
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "On bigger datasets, HDCR shows comparable or better results than AWR and ABM. ",
+        "bbox": [
+            176,
+            691,
+            723,
+            707
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            727,
+            287,
+            742
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Scott Fujimoto, David Meger, and Doina Precup. Off-policy deep reinforcement learning without exploration, 2019. ",
+        "bbox": [
+            173,
+            750,
+            823,
+            777
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Sham Kakade and John Langford. Approximately optimal approximate reinforcement learning. In Proceedings of the Nineteenth International Conference on Machine Learning, ICML ’02, pp. 267–274, San Francisco, CA, USA, 2002. Morgan Kaufmann Publishers Inc. ISBN 1558608737. ",
+        "bbox": [
+            174,
+            785,
+            825,
+            828
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "David Levin and Yuval Peres. Markov Chains and Mixing Times. 2017. doi: 10.1090/mbk/107. ",
+        "bbox": [
+            174,
+            835,
+            800,
+            852
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Xue Bin Peng, Aviral Kumar, Grace Zhang, and Sergey Levine. Advantage-weighted regression: Simple and scalable off-policy reinforcement learning, 2019. ",
+        "bbox": [
+            176,
+            858,
+            820,
+            887
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "John Schulman, Sergey Levine, Pieter Abbeel, Michael Jordan, and Philipp Moritz. Trust region policy optimization. volume 37 of Proceedings of Machine Learning Research, pp. 1889–1897, ",
+        "bbox": [
+            176,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Lille, France, 07–09 Jul 2015. PMLR. URL http://proceedings.mlr.press/v37/ schulman15.html. ",
+        "bbox": [
+            181,
+            103,
+            820,
+            132
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "John Schulman, Philipp Moritz, Sergey Levine, Michael Jordan, and Pieter Abbeel. Highdimensional continuous control using generalized advantage estimation. In Proceedings of the International Conference on Learning Representations (ICLR), 2016. ",
+        "bbox": [
+            174,
+            141,
+            823,
+            184
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Noah Siegel, Jost Tobias Springenberg, Felix Berkenkamp, Abbas Abdolmaleki, Michael Neunert, Thomas Lampe, Roland Hafner, Nicolas Heess, and Martin Riedmiller. Keep doing what worked: Behavior modelling priors for offline reinforcement learning. In International Conference on Learning Representations, 2020. URL https://openreview.net/forum?id $=$ rke7geHtwH. ",
+        "bbox": [
+            173,
+            193,
+            825,
+            263
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "E. Todorov, T. Erez, and Y. Tassa. Mujoco: A physics engine for model-based control. In 2012 IEEE/RSJ International Conference on Intelligent Robots and Systems, pp. 5026–5033, 2012. ",
+        "bbox": [
+            174,
+            271,
+            823,
+            301
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Alexandre B. Tsybakov. Introduction to Nonparametric Estimation. Springer New York, 2009. doi: 10.1007/b13794. URL https://doi.org/10.1007%2Fb13794. ",
+        "bbox": [
+            176,
+            310,
+            825,
+            338
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "A THEOREM 1 PROOF ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            370,
+            118
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Let $( \\Omega , A )$ be a measurable space, $P$ and $Q$ be two probability measures on that space, $v$ be a $\\sigma$ -finite measure on $( \\Omega , A )$ such that $P \\ll v ( P ( A ) = 0$ for any $A \\in { \\mathcal { A } }$ such that $\\mu ( A ) = 0 ,$ ) and $Q \\ll v$ . And let us denote Radon–Nikodym derivatives (in our derivations we can assume them as probability density functions) as follows: ",
+        "bbox": [
+            173,
+            132,
+            825,
+            189
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/50323fe35a7076a6e9903c47bd498a404bdfe3182b74ee88b8105835500e2232.jpg",
+        "text": "$$\n\\begin{array} { c } { p = \\displaystyle \\frac { d P } { d v } } \\\\ { q = \\displaystyle \\frac { d Q } { d v } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            467,
+            189,
+            529,
+            255
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "So, $p$ and $q$ satisfy following conditions: ",
+        "bbox": [
+            173,
+            261,
+            439,
+            275
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fe286d5fbb58a5b6830d631cf6cf17d1f96c9d9c1856b9e92034186e5390f8bf.jpg",
+        "text": "$$\n\\begin{array} { l } { { P ( A ) = \\displaystyle \\int _ { A } p ( v ) ~ d v ~ \\forall A \\in { \\mathcal A } } } \\\\ { { Q ( A ) = \\displaystyle \\int _ { A } q ( v ) ~ d v ~ \\forall A \\in { \\mathcal A } } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            398,
+            277,
+            599,
+            345
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Then we define distances between probability measures: ",
+        "bbox": [
+            173,
+            352,
+            544,
+            367
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1f780cbccba07bd78c3dcd855dbd24bd9b38b001a71c0399626a00b64189ad05.jpg",
+        "text": "$$\n\\begin{array} { l } { { \\displaystyle D _ { T V } ( P \\parallel Q ) = \\operatorname* { s u p } _ { A \\in \\mathcal { A } } | P ( A ) - Q ( A ) | } } \\\\ { { \\displaystyle H ( P \\parallel Q ) ^ { 2 } = \\frac { 1 } { 2 } \\int ( \\sqrt { p ( v ) } - \\sqrt { q ( v ) } ) ^ { 2 } d v = 1 - \\int \\sqrt { p ( v ) q ( v ) } d v } } \\\\ { { \\displaystyle D _ { K L } ( P \\parallel Q ) = \\int \\log \\frac { d P } { d Q } d P = \\int p ( v ) \\log \\frac { p ( v ) } { q ( v ) } d v } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            264,
+            385,
+            730,
+            483
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Following Lemmas will be used in Theorem 1 proof: ",
+        "bbox": [
+            173,
+            489,
+            522,
+            505
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Lemma 1. Given two probability distributions $p$ and $q$ total variance divergence can be calculated as follows: ",
+        "bbox": [
+            171,
+            507,
+            825,
+            534
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0ee13613d449ee7c9af0e01d12128774bfe5ff55106e6eab0267b3c632e0464a.jpg",
+        "text": "$$\nD _ { T V } ( P \\parallel Q ) = \\operatorname* { s u p } _ { A \\in { \\mathcal A } } \\left| P ( A ) - Q ( A ) \\right| = \\frac 1 2 \\int \\left| p ( v ) - q ( v ) \\right| d v\n$$",
+        "text_format": "latex",
+        "bbox": [
+            290,
+            532,
+            707,
+            565
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/810a85cac38551dde58b8692d628283ea8e55b011eadd982349b6360d705b647.jpg",
+        "text": "$$\n\\begin{array} { c } { { P ( A ) - Q ( A ) \\leq P ( A \\cap B ) - Q ( A \\cap B ) \\leq P ( B ) - Q ( B ) } } \\\\ { { P ( A ) - Q ( A ) \\leq Q ( A \\cap B ^ { c } ) - P ( A \\cap B ^ { c } ) \\leq Q ( B ^ { c } ) - P ( B ^ { c } ) } } \\\\ { { \\displaystyle \\operatorname* { s u p } _ { A \\in { \\cal A } } | P ( A ) - Q ( A ) | = P ( B ) - Q ( B ) = Q ( B ^ { c } ) - P ( B ^ { c } ) } } \\\\ { { \\displaystyle D _ { T V } ( P \\mid \\mid Q ) = \\frac { 1 } { 2 } [ P ( B ) - Q ( B ) + Q ( B ^ { c } ) - P ( B ^ { c } ) ] } } \\\\ { { \\displaystyle \\qquad = \\frac { 1 } { 2 } \\int \\left| p ( v ) - q ( v ) \\right| d v } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            263,
+            597,
+            732,
+            724
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Lemma 2. ",
+        "bbox": [
+            173,
+            753,
+            246,
+            767
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/aaabb55151a899405c5b57dc4a9bb6cf36923fd876c4b505089a5f9c04d60074.jpg",
+        "text": "$$\nD _ { T V } ( P \\mid | Q ) = 1 - \\int \\operatorname* { m i n } ( p ( v ) , q ( v ) ) \\ d v\n$$",
+        "text_format": "latex",
+        "bbox": [
+            356,
+            763,
+            643,
+            795
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Proof. ",
+        "bbox": [
+            173,
+            808,
+            217,
+            823
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2e6a4992dab9da300f07a8931f7733629d4aac7b5a7f8a0bd92b02ee7ec99faa.jpg",
+        "text": "$$\n\\begin{array} { l } { { \\displaystyle D _ { T V } ( P \\mid \\mid Q ) = \\frac { 1 } { 2 } \\int \\left. p ( v ) - q ( v ) \\right. d v = \\int _ { \\{ v : p ( v ) > q ( v ) \\} } [ p ( v ) - q ( v ) ] d v } } \\\\ { { \\displaystyle \\qquad = 1 - \\int _ { \\{ v : p ( v ) < q ( v ) \\} } p ( v ) d v - \\int _ { \\{ v : p ( v ) > q ( v ) \\} } q ( v ) d v } } \\\\ { { \\displaystyle \\qquad = 1 - \\int \\operatorname* { m i n } ( p ( v ) , q ( v ) ) d v } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            256,
+            825,
+            740,
+            931
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Lemma 3. ",
+        "bbox": [
+            173,
+            126,
+            246,
+            140
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "equation",
+        "img_path": "images/34f5206e2df2e60eaf6e453fdfb537c8f1107b38b1e56d8788a86ef0fc573db8.jpg",
+        "text": "$$\n\\int \\operatorname* { m a x } ( p ( v ) , q ( v ) ) d v + \\int \\operatorname* { m i n } ( p ( v ) , q ( v ) ) d v = 2\n$$",
+        "text_format": "latex",
+        "bbox": [
+            325,
+            135,
+            676,
+            169
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Proof. Rewriting left part in 4 integrals over following sets $\\begin{array} { r l r } { \\{ \\operatorname* { m a x } ( p ( v ) , q ( v ) ) } & { { } = { } } & { p ( v ) \\} } \\end{array}$ , $\\{ \\operatorname* { m a x } ( p ( v ) , q ( v ) ) ~ = ~ \\bar { q } ( v ) \\}$ , $\\{ \\operatorname* { m i n } ( \\bar { p ( \\boldsymbol { v } ) } , \\boldsymbol { q } ( \\boldsymbol { v } ) ) = q ( \\boldsymbol { v } ) \\bar  \\}$ and $\\{ \\operatorname* { m i n } ( p ( v ) , q ( v ) ) \\ = \\ q ( v ) \\}$ and stacking integrals back gives us $P ( \\Omega ) + Q ( \\Omega ) = 2$ . □ ",
+        "bbox": [
+            174,
+            181,
+            826,
+            226
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Theorem 1. For any two probability density functions $p$ and $q$ , the following double inequality is true: ",
+        "bbox": [
+            165,
+            231,
+            823,
+            257
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0bac497ab325184475141e0d826946b763f21f26210e3928e93771f1b783cf5e.jpg",
+        "text": "$$\nD _ { T V } ( p \\vert \\vert q ) ^ { 2 } \\leq 2 H ( p \\vert \\vert q ) ^ { 2 } \\leq D _ { K L } ( p \\vert \\vert q )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            352,
+            256,
+            645,
+            276
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Proof. First inequality can be proved as follows: ",
+        "bbox": [
+            173,
+            289,
+            495,
+            304
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a4f2193b0c75dbeaa9cd2850eea76a23f03c68a8aa9abbf0d74561d6a14f991a.jpg",
+        "text": "$$\n\\begin{array} { r l } { ( 1 - H ( P | | Q | ^ { 2 } ) ^ { 2 } ) = \\left[ \\int \\sqrt { p ( v ) q ( v ) } d v \\right] ^ { 2 } } \\\\ & { = \\left[ \\int \\sqrt { \\operatorname* { m i n } ( p ( v ) , q ( v ) ) \\operatorname* { m a x } ( p ( v ) , q ( v ) ) } d v \\right] ^ { 2 } } \\\\ & { \\leq \\int \\operatorname* { m i n } ( p ( v ) , q ( v ) ) d v \\int \\operatorname* { m a x } ( p ( v ) , q ( v ) ) d v } \\\\ & { = \\int \\operatorname* { m i n } ( p ( v ) , q ( v ) ) d v \\left[ 2 - \\int \\operatorname* { m i n } ( p ( v ) , q ( v ) ) d v \\right] } \\\\ & { = ( 1 - D _ { T V } ( P | | Q ) ) ( 1 + D _ { T V } ( P | | Q ) ) } \\\\ & { = 1 - D _ { T V } ( P | | Q ) ^ { 2 } } \\\\ { D v _ { T V } ( P | | Q ) ^ { 2 } \\leq H ( P | | Q ) ^ { 2 } ( 2 - H ( P | | Q ) ^ { 2 } ) } \\\\ & { D _ { T V } ( P | | Q ) ^ { 2 } \\leq 2 H ( P | | Q ) ^ { 2 } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            253,
+            306,
+            745,
+            530
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Proof of the second inequality: ",
+        "bbox": [
+            173,
+            536,
+            377,
+            551
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "equation",
+        "img_path": "images/81e8f089ebdff526acbc9da1d1c361bef73fbd00a08f5c29edaeaf30c7bf9e37.jpg",
+        "text": "$$\n\\begin{array} { r l } & { D _ { K L } ( P \\parallel Q ) = \\displaystyle \\int p ( v ) \\log \\frac { p ( v ) } { q ( v ) } d v = 2 \\int p ( v ) \\log \\sqrt { \\frac { p ( v ) } { q ( v ) } } d v } \\\\ & { \\qquad = - 2 \\int p ( v ) \\log \\left( \\left[ \\sqrt { \\frac { q ( v ) } { p ( v ) } } - 1 \\right] + 1 \\right) d v } \\\\ & { \\qquad \\geq - 2 \\int p ( v ) \\left[ \\sqrt { \\frac { q ( v ) } { p ( v ) } } - 1 \\right] \\ d v = - 2 \\int \\left[ \\sqrt { q ( v ) p ( v ) } - 1 \\right] \\ d v } \\\\ & { \\qquad = 2 \\left[ 1 - \\int \\sqrt { p ( v ) q ( v ) } \\ d v \\right] = 2 H ( P \\parallel Q ) ^ { 2 } } \\\\ & { D _ { K L } ( P \\parallel Q ) \\geq 2 H ( P \\parallel Q ) ^ { 2 } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            236,
+            555,
+            758,
+            742
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "B HDCR DERIVATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            781,
+            375,
+            799
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Given optimization problem: ",
+        "bbox": [
+            174,
+            813,
+            364,
+            828
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1b4fd0e1ec6d9e1ec208f6e1ae54e3a99cf2380f7ef4f9c61f32a7dda66fa14f.jpg",
+        "text": "$$\n\\begin{array} { r l } {  { \\arg \\operatorname* { m a x } _ { \\pi } \\int \\rho _ { \\mu } ( s ) \\int \\pi ( a \\vert s ) A _ { \\mu } ( s , a ) d a d s } } \\\\ & { \\quad \\mathrm { s . t . } \\int \\rho _ { \\mu } ( s ) H ( \\pi ( \\cdot \\vert s ) \\vert \\vert \\mu ( \\cdot \\vert s ) ) d s \\leq \\epsilon , } \\\\ & { \\quad \\quad \\quad \\int \\pi ( a \\vert s ) d a = 1 , \\forall s \\in \\mathcal S . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            354,
+            829,
+            640,
+            929
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Constructing Lagrangian where $\\alpha : \\mathcal { S } \\ \\to \\ \\mathbb { R }$ is a function for obtaining Lagrange multiplier for every state, $\\beta$ is also a Lagrange multiplier: ",
+        "bbox": [
+            173,
+            102,
+            823,
+            133
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d0621342bbee4a6c5fb20f20dfa6cb063878fe650f2c8bdd63bfe2178277653e.jpg",
+        "text": "$$\n\\begin{array} { l } { \\displaystyle \\mathcal { L } ( \\pi , \\beta , \\alpha ) = \\int _ { s } \\rho _ { \\mu } ( s ) \\int _ { a } \\pi ( a | s ) A _ { \\mu } ( s , a ) d a d s } \\\\ { \\displaystyle \\qquad + \\beta \\left( \\epsilon - \\int _ { s } \\rho _ { \\mu } ( s ) \\left[ 1 - \\int \\sqrt { \\pi ( a | s ) \\mu ( a | s ) } d a \\right] d s \\right) } \\\\ { \\displaystyle \\qquad + \\int _ { s } \\alpha _ { s } \\left( 1 - \\int _ { a } \\pi ( a | s ) d a \\right) d s } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            287,
+            136,
+            710,
+            242
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Differentiating with respect to $\\pi ( a | s )$ gives us following result: ",
+        "bbox": [
+            173,
+            250,
+            589,
+            266
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7a2a95e6a3665f80752cd7a5c2b898b40e816ab8a2cf9ffc5ddd45c0b341beab.jpg",
+        "text": "$$\n\\frac { \\partial \\mathcal { L } } { \\partial \\pi ( a | s ) } = \\rho _ { \\mu } ( s ) A _ { \\mu } ( s , a ) + \\beta \\rho _ { \\mu } ( s ) \\frac { \\mu ( a | s ) } { 2 \\sqrt { \\pi ( a | s ) \\mu ( a | s ) } } - \\alpha _ { s } = 0\n$$",
+        "text_format": "latex",
+        "bbox": [
+            285,
+            270,
+            714,
+            306
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Solving for $\\pi ( a | s )$ : ",
+        "bbox": [
+            173,
+            318,
+            302,
+            333
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7e80fd6ed89c646e183c12d177b78571e4d3d0bc7edb94ae6a7a7c1ccf84b8f6.jpg",
+        "text": "$$\n\\begin{array} { r l r } & { } & { \\beta \\rho _ { \\mu } ( s ) \\frac { \\mu ( a | s ) } { 2 \\sqrt { \\pi ( a | s ) \\mu ( a | s ) } } = \\alpha _ { s } - \\rho _ { \\mu } ( s ) A _ { \\mu } ( s , a ) } \\\\ & { } & { \\frac { \\sqrt { \\mu ( a | s ) } } { \\sqrt { \\pi ( a | s ) } } = 2 \\frac { \\frac { \\alpha _ { s } } { \\rho _ { \\mu } ( s ) } - A _ { \\mu } ( s , a ) } { \\beta } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            338,
+            337,
+            660,
+            415
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Substituting $\\pi ( a | s ) = \\mu ( \\cdot | s )$ and taking expectation over actions taken according to $\\mu$ gives us expression for $\\alpha _ { s }$ : ",
+        "bbox": [
+            173,
+            424,
+            825,
+            454
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5ab965064b2af99070e54157008845ae24e5e7326bf9f417997e6de6b723d5da.jpg",
+        "text": "$$\n\\begin{array} { c } { { 1 = 2 \\displaystyle \\frac { \\frac { \\alpha _ { s } } { \\rho _ { \\mu } ( s ) } - A _ { \\mu } ( s , a ) } { \\beta } } } \\\\ { { { } } } \\\\ { { \\mathbb { E } _ { a \\sim \\mu ( \\cdot | s ) } \\alpha _ { s } = \\alpha _ { s } = \\rho _ { \\mu } ( s ) \\mathbb { E } _ { a \\sim \\mu ( \\cdot | s ) } \\left[ \\displaystyle \\frac { 1 } { 2 } \\beta + A _ { \\mu } ( s , a ) \\right] = \\displaystyle \\frac { 1 } { 2 } \\beta \\rho _ { \\mu } ( s ) } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            277,
+            455,
+            722,
+            531
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Then optimal policy $\\pi ^ { * } ( a | s )$ can be written as follows: ",
+        "bbox": [
+            173,
+            540,
+            534,
+            556
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "equation",
+        "img_path": "images/49bb9c00dd6f895912743daf5c123f39846908fd3ce6763786fe8e6b38d1d06a.jpg",
+        "text": "$$\n\\pi ^ { * } ( a | s ) = \\mu ( a | s ) { \\frac { \\beta ^ { 2 } } { ( \\beta - 2 A _ { \\mu } ( s , a ) ) ^ { 2 } } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            379,
+            559,
+            617,
+            595
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "To obtain regression problem we construct Kullback–Leibler divergence between optimal policy $\\pi ^ { * }$ and current policy $\\pi$ : ",
+        "bbox": [
+            174,
+            606,
+            823,
+            635
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0f533979c79f40a487ed2767dc2863f4eef1aeeb79ca3fa4868ab52f88bcd050.jpg",
+        "text": "$$\n\\begin{array} { r l } &  \\begin{array} { r l } & { \\mathrm { a r g } _ { \\alpha } ^ { \\mathrm { L i n } } \\mathrm { i n } \\mathbb { E } _ { s \\sim p _ { \\ell } ( s ) } \\mathcal { D } _ { K L } ( \\overline { { \\mathbf { x } } } ^ { \\star } ( \\cdot | s ) | ) \\pi ( \\cdot | s ) } \\\\ & { = \\mathrm { a r g } _ { \\alpha } ^ { \\mathrm { L i n } } \\mathrm { i n } \\mathbb { E } _ { s \\sim p _ { \\ell } ( s ) } \\int \\pi ^ { \\star } ( a | s ) \\log \\frac { \\pi ^ { \\star } ( a | s ) } { \\pi ( a | s ) } d a } \\\\ & { = \\mathrm { a r g } _ { \\alpha } ^ { \\mathrm { n i n } } \\mathrm { E } _ { s \\sim p _ { \\ell } ( s ) } \\int \\mu ( a | s ) \\frac { \\beta ^ { 2 } } { ( \\beta - 2 A _ { \\nu } ( s , a ) ) ^ { 2 } } \\log \\frac { \\mu ( a | s ) \\frac { \\beta ^ { 2 } } { ( \\beta - 2 A _ { \\nu } ( s , a ) ) ^ { 2 } } } { \\pi ( a | s ) } d a } \\\\ & { = \\mathrm { a r g } _ { \\alpha } ^ { \\mathrm { n i n } } \\mathrm { E } _ { s \\sim p _ { \\ell } ( s ) } \\mathbb { E } _ { \\alpha \\sim p _ { \\ell } ( s ) } \\frac { 1 } { \\mathrm { B a s } \\pi ( s , a ) ( \\beta - 2 A _ { \\nu } ( s , a ) ) ^ { 2 } } \\left[ \\log \\left( \\mu ( a | s ) \\frac { \\beta ^ { 2 } } { ( \\beta - 2 A _ { \\nu } ( s , a ) ) ^ { 2 } } \\right) - \\log \\pi ( a | s ) \\right] } \\\\ & { = \\mathrm { a r g } _ { \\alpha } ^ { \\mathrm { n i n } } \\mathrm { E } _ { s \\sim p _ { \\ell } ( s ) } \\mathbb { E } _ { \\alpha \\sim p _ { \\ell } ( s ) } \\log \\pi ( a | s ) \\frac { 1 } { ( \\beta - 2 A _ { \\nu } ( s , a ) ) ^ { 2 } } \\left[ \\log \\left( \\mu ( a | s ) \\frac { \\beta ^ { 2 } } { ( \\beta - 2 A _ { \\mu } ( s , a ) ) ^ { 2 } } \\right) - \\log \\pi ( a | s ) \\right] } \\\\ & { = \\mathrm { a r g } _ { \\alpha } ^ { \\mathrm { n a x } } \\mathbb { E } _ { s \\sim p _ { \\ell } ( s ) } \\mathbb { E } _ { \\alpha \\sim p _ { \\ell } ( s ) } \\log \\pi ( a | s ) \\frac { 1 } { ( \\beta - 2 A _ { \\mu } ( s , a ) ) ^ { 2 } } } \\\\ &   \\end{array} \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            181,
+            635,
+            820,
+            848
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Regression problem follows: ",
+        "bbox": [
+            174,
+            871,
+            364,
+            885
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f03587aa154e686449a4f86f03f029cb168b5629310b4e13c778f376a18328e2.jpg",
+        "text": "$$\n\\underset { \\pi } { \\arg \\operatorname* { m a x } } \\mathbb { E } _ { s \\sim \\rho _ { \\mu } ( \\cdot ) } \\mathbb { E } _ { a \\sim \\mu ( \\cdot \\vert s ) } \\log \\pi ( a \\vert s ) \\frac { 1 } { ( \\beta - A _ { \\mu } ( s , a ) ) ^ { 2 } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            316,
+            890,
+            681,
+            921
+        ],
+        "page_idx": 9
+    }
+]

parse/train/ryeNPi0qKX/ryeNPi0qKX.md

@@ -0,0 +1,212 @@
+# LANGUAGE MODELING TEACHES YOU MORE SYNTAX THAN TRANSLATION DOES
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Recent work using auxiliary prediction task classifiers to investigate the properties of LSTM representations has begun to shed light on why pretrained representations, like ELMo (Peters et al., 2018) and CoVe (McCann et al., 2017), are so beneficial for neural language understanding models. We still, though, do not yet have a clear understanding of how the choice of pretraining objective affects the type of linguistic information that models learn. With this in mind, we compare four objectives—language modeling, translation, skip-thought, and autoencoding—on their ability to induce syntactic and part-of-speech information. We make a fair comparison between the tasks by holding constant the quantity and genre of the training data, as well as the LSTM architecture. We find that representations from language models consistently perform best on our syntactic auxiliary prediction tasks, even when trained on relatively small amounts of data. These results suggest that language modeling may be the best data-rich pretraining task for transfer learning applications requiring syntactic information. We also find that the representations from randomly-initialized, frozen LSTMs perform strikingly well on our syntactic auxiliary tasks, but this effect disappears when the amount of training data for the auxiliary tasks is reduced.
+
+# 1 INTRODUCTION
+
+Representation learning with deep recurrent neural networks has revolutionized natural language processing and replaced many of the expert-designed, linguistic features used previously. Recently, researchers have begun to investigate the properties of learned representations by training auxiliary classifiers that use the hidden states of frozen, pretrained models to perform other tasks. These investigations have shown that when deep LSTMs (Hochreiter & Schmidhuber, 1997) are trained on tasks like translation, they learn substantial syntactic and semantic information about their input sentences, including part-of-speech (Shi et al., 2016; Belinkov et al., 2017a;b; Blevins et al., 2018).
+
+These intriguing findings lead us to ask the following questions:
+
+1. How does the training task affect how well models learn syntactic properties? Which tasks are better at inducing these properties?   
+2. How does the amount of data the model is trained on affect these results? When does training on more data help?
+
+We investigate these questions by holding the data source and model architecture constant, while varying both the training task and the amount of training data. Specifically, we examine models trained on English-German (En-De) translation, language modeling, skip-thought (Kiros et al., 2015), and autoencoding, and also compare to an untrained LSTM model as a baseline. We control for the data domain by exclusively training on datasets from the 2016 Conference on Machine Translation (WMT; Bojar et al., 2016). We train models on all tasks using the parallel En-De corpus, which allows us to make fair comparisons across tasks. We also train models on a subset of the this corpus to examine the effect of training data volume on learned representations. Additionally, we augment the parallel dataset with a large monolingual corpus from WMT to examine how the performance of the unsupervised tasks (all but translation) scale with more data.
+
+Throughout our work, we focus on the syntactic evaluation tasks of part-of-speech (POS) tagging and Combinatorial Categorical Grammar (CCG) supertagging. Supertagging is considered a building block for parsing as these tags constrain the ways in which words can compose, largely determining the parse of the sentence. CCG supertagging thus allows us to measure the degree to which models learn syntactic structure above the word. We focus our analysis on representations learned by language models and by the encoders of sequence-to-sequence models, as translation encoders have been found to learn richer representations of POS and morphological information than translation decoders (Belinkov et al., 2017a).
+
+We find that for POS and CCG tagging, bidirectional language models (BiLMs)—created by separately training forward and backward language models, and concatenating their hidden states— outperform models trained on all other tasks. Even BiLMs trained on relatively small amounts of data (1 million sentences) outperform translation and skip-thought models trained on larger datasets (5 million and 63 million sentences respectively).
+
+Our inclusion of an untrained LSTM baseline allows us to study the effect of training on hidden state representations of LSTMs. We find, surprisingly, that when we use all of the available labeled tag data to train our auxiliary task classifiers, our best trained models (BiLMs) only outperform the randomly initialized, untrained LSTMs by a few percentage points. When we reduce the amount of classifier training data though, the performance of the randomly initialized LSTM model drops far below those of trained models. We hypothesize that this occurs because training the classifiers on large amounts of auxiliary task data allows them to memorize configurations of words seen in the training set and their associated tags. We test this hypothesis by training classifiers to predict the identity of neighboring words from a given hidden state, and find that randomly initialized models outperform all trained models on this task. Our findings demonstrate that our best trained models do well on the tagging tasks because they are truly learning representations that conform to our notions of POS and CCG tagging, and not simply because the classifiers we train are able to recover neighboring word identity information.
+
+# 2 RELATED WORK
+
+Evaluating Learned Representations Adi et al. (2016) introduce the idea of examining sentence vector representations by training auxiliary classifiers to take sentence encodings and predict attributes like word order. Belinkov et al. (2017a) build on this work by examining the hidden states of LSTMs trained on translation and find that they learn substantial POS and morphological information without direct supervision for these linguistic properties. Beyond translation, Blevins et al. (2018) find that deep LSTMs learn hierarchical syntax when trained on a variety of tasks—including semantic role labeling, language modeling, and dependency parsing. However, the models examined by Blevins et al. (2018) were also trained on different datasets, so it’s unclear if the differences in syntactic task performance are due to the training objectives or simply differences in the training data. By controlling for model size and the quantity and genre of the training data, we we are able to make direct comparisons between tasks on their ability to induce syntactic information.
+
+Transfer Learning of Representations Much of the work on sentence-level pretraining has focused on sentence-to-vector models and evaluating learned representations on how well they can be used to perform sentence-level classification tasks. A prominent early success in this area with unlabeled data is skip-thought (Kiros et al., 2015), the technique of training a sequence-to-sequence model to predict the sentence preceding and following each sentence in a running text. InferSent (Conneau et al., 2017)—the technique of pretraining encoders on natural language inference data— yields strikingly better performance when such labeled data is available.
+
+Work in transfer learning of representations has recently moved beyond strict sentence-to-vector mappings. Newer models that incorporate LSTMs or Transformer networks pretrained on datarich tasks, like translation and language modeling, have achieved state-of-the-art results on many tasks—including semantic role labeling, natural language inference, and coreference resolution (Peters et al., 2018; McCann et al., 2017; Howard & Ruder, 2018; Radford et al., 2018). Although comparisons have previously been made between translation and language modeling as pretraining tasks (Peters et al., 2018; Wang et al., 2018), we investigate this issue more thoroughly by controlling for the quantity and content of the training data.
+
+Table 1: Perplexity of trained models by number of training sentences. All but the language models are 1000D BiLSTMs (500D per direction). The 500D forward and backward language models are combined into a single bidirectional language model for analysis experiments.   
+
+<table><tr><td>Task</td><td>Layer Size</td><td>Attn.</td><td>1 Million</td><td>5 Million</td><td>15 Million</td><td>63 Million</td></tr><tr><td>Translation</td><td>2×500D</td><td>Y</td><td>13.2 (17.6 BLEU)</td><td>9.1 (21.4 BLEU)</td><td>1</td><td>1</td></tr><tr><td>Translation</td><td>2×500D</td><td>N</td><td>25.2 (6.8 BLEU)</td><td>13.0 (12.3 BLEU)</td><td></td><td></td></tr><tr><td>LMForward</td><td>1×500D</td><td>1</td><td>104.8</td><td>81.2</td><td>82.3</td><td>76.9</td></tr><tr><td>LMBackward</td><td>1×500D</td><td>1</td><td>103.2</td><td>80.8</td><td>81.1</td><td>77.3</td></tr><tr><td>LMForward</td><td>1×1000D</td><td></td><td>103.8</td><td>73.6</td><td>69.2</td><td>66.5</td></tr><tr><td>Skip-Thought</td><td>2×500D</td><td>Y</td><td>99.0</td><td>69.2</td><td>68.7</td><td>67.9</td></tr><tr><td>Skip-Thought</td><td>2×500D</td><td>N</td><td>104.1</td><td>72.0</td><td>68.1</td><td>66.7</td></tr><tr><td>Autoencoder</td><td>2×500D</td><td>Y</td><td>1.0</td><td>1.0</td><td>1.0</td><td>1.0</td></tr><tr><td>Autoencoder</td><td>2×500D</td><td>N</td><td>1.0</td><td>1.1</td><td>1.2</td><td>1.1</td></tr></table>
+
+Training Dataset Size The performance of neural models depends immensely on the amount of training data used. Koehn & Knowles (2017) find that when training machine translation models on corpora with fewer than 15 million words (English side), statistical machine translation approaches outperform neural ones. Similarly, Hestness et al. (2017) study the affect of training data volume on performance for several tasks—including translation and image classification. They find that for small amounts of data, neural models perform about as well as chance. After a certain threshold, model performance improves logarithmically with the amount of training data, but this eventually plateaus. With this in mind, we also vary the amount of training data to investigate the relationship between performance and data volume for each task.
+
+Randomly Initialized Models Conneau et al. (2018) use randomly initialized LSTMs as a baseline when studying sentence-to-vector embedding models. They find that untrained models outperform many trained models on several auxiliary tasks, including predicting word content. Similarly in vision, untrained convolutional networks have been shown to capture many low-level image statistics and can be used for image denoising (Ulyanov et al., 2017). Our method of training auxiliary classifiers on randomly initialized RNNs builds on the tradition of reservoir computing, in which randomly initialized networks or “reservoirs” are fixed and only “read-out” classifier networks are trained (Lukosevi ˇ cius & Jaeger, 2009). Echo state networks—reservoir computing with recurrent ˇ models—have been used for tasks like speech recognition, language modeling, and time series prediction (Verstraeten et al., 2006; Tong et al., 2007; Sun et al., 2017).
+
+# 3 METHODS
+
+# 3.1 MAIN TRAINING DATA
+
+We use the parallel English-German (En-De) dataset from the 2016 ACL Conference on Machine Translation (WMT) shared task on news translation (Bojar et al., 2016). This dataset contains 5 million ordered sentence translation pairs. We also use the 2015 English monolingual news discussion dataset from the same WMT shared task, which contains approximately 58 million ordered sentences. To examine how the volume of training data affects learned representations, we use four corpus sizes: 1, 5, 15, and 63 million sentences (translation is only trained on the smaller two sizes). We create the 1 million sentence corpora from the 5 million sentence dataset by sampling (i) sentence pairs for translation, (ii) English sentences for autoencoders, and (iii) ordered English sentence pairs for skip-thought and language models1. Similarly, we create the 15 million sentence corpora for the unsupervised tasks by sampling sentences from the entire corpus of 63 million sentences. We use word-level representations throughout and use the Moses package (Koehn et al., 2007) to tokenize and truecase our data. Finally, we limit both the English and German vocabularies to the $5 0 \mathrm { k }$ most frequent tokens in the training set.
+
+Soon she was running the office RB PRP VBD VBG DT NN (a) POS tags
+
+![](images/55f65e44e652f99afd857c7935ea88453a4f48da46dfd39c9456e8d3abae90a3.jpg)  
+Figure 1: An annotated PTB example sentence.
+
+(b) A CCG parse, with supertags shown immediately below the words.
+
+# 3.2 MODEL ARCHITECTURE AND TRAINING
+
+We train all our models using OpenNMT-py (Klein et al., 2017) and use the default options for model sizes, hyperparameters, and training procedure—except we increase the size of the LSTMs, make the encoders bidirectional, and use validation-based learning rate decay instead of a fixed schedule. Specifically, all our models (except language models) are 1000D, two-layer encoder-decoder LSTMs with bidirectional encoders (500D per direction) and 500D embeddings. We train models both with and without attention (Bahdanau et al., 2015). For language models, we train a 1000D forward language model and a bidirectional language model—two 500D language models (forward and backward) trained separately, whose hidden states are concatenated. All models, including our untrained baseline, are initialized from a uniform distribution $( - 0 . 1 , 0 . 1 )$ , the default in OpenNMT.
+
+We use the same training procedure for all our models. We evaluate on the validation set every epoch when training on the 1 and 5 million sentence datasets, and evaluate approximately every 5 million sentences when training on the larger datasets. We use SGD with an initial learning rate of 1. Whenever a model’s validation loss increases relative to the previous evaluation, we halve the learning rate and stop training when the learning rate reaches $0 . 5 ^ { \mathbf { \hat { 1 } 5 } }$ . For each training task and dataset size, we select the model with the lowest validation perplexity to perform auxiliary task evaluations on. We report model performance in terms of perplexity and BLEU (Papineni et al., 2002) in Table 1. For translation we use beam search $\mathrm { B } = 5$ ) when decoding.
+
+# 3.3 CLASSIFIER DATA AND ARCHITECTURE
+
+POS and CCG For Part-of-Speech (POS) tagging evaluation, we use the Wall Street Journal (WSJ) portion of the Penn Treebank (PTB; Marcus et al., 1993) We follow the standard WSJ split (train 2-21; dev 22; test 23). The dataset contains approximately 50k sentences and 45 tag types.
+
+For CCG supertagging, we use CCG Bank (Hockenmaier & Steedman, 2007), which is based on PTB WSJ. CCG supertagging provides fine-grained information about the role of each word in its larger syntactic context and is considered almost parsing, since sequences of tags map sentences to small subsets of possible parses. The entire dataset contains approximately $5 0 \mathrm { k }$ sentences and 1327 tag types. We display POS and CCG tags for an example sentence in Figure 1.
+
+To study the impact of auxiliary task training data volume, for both datasets we create smaller classifier training sets by sampling $10 \%$ and $1 \%$ of the sentences. We truecase both datasets using the same truecase model trained on WMT and restrict the vocabularies to the $5 0 \mathrm { k }$ tokens used in pretraining our LSTM models. In addition to the untrained LSTM baseline, we also compare to the word-conditional most frequent class (WC-MFC)—the most frequently assigned tag class for each distinct word in the training set. For this baseline we restrict the vocabulary to that of our LSTM models and map all out-of-vocabulary words to a single UNK token. Note that while PTB and WMT are both drawn from news text, there is slight genre mismatch.
+
+Word Identity For this task, the classifier takes a single LSTM hidden state as input and predicts the identity of the word at a different time step. For example, for the sentence “I love NLP” and a time step shift of -2, we would train the classifier to take the hidden state for “NLP” and predict the word “I”. We use the WSJ dataset for this task. Following Conneau et al. (2018), we take all words that occur between 100 and 1000 times (about 1000 words total) as the possible targets for neighboring word prediction.
+
+![](images/b68a5a7d50f13dc4ce2cd55ef7ce0d4f17964d678ac86e46f42ec97bc37bb6a7.jpg)  
+  
+Figure 2: POS and CCG tagging accuracies for different amounts of LSTM encoder and classifier training data. We show results for the best performing layer of each model. Note, BiLMs are displayed with the attention models and forward LMs are displayed with the models without attention.
+
+Classifier Training Procedure We train multi-layer perceptron (MLP) classifiers that take an LSTM hidden state (from one time step and one layer) and output a distribution over the possible labels (tags or word identities). The MLPs we train have a single 1000D hidden layer with a ReLU activation. For classifier training, we use the same training and learning rate decay procedure used for pretraining the LSTM encoders.
+
+# 4 COMPARING PRETRAINING TASKS
+
+In this section we discuss the main POS and CCG tagging results displayed in Figure 2. Overall, POS and CCG tagging accuracies tend to increase with the amount of data the LSTM encoders are trained on, but the marginal improvement decreases as the amount of training data increases.
+
+Language Modeling and Translation For all pretraining dataset sizes, bidirectional language model (BiLM) and translation encoder representations perform best on both POS and CCG tagging. Translation encoders, however, slightly underperform BiLMs, even when both models are trained on the same amount of data. In fact, even BiLMs trained on the smallest amount of data (1 million sentences) outperform models trained on all other tasks and dataset sizes (up to 5 million sentences for translation, and 63 million sentences for skip-thought and autoencoding). Especially since BiLMs
+
+(a) WC-MFC baselines for different amounts of PTB training data: $1 \%$ PTB: $8 1 . 8 \%$ ; $10 \%$ PTB: $8 8 . 6 \%$ ; $100 \%$ PTB: $8 9 . 9 \%$ .
+
+![](images/5487db7289b1df961d9b91688520bb743cf4847dc08fb1972a04800e7720fa4a.jpg)  
+(b) WC-MFC baselines for different amounts of CCG training data: $1 \%$ CCG: $6 2 . 3 \%$ ; $10 \%$ CCG: $6 8 . 3 \%$ ; $100 \%$ CCG: $7 1 . 6 \%$ .
+
+![](images/8f6e77fb793953ea416ba31d34ffc971f00544f63113a5e4fd56bd28c320805c.jpg)  
+Figure 3: POS and CCG tagging accuracies for different amounts of classifier training data in terms of percentage points over the word-conditional most frequent class (WC-MFC) baseline. We show results for the best performing layer and model for each task.
+
+do not require aligned data to train, the superior performance of BiLM representations on these tasks suggests that BiLMs (like ELMo; Peters et al., 2018) are better than translation encoders (like CoVe; McCann et al., 2017) for transfer learning of syntactic information. One reason BiLMs perform relatively well on these syntactic tasks could be that in contrast to the encoders for the other tasks, LM encoders have a per-token loss. Note also that since our evaluation tasks also predict a single label for each token, this could be one reason that BiLMs perform so well on these tasks in particular.
+
+For all amounts of training data, the BiLMs significantly outperform the 1000D forward-only language models. The gap in performance between bidirectional and forward language models is greater for CCG supertagging than for POS tagging. When using all available auxiliary training data, there is a 2 and 8 percentage point performance gap in POS and CCG tagging respectively. This difference in relative performance suggests that bidirectional context information is more important for identifying syntactic structure than for identifying part of speech.
+
+Figure 2 illustrates how the best performing BiLMs and translation models tend to be more robust to decreases in classifier data than models trained on other tasks. Also, when training on less auxiliary task data, POS tagging performance tends to drop less than CCG supertagging performance. For the best model (BiLM trained on 63 million sentences), when using $1 \%$ rather than all of the auxiliary task training data, CCG accuracy drops 9 percentage points, while POS accuracy only drops 2 points. Further examinations of the effect of classifier data volume are displayed in Figure 3.
+
+Skip-Thought Although skip-thought encoders consistently underperform both BiLMs and translation encoders in all data regimes we examine, skip-thought models improve the most when increasing the amount of pretraining data, and are the only models whose performance does not seem to have plateaued by 63 million training sentences. Since we train our language models on ordered sentences, as we do for skip-thought, our language models can be interpreted as a regularized versions of skip-thought, in which the weights of the encoder and decoder are shared. The increased model capacity of skip-thought, compared to language models, could explain the difference in learned representation quality—especially when these models are trained on smaller amounts of data.
+
+Random Initialization For our randomly initialized, untrained LSTM encoders, we use the default weight initialization technique in OpenNMT-py, a uniform distribution between $- 0 . 1$ and 0.1; the only change we make is to set all biases to zero. We find that this baseline performs quite well when using all auxiliary data, and is only 3 and 8 percentage points behind the BiLM on POS and CCG tagging, respectively. We find that decreasing the amount of classifier data leads to a significantly greater drop in the untrained encoder performance compared to trained models. In the $1 \%$ classifier data regime, the performance of untrained encoders on both tasks drops below that of all trained models and below even the word-conditional most-frequent class baseline.
+
+![](images/8f61c3c81319fdf73e823d448b463e2042969030ce7fde8062341493f5774e19.jpg)  
+Figure 4: POS and CCG tagging accuracies in terms of percentage points over the word-conditional most frequent class baseline. We display results for the best performing models for each task.
+
+We hypothesize that the randomly initialized baseline is able to perform well on tagging tasks with large amounts of auxiliary task training data, because the classifier can learn the identity of neighboring words from a given time step’s hidden state, and simply memorize word configurations and their associated tags from the training data. We test this hypothesis directly in Section 6 and find that untrained LSTM representations are in fact better at capturing neighboring word identity information than any trained model.
+
+Autoencoder Models trained on autoencoding are the only ones that do not consistently improve with the amount of training data, which is unsurprising as unregularized autoencoders are prone to learning identity mappings (Vincent et al., 2008). When training on $10 \%$ and $1 \%$ of the auxiliary task data, autoencoders outperform randomly initialized encoders and match the word-conditional most frequent class baseline. When training on all the auxiliary data though, untrained encoders outperform autoencoders. These results suggest that autoencoders learn some useful structure that is useful in the low auxiliary data regime. However, the representations autoencoders learn do not capture syntactically rich features, since random encoders outperform them in the high auxiliary data regime. This conclusion is further supported by the extremely poor performance of the second layer of an autoencoder without attention on POS tagging (almost 10 percentage points below the most frequent class baseline), as seen in Figure 4a.
+
+# 5 COMPARING LAYERS
+
+Embeddings (Layer 0) We find that randomly initialized embeddings consistently perform as well as the word-conditional most frequent class baseline on POS and CCG tagging, which serves as an upper bound on performance for the embedding layer. As these embeddings are untrained, the auxiliary classifiers are learning to memorize and classify the random vectors. When using all the auxiliary classifier data, there is no significant difference in the performance of trained and untrained embeddings on the tagging tasks. Only for smaller amounts of classifier data do trained embeddings consistently outperform randomly initialized ones.
+
+Upper Layers Belinkov et al. (2017a) find that, for translation models, the first layer consistently outperforms the second on POS tagging. We find that this pattern holds for all our models, except in BiLMs, for which the first and second layers perform equivalently. The pattern holds even for untrained models, suggesting that POS information is stored on the lower layer, not necessarily because the training task encourages this, but because of properties of the deep LSTM architecture.
+
+We also find that for CCG supertagging, the first layer also outperforms the second layer on untrained models. For the trained models though, the second layer performs better than the first in some cases. Which layer performs best appears to be independent of absolute performance on the supertagging task. Our layer analysis results are displayed in Figure 4.
+
+![](images/ffb876081fbb51d93085a3a7df69a3a3f1ad29500415e7befd90ba3e0c08c40e.jpg)  
+Figure 5: Performance of classifiers trained to predict the identity of the word a fixed number of timesteps away. Note, the forward LM has asymmetrical access to this information in its input.
+
+# 6 WORD IDENTITY PREDICTION
+
+Our results on word identity prediction are summarized in Figure 5 and given in more detail in Appendix A. While trained encoders outperform untrained ones on both POS and CCG tagging, we find that all trained LSTMs underperform untrained ones on word identity prediction. This finding confirms that trained encoders genuinely capture substantial syntactic features, beyond mere word identity, that the auxiliary classifiers can use.
+
+We find that for both trained and untrained models, the first layer outperforms the second layer when predicting the identity of the immediate neighbors of a word. However, the second layer tends to outperform the first at predicting the identity of more distant neighboring words. This effect is especially apparent for the randomly initialized encoders. Our finding suggests that, as is the case for convolutional neural networks, depth in recurrent neural networks has the effect of increasing the receptive field and allows the upper layers to have representations that capture a larger context. These results reflect the findings of Blevins et al. (2018) that for trained models, upper levels of LSTMs encode more abstract syntactic information, since more abstract information generally requires larger context information.
+
+# 7 CONCLUSION
+
+By controlling for the genre and quantity of the training data, we make fair comparisons between several data-rich training tasks in their ability to induce syntactic information. We find that bidirectional language models (BiLMs) do better than translation and skip-thought encoders at extracting useful features for POS tagging and CCG supertagging. Moreover, this improvement holds even when the BiLMs are trained on substantially less data than competing models. Our results suggest that for transfer learning, BiLMs like ELMo (Peters et al., 2018) capture more useful features than translation encoders—and that this holds even on genres for which data is not abundant.
+
+We also find that randomly initialized encoders extract usable features for POS and CCG tagging— at least when the auxiliary POS and CCG classifiers are themselves trained on reasonably large amounts of data. The performance of untrained models drops sharply relative to trained ones when using smaller amounts of the classifier data. We investigate further and find that untrained models outperform trained ones on the task of neighboring word identity prediction, which confirms that trained encoders do not perform well on tagging tasks because the classifiers are simply memorizing word identity information. We also find that both trained and untrained LSTMs store more local neighboring word identity information in lower layers and more distant word identity information in upper layers, which suggests that depth in LSTMs allow them to capture larger context information.
+
+# REFERENCES
+
+Yossi Adi, Einat Kermany, Yonatan Belinkov, Ofer Lavi, and Yoav Goldberg. Fine-grained Analysis of Sentence Embeddings Using Auxiliary Prediction Tasks. ICLR, 2016. URL http://arxiv. org/abs/1608.04207.
+
+Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural Machine Translation by Jointly Learning to Align and Translate. ICLR, 2015.
+
+Yonatan Belinkov, Llu´ıs Marquez, Hassan Sajjad, Nadir Durrani, Fahim Dalvi, and James Glass. \` Evaluating Layers of Representation in Neural Machine Translation on Part-of-Speech and Semantic Tagging Tasks. IJCNLP, 2017b. URL https://arxiv.org/abs/1801.07772.
+
+Yonatan Belinkov, Nadir Durrani, Fahim Dalvi, Hassan Sajjad, and James R. Glass. What do Neural Machine Translation Models Learn about Morphology? ACL, 2017a. URL http://arxiv. org/abs/1704.03471.
+
+Terra Blevins, Omer Levy, and Luke Zettlemoyer. Deep RNNs Learn Hierarchical Syntax. ACL, 2018.
+
+Ondrej Bojar, Rajen Chatterjee, Christian Federmann, Yvette Graham, Barry Haddow, Matthias Huck, Antonio Jimeno Yepes, Philipp Koehn, Varvara Logacheva, Christof Monz, Matteo Negri, Aurelie Neveol, Mariana Neves, Martin Popel, Matt Post, Raphael Rubino, Carolina Scarton, Lucia Specia, Marco Turchi, Karin Verspoor, and Marcos Zampieri. Findings of the 2016 Conference on Machine Translation (WMT16). ACL, 2016.
+
+Alexis Conneau, Douwe Kiela, Holger Schwenk, Loic Barrault, and Antoine Bordes. Supervised Learning of Universal Sentence Representations from Natural Language Inference Data. ACL, 2017.
+
+Alexis Conneau, German Kruszewski, Guillaume Lample, Lo \` ¨ı Barrault, and Marco Baroni. What you can cram into a single \$&!#\* vector: Probing sentence embeddings for linguistic properties. ACL, 2018.
+
+Joel Hestness, Sharan Narang, Newsha Ardalani, Gregory F. Diamos, Heewoo Jun, Hassan Kianinejad, Md. Mostofa Ali Patwary, Yang Yang, and Yanqi Zhou. Deep Learning Scaling is Predictable, Empirically. arXiv preprint 1712.00409, 2017. URL http://arxiv.org/abs/ 1712.00409.
+
+Sepp Hochreiter and Juergen Schmidhuber. Long Short-Term Memory. ¨ Neural Computation, 9(8): 1735–1780, 1997.
+
+Julia Hockenmaier and Mark Steedman. CCGbank: A Corpus of CCG Derivations and Dependency Structures Extracted from the Penn Treebank. Computational Linguistics, 2007. URL http: //www.aclweb.org/anthology/J07-3004.
+
+Jeremy Howard and Sebastian Ruder. Universal Language Model Fine-tuning for Text Classification. ACL, 2018. URL http://arxiv.org/abs/1801.06146.
+
+Ryan Kiros, Yukun Zhu, Ruslan Salakhutdinov, Richard S. Zemel, Antonio Torralba, Raquel Urtasun, and Sanja Fidler. Skip-Thought Vectors. NIPS, 2015. URL http://arxiv.org/abs/ 1506.06726.
+
+Guillaume Klein, Yoon Kim, Yuntian Deng, Jean Senellart, and Alexander M. Rush. OpenNMT: Open-Source Toolkit for Neural Machine Translation. ACL, 2017. doi: 10.18653/v1/P17-4012. URL https://doi.org/10.18653/v1/P17-4012.
+
+Philip Koehn and Rebecca Knowles. Six Challenges for Neural Machine Translation. ACL, 2017.
+
+Philipp Koehn, Hieu Hoang, Alexandra Birch, Chris Callison-Burch, Marcello Federico, Nicola Bertoldi, Brooke Cowan, Wade Shen, Christine Moran, Richard Zens, Chris Dyer, Ondˇrej Bojar, Alexandra Constantin, and Evan Herbst. Moses: Open Source Toolkit for Statistical Machine Translation. ACL, 2007. URL http://www.statmt.org/moses/.
+
+Mantas Lukosevi ˇ cius and Herbert Jaeger. Reservoir computing approaches to recurrent neural net- ˇ work training. In Computer Science Review, volume 3, pp. 127–149, 2009.
+
+Mitchell P. Marcus, Mary Ann Marcinkiewicz, and Beatrice Santorini. Building a Large Annotated Corpus of English: The Penn Treebank. Computational Linguistics, 1993. URL http://dl. acm.org/citation.cfm?id $=$ 972470.972475.
+
+Bryan McCann, James Bradbury, Caiming Xiong, and Richard Socher. Learned in Translation: Contextualized Word Vectors. NIPS, 2017.
+
+Kishore Papineni, Salim Roukos, Todd Ward, and Wei-Jing Zhu. Bleu: a Method for Automatic Evaluation of Machine Translation. ACL, 2002. URL http://www.aclweb.org/ anthology/P02-1040.pdf.
+
+Matthew E. Peters, Mark Neumann, Mohit Iyyer, Matt Gardner, Christopher Clark, Kenton Lee, and Luke Zettlemoyer. Deep contextualized word representations. NAACL, 2018. URL http: //arxiv.org/abs/1802.05365.
+
+Alec Radford, Karthik Narasimhan, Tim Salimans, and Ilya Sutskever. Improving Language Understanding by Generative Pre-Training. 2018. URL http://openai-assets.s3. amazonaws.com/research-covers/language-unsupervised/language_ understanding_paper.pdf.
+
+Xing Shi, Inkit Padhi, and Kevin Knight. Does String-Based Neural MT Learn Source Syntax? EMNLP, 2016. URL https://www.isi.edu/natural-language/mt/ emnlp16-nmt-grammar.pdf.
+
+Xiaochuan Sun, Tao Li, Qun Li, Yue Huang, and Yingqi Li. Deep belief echo-state network and its application to time series prediction. Knowl.-Based Syst., 130:17–29, 2017.
+
+Matthew H. Tong, Adam D. Bickett, Eric M. Christiansen, and Garrison W. Cottrell. Learning grammatical structure with echo state networks. Neural Networks, 20(3):424–432, 2007. doi: 10. 1016/j.neunet.2007.04.013. URL https://doi.org/10.1016/j.neunet.2007.04. 013.
+
+Dmitry Ulyanov, Andrea Vedaldi, and Victor Lempitsky. Deep Image Prior. NIPS, 2017.
+
+David Verstraeten, Benjamin Schrauwen, and Dirk Stroobandt. Reservoir-based techniques for speech recognition. In The 2006 IEEE International Joint Conference on Neural Network Proceedings, pp. 1050–1053, July 2006. doi: 10.1109/IJCNN.2006.246804.
+
+Pascal Vincent, Hugo Larochelle, Yoshua Bengio, and Pierre-Antoine Manzagol. Extracting and Composing Robust Features with Denoising Autoencoders. In Machine Learning, Proceedings of the Twenty-Fifth International Conference (ICML 2008), Helsinki, Finland, June 5-9, 2008, pp. 1096–1103, 2008.
+
+Alex Wang, Amapreet Singh, Julian Michael, Felix Hill, Omer Levy, and Samuel R. Bowman. GLUE: A Multi-Task Benchmark and Analysis Platform for Natural Language Understanding. 2018. URL https://arxiv.org/abs/1804.07461.
+
+# A RANDOMLY INITIALIZED ENCODERS
+
+![](images/b1b4708c094604f919e241a22de7653a27769afbaac44d978caf9231a0eea125.jpg)  
+Figure 6: Here we display results for the word identity prediction task with randomly initialized LSTM encoders with up to 4 layers. Lower layers have a more peaked shape and upper layers a more flat shape, meaning that the lower layers encode relatively more nearby neighboring word information, while upper layers encode relatively more distant neighboring word information.
+
+# B POS AND CCG EVALUATION FULL RESULTS
+
+B.1 TRAINING CLASSIFIERS ON ALL DATA   
+Table 2: Here we display results for training on all of auxiliary task data. Word-conditional most frequent class baselines for this amount of training data are $8 9 . 9 \%$ for POS tagging and $7 1 . 6 \%$ for CCG supertagging. For each task, we underline the best performance for each training dataset size and bold the best overall performance.   
+
+<table><tr><td>Training task</td><td>Data</td><td>Attention</td><td>POS L2</td><td>POS L1</td><td>POS LO</td><td>CCG L2</td><td>CCG L1</td><td>CCG LO</td></tr><tr><td>Random Init 1</td><td>None</td><td>N/A</td><td>90.5</td><td>93.7</td><td>90.2</td><td>83.5</td><td>85.4</td><td>71.6</td></tr><tr><td>Random Init 2</td><td>None</td><td>N/A</td><td>90.3</td><td>93.8</td><td>90.1</td><td>83.3</td><td>85.3</td><td>71.5</td></tr><tr><td>Translation</td><td>1M</td><td>Yes</td><td>95.6</td><td>95.7</td><td>90.0</td><td>91.4</td><td>91.2</td><td>71.5</td></tr><tr><td>Translation</td><td>1M</td><td>No</td><td>92.5</td><td>95.0</td><td>90.0</td><td>88.2</td><td>90.1</td><td>71.3</td></tr><tr><td>LM (Bidir)</td><td>1M</td><td>No</td><td>96.4</td><td>96.1</td><td>90.2</td><td>92.5</td><td>92.0</td><td>71.6</td></tr><tr><td>LM (Forward)</td><td>1M</td><td>No</td><td>94.3</td><td>94.5</td><td>90.1</td><td>83.5</td><td>83.1</td><td>71.5</td></tr><tr><td>Skip-thought</td><td>1M</td><td>Yes</td><td>44.3</td><td>88.6</td><td>89.9</td><td>45.3</td><td>81.0</td><td>71.1</td></tr><tr><td>Skip-thought</td><td>1M</td><td>No</td><td>78.1</td><td>90.8</td><td>89.9</td><td>74.5</td><td>84.4</td><td>71.1</td></tr><tr><td>Autoencoder</td><td>1M</td><td>Yes</td><td>80.8</td><td>92.4</td><td>89.6</td><td>73.6</td><td>83.7</td><td>71.2</td></tr><tr><td>Autoencoder</td><td>1M</td><td>No</td><td>79.8</td><td>90.8</td><td>89.9</td><td>79.2</td><td>84.0</td><td>71.1</td></tr><tr><td>Translation</td><td>5M</td><td>Yes</td><td>96.0</td><td>95.9</td><td>90.2</td><td>92.2</td><td>91.6</td><td>71.5</td></tr><tr><td>Translation</td><td>5M</td><td>No</td><td>92.9</td><td>95.8</td><td>90.2</td><td>89.6</td><td>91.2</td><td>71.5</td></tr><tr><td>LM(Bidir)</td><td>5M</td><td>No</td><td>96.6</td><td>96.2</td><td>90.3</td><td>92.6</td><td>92.4</td><td>71.6</td></tr><tr><td>LM (Forward)</td><td>5M</td><td>No</td><td>94.6</td><td>94.7</td><td>90.2</td><td>84.0</td><td>83.5</td><td>71.5</td></tr><tr><td>Skip-thought</td><td>5M</td><td>Yes</td><td>76.4</td><td>92.2</td><td>90.0</td><td>68.4</td><td>86.4</td><td>71.1</td></tr><tr><td>Skip-thought</td><td>5M</td><td>No</td><td>86.1</td><td>94.3</td><td>90.0</td><td>81.2</td><td>88.6</td><td>71.2</td></tr><tr><td>Autoencoder</td><td>5M</td><td>Yes</td><td>88.1</td><td>91.8</td><td>89.6</td><td>76.5</td><td>82.5</td><td>70.8</td></tr><tr><td>Autoencoder</td><td>5M</td><td>No</td><td>70.7</td><td>92.1</td><td>89.8</td><td>72.7</td><td>83.7</td><td>71.0</td></tr><tr><td>LM (Bidir)</td><td>15M</td><td>No</td><td>97.0</td><td>96.8</td><td>90.6</td><td>93.1</td><td>92.9</td><td>72.0</td></tr><tr><td>LM (Forward)</td><td>15M</td><td>No</td><td>95.3</td><td>95.3</td><td>90.6</td><td>84.9</td><td>84.5</td><td>72.0</td></tr><tr><td>Skip-thought</td><td>15M</td><td>Yes</td><td>82.3</td><td>93.8</td><td>90.2</td><td>70.4</td><td>87.6</td><td>71.6</td></tr><tr><td>Skip-thought</td><td>15M</td><td>No</td><td>90.1</td><td>95.1</td><td>90.3</td><td>85.8</td><td>89.8</td><td>71.5</td></tr><tr><td>Autoencoder</td><td>15M</td><td>Yes</td><td>91.9</td><td>93.1</td><td>90.1</td><td>82.6</td><td>84.5</td><td>71.4</td></tr><tr><td>Autoencoder</td><td>15M</td><td>No</td><td>71.6</td><td>92.0</td><td>89.8</td><td>71.0</td><td>83.7</td><td>71.2</td></tr><tr><td>LM (Bidir)</td><td>63M</td><td>No</td><td>96.9</td><td>96.7</td><td>90.6</td><td>93.1</td><td>93.0</td><td>72.0</td></tr><tr><td>LM (Forward)</td><td>63M</td><td>No</td><td>95.3</td><td>95.4</td><td>90.6</td><td>84.9</td><td>84.5</td><td>72.0</td></tr><tr><td>Skip-thought</td><td>63M</td><td>Yes</td><td>90.6</td><td>95.5</td><td>90.3</td><td>80.9</td><td>90.1</td><td>71.6</td></tr><tr><td>Skip-thought</td><td>63M</td><td>No</td><td>91.6</td><td>95.6</td><td>90.3</td><td>86.8</td><td>90.3</td><td>71.6</td></tr><tr><td>Autoencoder</td><td>63M</td><td>Yes</td><td>89.4</td><td>91.8</td><td>89.6</td><td>78.4</td><td>83.2</td><td>71.2</td></tr><tr><td>Autoencoder</td><td>63M</td><td>No</td><td>70.2</td><td>91.7</td><td>89.9</td><td>70.5</td><td>83.1</td><td>71.3</td></tr></table>
+
+B.2 TRAINING CLASSIFIERS ON $10 \%$ OF DATA   
+Table 3: Here we display results for training on $10 \%$ of auxiliary task data. Word-conditional most frequent class baselines for this amount of training data are $8 8 . 6 \%$ for POS tagging and $6 8 . 3 \%$ for CCG supertagging. For each task, we underline the best performance for each training dataset size and bold the best overall performance.   
+
+<table><tr><td>Training task</td><td>Data</td><td>Attention</td><td>POS L2</td><td>POS L1</td><td>POS LO</td><td>CCG L2</td><td>CCG L1</td><td>CCG L0</td></tr><tr><td>Random Init 1</td><td>None</td><td>N/A</td><td>85.0</td><td>90.5</td><td>88.3</td><td>71.8</td><td>77.0</td><td>68.3</td></tr><tr><td>Random Init 2</td><td>None</td><td>N/A</td><td>84.9</td><td>90.6</td><td>88.3</td><td>72.7</td><td>77.0</td><td>68.3</td></tr><tr><td>Translation</td><td>1M</td><td>Yes</td><td>93.4</td><td>94.3</td><td>89.1</td><td>88.4</td><td>87.6</td><td>69.5</td></tr><tr><td>Translation</td><td>1M</td><td>No</td><td>89.9</td><td>93.4</td><td>89.0</td><td>82.9</td><td>86.0</td><td>69.5</td></tr><tr><td>LM (Bidir)</td><td>1M</td><td>No</td><td>95.5</td><td>95.2</td><td>89.7</td><td>89.4</td><td>88.6</td><td>70.1</td></tr><tr><td>LMForward</td><td>1M</td><td>No</td><td>93.2</td><td>93.5</td><td>89.5</td><td>80.8</td><td>80.2</td><td>69.9</td></tr><tr><td>Skip-thought</td><td>1M</td><td>Yes</td><td>34.3</td><td>84.1</td><td>88.2</td><td>36.7</td><td>74.0</td><td>68.3</td></tr><tr><td>Skip-thought</td><td>1M</td><td>No</td><td>71.3</td><td>86.9</td><td>88.2</td><td>64.9</td><td>78.0</td><td>68.1</td></tr><tr><td>Autoencoder</td><td>1M</td><td>Yes</td><td>77.9</td><td>89.6</td><td>87.7</td><td>71.5</td><td>77.4</td><td>68.3</td></tr><tr><td>Autoencoder</td><td>1M</td><td>No</td><td>71.2</td><td>87.9</td><td>88.6</td><td>71.8</td><td>78.1</td><td>68.8</td></tr><tr><td>Translation</td><td>5M</td><td>Yes</td><td>94.1</td><td>94.8</td><td>89.5</td><td>88.9</td><td>88.2</td><td>69.8</td></tr><tr><td>Translation</td><td>5M</td><td>No</td><td>89.2</td><td>94.4</td><td>89.5</td><td>85.4</td><td>87.6</td><td>69.9</td></tr><tr><td>LM (Bidir)</td><td>5M</td><td>No</td><td>95.7</td><td>95.3</td><td>89.8</td><td>89.6</td><td>88.9</td><td>70.2</td></tr><tr><td>LMForward</td><td>5M</td><td>No</td><td>93.3</td><td>93.7</td><td>89.7</td><td>81.4</td><td>80.6</td><td>70.1</td></tr><tr><td>Skip-thought</td><td>5M</td><td>Yes</td><td>66.8</td><td>89.6</td><td>88.7</td><td>60.8</td><td>81.0</td><td>68.7</td></tr><tr><td>Skip-thought</td><td>5M</td><td>No</td><td>81.2</td><td>92.1</td><td>88.7</td><td>73.4</td><td>83.7</td><td>68.7</td></tr><tr><td>Autoencoder</td><td>5M</td><td>Yes</td><td>84.9</td><td>89.0</td><td>87.6</td><td>71.8</td><td>76.1</td><td>67.9</td></tr><tr><td>Autoencoder</td><td>5M</td><td>No</td><td>65.6</td><td>89.6</td><td>88.4</td><td>65.8</td><td>77.9</td><td>68.3</td></tr><tr><td>LM (Bidir)</td><td>15M</td><td>No</td><td>96.1</td><td>95.9</td><td>90.2</td><td>89.7</td><td>89.9</td><td>70.6</td></tr><tr><td>LMForward</td><td>15M</td><td>No</td><td>94.1</td><td>94.5</td><td>90.1</td><td>82.1</td><td>81.8</td><td>70.6</td></tr><tr><td>Skip-thought</td><td>15M</td><td>Yes</td><td>72.8</td><td>91.4</td><td>89.0</td><td>63.2</td><td>82.6</td><td>68.9</td></tr><tr><td>Skip-thought</td><td>15M</td><td>No</td><td>84.6</td><td>93.2</td><td>89.0</td><td>79.8</td><td>85.5</td><td>69.1</td></tr><tr><td>Autoencoder</td><td>15M</td><td>Yes</td><td>88.3</td><td>90.3</td><td>88.4</td><td>76.6</td><td>78.9</td><td>68.7</td></tr><tr><td>Autoencoder</td><td>15M</td><td>No</td><td>68.5</td><td>89.2</td><td>88.3</td><td>68.6</td><td>78.1</td><td>68.6</td></tr><tr><td>LM (Bidir)</td><td>63M</td><td>No</td><td>96.1</td><td>96.0</td><td>90.2</td><td>90.0</td><td>90.1</td><td>70.7</td></tr><tr><td>LMForward</td><td>63M</td><td>No</td><td>94.3</td><td>94.4</td><td>90.2</td><td>82.3</td><td>81.8</td><td>70.6</td></tr><tr><td>Skip-thought</td><td>63M</td><td>Yes</td><td>85.0</td><td>94.0</td><td>89.2</td><td>73.9</td><td>86.0</td><td>69.4</td></tr><tr><td>Skip-thought</td><td>63M</td><td>No</td><td>88.0</td><td>94.0</td><td>89.3</td><td>81.6</td><td>86.1</td><td>69.3</td></tr><tr><td>Autoencoder</td><td>63M</td><td>Yes</td><td>82.8</td><td>88.9</td><td>87.4</td><td>72.7</td><td>77.3</td><td>68.4</td></tr><tr><td>Autoencoder</td><td>63M</td><td>No</td><td>67.2</td><td>89.5</td><td>88.5</td><td>66.1</td><td>77.2</td><td>68.5</td></tr></table>
+
+B.3 TRAINING CLASSIFIERS ON $1 \%$ OF DATA   
+
+<table><tr><td>Training task</td><td>Data</td><td>Attn.</td><td>POS L2</td><td>POS L1</td><td>POS LO</td><td>CCG L2</td><td>CCG L1</td><td>CCG L0</td></tr><tr><td>Random Init 1</td><td>None</td><td>N/A</td><td>68.7</td><td>74.5</td><td>79.1</td><td>54.4</td><td>60.9</td><td>59.3</td></tr><tr><td>Random Init 2</td><td>None</td><td>N/A</td><td>68.8</td><td>74.5</td><td>79.5</td><td>55.5</td><td>62.0</td><td>58.8</td></tr><tr><td>Translation</td><td>1M</td><td>Yes</td><td>90.8</td><td>91.7</td><td>87.2</td><td>79.1</td><td>81.0</td><td>65.4</td></tr><tr><td>Translation</td><td>1M</td><td>No</td><td>82.5</td><td>89.9</td><td>86.9</td><td>69.0</td><td>78.3</td><td>65.0</td></tr><tr><td>LM (Bidir)</td><td>1M</td><td>No</td><td>93.5</td><td>93.8</td><td>89.0</td><td>82.8</td><td>81.6</td><td>67.1</td></tr><tr><td>LMForward</td><td>1M</td><td>No</td><td>90.8</td><td>91.8</td><td>88.5</td><td>74.3</td><td>74.1</td><td>66.5</td></tr><tr><td>Skip-thought</td><td>1M</td><td>Yes</td><td>27.2</td><td>73.2</td><td>81.4</td><td>28.7</td><td>63.3</td><td>60.7</td></tr><tr><td>Skip-thought</td><td>1M</td><td>No</td><td>57.8</td><td>77.5</td><td>81.3</td><td>47.4</td><td>67.9</td><td>61.0</td></tr><tr><td>Autoencoder</td><td>1M</td><td>Yes</td><td>71.2</td><td>81.4</td><td>81.8</td><td>59.0</td><td>67.4</td><td>61.9</td></tr><tr><td>Autoencoder</td><td>1M</td><td>No</td><td>62.2</td><td>78.7</td><td>84.2</td><td>60.2</td><td>69.4</td><td>63.5</td></tr><tr><td>Translation</td><td>5M</td><td>Yes</td><td>92.1</td><td>92.9</td><td>88.2</td><td>77.3</td><td>81.2</td><td>65.7</td></tr><tr><td>Translation</td><td>5M</td><td>No</td><td>82.7</td><td>91.7</td><td>88.0</td><td>73.5</td><td>80.7</td><td>65.9</td></tr><tr><td>LM (Bidir)</td><td>5M</td><td>No</td><td>93.7</td><td>94.0</td><td>89.1</td><td>83.0</td><td>82.4</td><td>67.1</td></tr><tr><td>LMForward</td><td>5M</td><td>No</td><td>90.7</td><td>92.1</td><td>88.8</td><td>74.3</td><td>74.3</td><td>66.7</td></tr><tr><td>Skip-thought</td><td>5M</td><td>Yes</td><td>55.3</td><td>83.4</td><td>84.8</td><td>44.5</td><td>72.4</td><td>63.0</td></tr><tr><td>Skip-thought</td><td>5M</td><td>No</td><td>69.6</td><td>86.0</td><td>84.4</td><td>53.5</td><td>75.1</td><td>62.7</td></tr><tr><td>Autoencoder</td><td>5M</td><td>Yes</td><td>67.6</td><td>79.5</td><td>80.8</td><td>58.8</td><td>64.6</td><td>61.0</td></tr><tr><td>Autoencoder</td><td>5M</td><td>No</td><td>60.7</td><td>81.1</td><td>82.6</td><td>56.0</td><td>68.7</td><td>61.8</td></tr><tr><td>LM (Bidir)</td><td>15M</td><td>No</td><td>94.4</td><td>94.7</td><td>89.6</td><td>82.8</td><td>83.7</td><td>67.5</td></tr><tr><td>LMForward</td><td>15M</td><td>No</td><td>91.7</td><td>93.1</td><td>89.3</td><td>74.8</td><td>75.8</td><td>67.3</td></tr><tr><td>Skip-thought</td><td>15M</td><td>Yes</td><td>50.7</td><td>85.4</td><td>84.9</td><td>29.6</td><td>73.8</td><td>63.5</td></tr><tr><td>Skip-thought</td><td>15M</td><td>No</td><td>75.2</td><td>88.1</td><td>84.9</td><td>63.5</td><td>77.4</td><td>63.7</td></tr><tr><td>Autoencoder</td><td>15M</td><td>Yes</td><td>77.9</td><td>82.3</td><td>81.9</td><td>66.9</td><td>68.7</td><td>62.6</td></tr><tr><td>Autoencoder</td><td>15M</td><td>No</td><td>61.2</td><td>80.4</td><td>82.3</td><td>56.6</td><td>69.8</td><td>62.0</td></tr><tr><td>LM (Bidir)</td><td>63M</td><td>No</td><td>94.3</td><td>94.8</td><td>89.7</td><td>82.9</td><td>83.9</td><td>67.5</td></tr><tr><td>LMForward</td><td>63M</td><td>No</td><td>92.1</td><td>93.3</td><td>89.4</td><td>74.9</td><td>76.2</td><td>67.6</td></tr><tr><td>Skip-thought</td><td>63M</td><td>Yes</td><td>69.8</td><td>90.2</td><td>86.3</td><td>55.4</td><td>78.1</td><td>64.4</td></tr><tr><td>Skip-thought</td><td>63M</td><td>No</td><td>77.9</td><td>89.6</td><td>86.1</td><td>64.8</td><td>78.4</td><td>64.0</td></tr><tr><td>Autoencoder</td><td>63M</td><td>Yes</td><td>72.1</td><td>80.1</td><td>81.5</td><td>58.7</td><td>66.8</td><td>61.3</td></tr><tr><td>Autoencoder</td><td>63M</td><td>No</td><td>60.6</td><td>80.6</td><td>82.3</td><td>55.7</td><td>68.6</td><td>61.7</td></tr></table>
+
+Table 4: Here we display results for training on $1 \%$ of auxiliary task data. Word-conditional most frequent class baselines for this amount of training data are $8 1 . 8 \%$ for POS tagging and $6 2 . 3 \%$ for CCG supertagging. For each task, we underline the best performance for each training dataset size and bold the best overall performance.

parse/train/ryeNPi0qKX/ryeNPi0qKX_content_list.json

@@ -0,0 +1,1146 @@
+[
+    {
+        "type": "text",
+        "text": "LANGUAGE MODELING TEACHES YOU MORE SYNTAX THAN TRANSLATION DOES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            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,
+            234,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recent work using auxiliary prediction task classifiers to investigate the properties of LSTM representations has begun to shed light on why pretrained representations, like ELMo (Peters et al., 2018) and CoVe (McCann et al., 2017), are so beneficial for neural language understanding models. We still, though, do not yet have a clear understanding of how the choice of pretraining objective affects the type of linguistic information that models learn. With this in mind, we compare four objectives—language modeling, translation, skip-thought, and autoencoding—on their ability to induce syntactic and part-of-speech information. We make a fair comparison between the tasks by holding constant the quantity and genre of the training data, as well as the LSTM architecture. We find that representations from language models consistently perform best on our syntactic auxiliary prediction tasks, even when trained on relatively small amounts of data. These results suggest that language modeling may be the best data-rich pretraining task for transfer learning applications requiring syntactic information. We also find that the representations from randomly-initialized, frozen LSTMs perform strikingly well on our syntactic auxiliary tasks, but this effect disappears when the amount of training data for the auxiliary tasks is reduced. ",
+        "bbox": [
+            233,
+            266,
+            764,
+            502
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            529,
+            336,
+            545
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Representation learning with deep recurrent neural networks has revolutionized natural language processing and replaced many of the expert-designed, linguistic features used previously. Recently, researchers have begun to investigate the properties of learned representations by training auxiliary classifiers that use the hidden states of frozen, pretrained models to perform other tasks. These investigations have shown that when deep LSTMs (Hochreiter & Schmidhuber, 1997) are trained on tasks like translation, they learn substantial syntactic and semantic information about their input sentences, including part-of-speech (Shi et al., 2016; Belinkov et al., 2017a;b; Blevins et al., 2018). ",
+        "bbox": [
+            174,
+            560,
+            825,
+            659
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "These intriguing findings lead us to ask the following questions: ",
+        "bbox": [
+            173,
+            665,
+            593,
+            679
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1. How does the training task affect how well models learn syntactic properties? Which tasks are better at inducing these properties?   \n2. How does the amount of data the model is trained on affect these results? When does training on more data help? ",
+        "bbox": [
+            212,
+            686,
+            825,
+            742
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We investigate these questions by holding the data source and model architecture constant, while varying both the training task and the amount of training data. Specifically, we examine models trained on English-German (En-De) translation, language modeling, skip-thought (Kiros et al., 2015), and autoencoding, and also compare to an untrained LSTM model as a baseline. We control for the data domain by exclusively training on datasets from the 2016 Conference on Machine Translation (WMT; Bojar et al., 2016). We train models on all tasks using the parallel En-De corpus, which allows us to make fair comparisons across tasks. We also train models on a subset of the this corpus to examine the effect of training data volume on learned representations. Additionally, we augment the parallel dataset with a large monolingual corpus from WMT to examine how the performance of the unsupervised tasks (all but translation) scale with more data. ",
+        "bbox": [
+            173,
+            750,
+            825,
+            888
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Throughout our work, we focus on the syntactic evaluation tasks of part-of-speech (POS) tagging and Combinatorial Categorical Grammar (CCG) supertagging. Supertagging is considered a building block for parsing as these tags constrain the ways in which words can compose, largely determining the parse of the sentence. CCG supertagging thus allows us to measure the degree to which models learn syntactic structure above the word. We focus our analysis on representations learned by language models and by the encoders of sequence-to-sequence models, as translation encoders have been found to learn richer representations of POS and morphological information than translation decoders (Belinkov et al., 2017a). ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            186
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We find that for POS and CCG tagging, bidirectional language models (BiLMs)—created by separately training forward and backward language models, and concatenating their hidden states— outperform models trained on all other tasks. Even BiLMs trained on relatively small amounts of data (1 million sentences) outperform translation and skip-thought models trained on larger datasets (5 million and 63 million sentences respectively). ",
+        "bbox": [
+            174,
+            194,
+            825,
+            263
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our inclusion of an untrained LSTM baseline allows us to study the effect of training on hidden state representations of LSTMs. We find, surprisingly, that when we use all of the available labeled tag data to train our auxiliary task classifiers, our best trained models (BiLMs) only outperform the randomly initialized, untrained LSTMs by a few percentage points. When we reduce the amount of classifier training data though, the performance of the randomly initialized LSTM model drops far below those of trained models. We hypothesize that this occurs because training the classifiers on large amounts of auxiliary task data allows them to memorize configurations of words seen in the training set and their associated tags. We test this hypothesis by training classifiers to predict the identity of neighboring words from a given hidden state, and find that randomly initialized models outperform all trained models on this task. Our findings demonstrate that our best trained models do well on the tagging tasks because they are truly learning representations that conform to our notions of POS and CCG tagging, and not simply because the classifiers we train are able to recover neighboring word identity information. ",
+        "bbox": [
+            174,
+            271,
+            825,
+            450
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            484,
+            343,
+            501
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Evaluating Learned Representations Adi et al. (2016) introduce the idea of examining sentence vector representations by training auxiliary classifiers to take sentence encodings and predict attributes like word order. Belinkov et al. (2017a) build on this work by examining the hidden states of LSTMs trained on translation and find that they learn substantial POS and morphological information without direct supervision for these linguistic properties. Beyond translation, Blevins et al. (2018) find that deep LSTMs learn hierarchical syntax when trained on a variety of tasks—including semantic role labeling, language modeling, and dependency parsing. However, the models examined by Blevins et al. (2018) were also trained on different datasets, so it’s unclear if the differences in syntactic task performance are due to the training objectives or simply differences in the training data. By controlling for model size and the quantity and genre of the training data, we we are able to make direct comparisons between tasks on their ability to induce syntactic information. ",
+        "bbox": [
+            174,
+            525,
+            825,
+            678
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Transfer Learning of Representations Much of the work on sentence-level pretraining has focused on sentence-to-vector models and evaluating learned representations on how well they can be used to perform sentence-level classification tasks. A prominent early success in this area with unlabeled data is skip-thought (Kiros et al., 2015), the technique of training a sequence-to-sequence model to predict the sentence preceding and following each sentence in a running text. InferSent (Conneau et al., 2017)—the technique of pretraining encoders on natural language inference data— yields strikingly better performance when such labeled data is available. ",
+        "bbox": [
+            174,
+            708,
+            825,
+            805
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Work in transfer learning of representations has recently moved beyond strict sentence-to-vector mappings. Newer models that incorporate LSTMs or Transformer networks pretrained on datarich tasks, like translation and language modeling, have achieved state-of-the-art results on many tasks—including semantic role labeling, natural language inference, and coreference resolution (Peters et al., 2018; McCann et al., 2017; Howard & Ruder, 2018; Radford et al., 2018). Although comparisons have previously been made between translation and language modeling as pretraining tasks (Peters et al., 2018; Wang et al., 2018), we investigate this issue more thoroughly by controlling for the quantity and content of the training data. ",
+        "bbox": [
+            174,
+            813,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "table",
+        "img_path": "images/88c7f76bc5f1c12965fb71c93b74da32a5b2073f41e4e267078939b5ee7b15e1.jpg",
+        "table_caption": [
+            "Table 1: Perplexity of trained models by number of training sentences. All but the language models are 1000D BiLSTMs (500D per direction). The 500D forward and backward language models are combined into a single bidirectional language model for analysis experiments. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Task</td><td>Layer Size</td><td>Attn.</td><td>1 Million</td><td>5 Million</td><td>15 Million</td><td>63 Million</td></tr><tr><td>Translation</td><td>2×500D</td><td>Y</td><td>13.2 (17.6 BLEU)</td><td>9.1 (21.4 BLEU)</td><td>1</td><td>1</td></tr><tr><td>Translation</td><td>2×500D</td><td>N</td><td>25.2 (6.8 BLEU)</td><td>13.0 (12.3 BLEU)</td><td></td><td></td></tr><tr><td>LMForward</td><td>1×500D</td><td>1</td><td>104.8</td><td>81.2</td><td>82.3</td><td>76.9</td></tr><tr><td>LMBackward</td><td>1×500D</td><td>1</td><td>103.2</td><td>80.8</td><td>81.1</td><td>77.3</td></tr><tr><td>LMForward</td><td>1×1000D</td><td></td><td>103.8</td><td>73.6</td><td>69.2</td><td>66.5</td></tr><tr><td>Skip-Thought</td><td>2×500D</td><td>Y</td><td>99.0</td><td>69.2</td><td>68.7</td><td>67.9</td></tr><tr><td>Skip-Thought</td><td>2×500D</td><td>N</td><td>104.1</td><td>72.0</td><td>68.1</td><td>66.7</td></tr><tr><td>Autoencoder</td><td>2×500D</td><td>Y</td><td>1.0</td><td>1.0</td><td>1.0</td><td>1.0</td></tr><tr><td>Autoencoder</td><td>2×500D</td><td>N</td><td>1.0</td><td>1.1</td><td>1.2</td><td>1.1</td></tr></table>",
+        "bbox": [
+            173,
+            101,
+            825,
+            242
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Training Dataset Size The performance of neural models depends immensely on the amount of training data used. Koehn & Knowles (2017) find that when training machine translation models on corpora with fewer than 15 million words (English side), statistical machine translation approaches outperform neural ones. Similarly, Hestness et al. (2017) study the affect of training data volume on performance for several tasks—including translation and image classification. They find that for small amounts of data, neural models perform about as well as chance. After a certain threshold, model performance improves logarithmically with the amount of training data, but this eventually plateaus. With this in mind, we also vary the amount of training data to investigate the relationship between performance and data volume for each task. ",
+        "bbox": [
+            174,
+            327,
+            825,
+            452
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Randomly Initialized Models Conneau et al. (2018) use randomly initialized LSTMs as a baseline when studying sentence-to-vector embedding models. They find that untrained models outperform many trained models on several auxiliary tasks, including predicting word content. Similarly in vision, untrained convolutional networks have been shown to capture many low-level image statistics and can be used for image denoising (Ulyanov et al., 2017). Our method of training auxiliary classifiers on randomly initialized RNNs builds on the tradition of reservoir computing, in which randomly initialized networks or “reservoirs” are fixed and only “read-out” classifier networks are trained (Lukosevi ˇ cius & Jaeger, 2009). Echo state networks—reservoir computing with recurrent ˇ models—have been used for tasks like speech recognition, language modeling, and time series prediction (Verstraeten et al., 2006; Tong et al., 2007; Sun et al., 2017). ",
+        "bbox": [
+            174,
+            472,
+            825,
+            611
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 METHODS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            636,
+            290,
+            651
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 MAIN TRAINING DATA ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            670,
+            372,
+            684
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We use the parallel English-German (En-De) dataset from the 2016 ACL Conference on Machine Translation (WMT) shared task on news translation (Bojar et al., 2016). This dataset contains 5 million ordered sentence translation pairs. We also use the 2015 English monolingual news discussion dataset from the same WMT shared task, which contains approximately 58 million ordered sentences. To examine how the volume of training data affects learned representations, we use four corpus sizes: 1, 5, 15, and 63 million sentences (translation is only trained on the smaller two sizes). We create the 1 million sentence corpora from the 5 million sentence dataset by sampling (i) sentence pairs for translation, (ii) English sentences for autoencoders, and (iii) ordered English sentence pairs for skip-thought and language models1. Similarly, we create the 15 million sentence corpora for the unsupervised tasks by sampling sentences from the entire corpus of 63 million sentences. We use word-level representations throughout and use the Moses package (Koehn et al., 2007) to tokenize and truecase our data. Finally, we limit both the English and German vocabularies to the $5 0 \\mathrm { k }$ most frequent tokens in the training set. ",
+        "bbox": [
+            174,
+            698,
+            825,
+            878
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Soon she was running the office RB PRP VBD VBG DT NN (a) POS tags ",
+        "bbox": [
+            215,
+            137,
+            455,
+            188
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/55f65e44e652f99afd857c7935ea88453a4f48da46dfd39c9456e8d3abae90a3.jpg",
+        "image_caption": [
+            "Figure 1: An annotated PTB example sentence. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            517,
+            101,
+            813,
+            190
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "(b) A CCG parse, with supertags shown immediately below the words. ",
+        "bbox": [
+            504,
+            198,
+            831,
+            223
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 MODEL ARCHITECTURE AND TRAINING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            276,
+            495,
+            290
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We train all our models using OpenNMT-py (Klein et al., 2017) and use the default options for model sizes, hyperparameters, and training procedure—except we increase the size of the LSTMs, make the encoders bidirectional, and use validation-based learning rate decay instead of a fixed schedule. Specifically, all our models (except language models) are 1000D, two-layer encoder-decoder LSTMs with bidirectional encoders (500D per direction) and 500D embeddings. We train models both with and without attention (Bahdanau et al., 2015). For language models, we train a 1000D forward language model and a bidirectional language model—two 500D language models (forward and backward) trained separately, whose hidden states are concatenated. All models, including our untrained baseline, are initialized from a uniform distribution $( - 0 . 1 , 0 . 1 )$ , the default in OpenNMT. ",
+        "bbox": [
+            173,
+            301,
+            825,
+            426
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We use the same training procedure for all our models. We evaluate on the validation set every epoch when training on the 1 and 5 million sentence datasets, and evaluate approximately every 5 million sentences when training on the larger datasets. We use SGD with an initial learning rate of 1. Whenever a model’s validation loss increases relative to the previous evaluation, we halve the learning rate and stop training when the learning rate reaches $0 . 5 ^ { \\mathbf { \\hat { 1 } 5 } }$ . For each training task and dataset size, we select the model with the lowest validation perplexity to perform auxiliary task evaluations on. We report model performance in terms of perplexity and BLEU (Papineni et al., 2002) in Table 1. For translation we use beam search $\\mathrm { B } = 5$ ) when decoding. ",
+        "bbox": [
+            174,
+            434,
+            825,
+            545
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.3 CLASSIFIER DATA AND ARCHITECTURE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            561,
+            488,
+            575
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "POS and CCG For Part-of-Speech (POS) tagging evaluation, we use the Wall Street Journal (WSJ) portion of the Penn Treebank (PTB; Marcus et al., 1993) We follow the standard WSJ split (train 2-21; dev 22; test 23). The dataset contains approximately 50k sentences and 45 tag types. ",
+        "bbox": [
+            174,
+            588,
+            825,
+            630
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For CCG supertagging, we use CCG Bank (Hockenmaier & Steedman, 2007), which is based on PTB WSJ. CCG supertagging provides fine-grained information about the role of each word in its larger syntactic context and is considered almost parsing, since sequences of tags map sentences to small subsets of possible parses. The entire dataset contains approximately $5 0 \\mathrm { k }$ sentences and 1327 tag types. We display POS and CCG tags for an example sentence in Figure 1. ",
+        "bbox": [
+            174,
+            636,
+            823,
+            707
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To study the impact of auxiliary task training data volume, for both datasets we create smaller classifier training sets by sampling $10 \\%$ and $1 \\%$ of the sentences. We truecase both datasets using the same truecase model trained on WMT and restrict the vocabularies to the $5 0 \\mathrm { k }$ tokens used in pretraining our LSTM models. In addition to the untrained LSTM baseline, we also compare to the word-conditional most frequent class (WC-MFC)—the most frequently assigned tag class for each distinct word in the training set. For this baseline we restrict the vocabulary to that of our LSTM models and map all out-of-vocabulary words to a single UNK token. Note that while PTB and WMT are both drawn from news text, there is slight genre mismatch. ",
+        "bbox": [
+            174,
+            713,
+            825,
+            825
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Word Identity For this task, the classifier takes a single LSTM hidden state as input and predicts the identity of the word at a different time step. For example, for the sentence “I love NLP” and a time step shift of -2, we would train the classifier to take the hidden state for “NLP” and predict the word “I”. We use the WSJ dataset for this task. Following Conneau et al. (2018), we take all words that occur between 100 and 1000 times (about 1000 words total) as the possible targets for neighboring word prediction. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/b68a5a7d50f13dc4ce2cd55ef7ce0d4f17964d678ac86e46f42ec97bc37bb6a7.jpg",
+        "image_caption": [
+            "",
+            "Figure 2: POS and CCG tagging accuracies for different amounts of LSTM encoder and classifier training data. We show results for the best performing layer of each model. Note, BiLMs are displayed with the attention models and forward LMs are displayed with the models without attention. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            104,
+            825,
+            584
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Classifier Training Procedure We train multi-layer perceptron (MLP) classifiers that take an LSTM hidden state (from one time step and one layer) and output a distribution over the possible labels (tags or word identities). The MLPs we train have a single 1000D hidden layer with a ReLU activation. For classifier training, we use the same training and learning rate decay procedure used for pretraining the LSTM encoders. ",
+        "bbox": [
+            174,
+            661,
+            825,
+            731
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 COMPARING PRETRAINING TASKS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            751,
+            493,
+            767
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this section we discuss the main POS and CCG tagging results displayed in Figure 2. Overall, POS and CCG tagging accuracies tend to increase with the amount of data the LSTM encoders are trained on, but the marginal improvement decreases as the amount of training data increases. ",
+        "bbox": [
+            174,
+            782,
+            825,
+            825
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Language Modeling and Translation For all pretraining dataset sizes, bidirectional language model (BiLM) and translation encoder representations perform best on both POS and CCG tagging. Translation encoders, however, slightly underperform BiLMs, even when both models are trained on the same amount of data. In fact, even BiLMs trained on the smallest amount of data (1 million sentences) outperform models trained on all other tasks and dataset sizes (up to 5 million sentences for translation, and 63 million sentences for skip-thought and autoencoding). Especially since BiLMs ",
+        "bbox": [
+            174,
+            840,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "(a) WC-MFC baselines for different amounts of PTB training data: $1 \\%$ PTB: $8 1 . 8 \\%$ ; $10 \\%$ PTB: $8 8 . 6 \\%$ ; $100 \\%$ PTB: $8 9 . 9 \\%$ . ",
+        "bbox": [
+            178,
+            282,
+            491,
+            319
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/5487db7289b1df961d9b91688520bb743cf4847dc08fb1972a04800e7720fa4a.jpg",
+        "image_caption": [
+            "(b) WC-MFC baselines for different amounts of CCG training data: $1 \\%$ CCG: $6 2 . 3 \\%$ ; $10 \\%$ CCG: $6 8 . 3 \\%$ ; $100 \\%$ CCG: $7 1 . 6 \\%$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            108,
+            490,
+            276
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/8f6e77fb793953ea416ba31d34ffc971f00544f63113a5e4fd56bd28c320805c.jpg",
+        "image_caption": [
+            "Figure 3: POS and CCG tagging accuracies for different amounts of classifier training data in terms of percentage points over the word-conditional most frequent class (WC-MFC) baseline. We show results for the best performing layer and model for each task. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            504,
+            106,
+            816,
+            276
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "do not require aligned data to train, the superior performance of BiLM representations on these tasks suggests that BiLMs (like ELMo; Peters et al., 2018) are better than translation encoders (like CoVe; McCann et al., 2017) for transfer learning of syntactic information. One reason BiLMs perform relatively well on these syntactic tasks could be that in contrast to the encoders for the other tasks, LM encoders have a per-token loss. Note also that since our evaluation tasks also predict a single label for each token, this could be one reason that BiLMs perform so well on these tasks in particular. ",
+        "bbox": [
+            174,
+            402,
+            823,
+            486
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For all amounts of training data, the BiLMs significantly outperform the 1000D forward-only language models. The gap in performance between bidirectional and forward language models is greater for CCG supertagging than for POS tagging. When using all available auxiliary training data, there is a 2 and 8 percentage point performance gap in POS and CCG tagging respectively. This difference in relative performance suggests that bidirectional context information is more important for identifying syntactic structure than for identifying part of speech. ",
+        "bbox": [
+            173,
+            493,
+            825,
+            577
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Figure 2 illustrates how the best performing BiLMs and translation models tend to be more robust to decreases in classifier data than models trained on other tasks. Also, when training on less auxiliary task data, POS tagging performance tends to drop less than CCG supertagging performance. For the best model (BiLM trained on 63 million sentences), when using $1 \\%$ rather than all of the auxiliary task training data, CCG accuracy drops 9 percentage points, while POS accuracy only drops 2 points. Further examinations of the effect of classifier data volume are displayed in Figure 3. ",
+        "bbox": [
+            174,
+            584,
+            823,
+            667
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Skip-Thought Although skip-thought encoders consistently underperform both BiLMs and translation encoders in all data regimes we examine, skip-thought models improve the most when increasing the amount of pretraining data, and are the only models whose performance does not seem to have plateaued by 63 million training sentences. Since we train our language models on ordered sentences, as we do for skip-thought, our language models can be interpreted as a regularized versions of skip-thought, in which the weights of the encoder and decoder are shared. The increased model capacity of skip-thought, compared to language models, could explain the difference in learned representation quality—especially when these models are trained on smaller amounts of data. ",
+        "bbox": [
+            173,
+            684,
+            825,
+            796
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Random Initialization For our randomly initialized, untrained LSTM encoders, we use the default weight initialization technique in OpenNMT-py, a uniform distribution between $- 0 . 1$ and 0.1; the only change we make is to set all biases to zero. We find that this baseline performs quite well when using all auxiliary data, and is only 3 and 8 percentage points behind the BiLM on POS and CCG tagging, respectively. We find that decreasing the amount of classifier data leads to a significantly greater drop in the untrained encoder performance compared to trained models. In the $1 \\%$ classifier data regime, the performance of untrained encoders on both tasks drops below that of all trained models and below even the word-conditional most-frequent class baseline. ",
+        "bbox": [
+            174,
+            811,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/8f61c3c81319fdf73e823d448b463e2042969030ce7fde8062341493f5774e19.jpg",
+        "image_caption": [
+            "Figure 4: POS and CCG tagging accuracies in terms of percentage points over the word-conditional most frequent class baseline. We display results for the best performing models for each task. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            102,
+            815,
+            279
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We hypothesize that the randomly initialized baseline is able to perform well on tagging tasks with large amounts of auxiliary task training data, because the classifier can learn the identity of neighboring words from a given time step’s hidden state, and simply memorize word configurations and their associated tags from the training data. We test this hypothesis directly in Section 6 and find that untrained LSTM representations are in fact better at capturing neighboring word identity information than any trained model. ",
+        "bbox": [
+            174,
+            351,
+            825,
+            435
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Autoencoder Models trained on autoencoding are the only ones that do not consistently improve with the amount of training data, which is unsurprising as unregularized autoencoders are prone to learning identity mappings (Vincent et al., 2008). When training on $10 \\%$ and $1 \\%$ of the auxiliary task data, autoencoders outperform randomly initialized encoders and match the word-conditional most frequent class baseline. When training on all the auxiliary data though, untrained encoders outperform autoencoders. These results suggest that autoencoders learn some useful structure that is useful in the low auxiliary data regime. However, the representations autoencoders learn do not capture syntactically rich features, since random encoders outperform them in the high auxiliary data regime. This conclusion is further supported by the extremely poor performance of the second layer of an autoencoder without attention on POS tagging (almost 10 percentage points below the most frequent class baseline), as seen in Figure 4a. ",
+        "bbox": [
+            174,
+            457,
+            825,
+            609
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5 COMPARING LAYERS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            636,
+            382,
+            652
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Embeddings (Layer 0) We find that randomly initialized embeddings consistently perform as well as the word-conditional most frequent class baseline on POS and CCG tagging, which serves as an upper bound on performance for the embedding layer. As these embeddings are untrained, the auxiliary classifiers are learning to memorize and classify the random vectors. When using all the auxiliary classifier data, there is no significant difference in the performance of trained and untrained embeddings on the tagging tasks. Only for smaller amounts of classifier data do trained embeddings consistently outperform randomly initialized ones. ",
+        "bbox": [
+            174,
+            671,
+            825,
+            768
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Upper Layers Belinkov et al. (2017a) find that, for translation models, the first layer consistently outperforms the second on POS tagging. We find that this pattern holds for all our models, except in BiLMs, for which the first and second layers perform equivalently. The pattern holds even for untrained models, suggesting that POS information is stored on the lower layer, not necessarily because the training task encourages this, but because of properties of the deep LSTM architecture. ",
+        "bbox": [
+            174,
+            790,
+            823,
+            861
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We also find that for CCG supertagging, the first layer also outperforms the second layer on untrained models. For the trained models though, the second layer performs better than the first in some cases. Which layer performs best appears to be independent of absolute performance on the supertagging task. Our layer analysis results are displayed in Figure 4. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/ffb876081fbb51d93085a3a7df69a3a3f1ad29500415e7befd90ba3e0c08c40e.jpg",
+        "image_caption": [
+            "Figure 5: Performance of classifiers trained to predict the identity of the word a fixed number of timesteps away. Note, the forward LM has asymmetrical access to this information in its input. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            210,
+            104,
+            789,
+            327
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 WORD IDENTITY PREDICTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            404,
+            457,
+            420
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Our results on word identity prediction are summarized in Figure 5 and given in more detail in Appendix A. While trained encoders outperform untrained ones on both POS and CCG tagging, we find that all trained LSTMs underperform untrained ones on word identity prediction. This finding confirms that trained encoders genuinely capture substantial syntactic features, beyond mere word identity, that the auxiliary classifiers can use. ",
+        "bbox": [
+            174,
+            436,
+            825,
+            506
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We find that for both trained and untrained models, the first layer outperforms the second layer when predicting the identity of the immediate neighbors of a word. However, the second layer tends to outperform the first at predicting the identity of more distant neighboring words. This effect is especially apparent for the randomly initialized encoders. Our finding suggests that, as is the case for convolutional neural networks, depth in recurrent neural networks has the effect of increasing the receptive field and allows the upper layers to have representations that capture a larger context. These results reflect the findings of Blevins et al. (2018) that for trained models, upper levels of LSTMs encode more abstract syntactic information, since more abstract information generally requires larger context information. ",
+        "bbox": [
+            174,
+            513,
+            825,
+            638
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "7 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            661,
+            318,
+            676
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "By controlling for the genre and quantity of the training data, we make fair comparisons between several data-rich training tasks in their ability to induce syntactic information. We find that bidirectional language models (BiLMs) do better than translation and skip-thought encoders at extracting useful features for POS tagging and CCG supertagging. Moreover, this improvement holds even when the BiLMs are trained on substantially less data than competing models. Our results suggest that for transfer learning, BiLMs like ELMo (Peters et al., 2018) capture more useful features than translation encoders—and that this holds even on genres for which data is not abundant. ",
+        "bbox": [
+            174,
+            694,
+            825,
+            791
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We also find that randomly initialized encoders extract usable features for POS and CCG tagging— at least when the auxiliary POS and CCG classifiers are themselves trained on reasonably large amounts of data. The performance of untrained models drops sharply relative to trained ones when using smaller amounts of the classifier data. We investigate further and find that untrained models outperform trained ones on the task of neighboring word identity prediction, which confirms that trained encoders do not perform well on tagging tasks because the classifiers are simply memorizing word identity information. We also find that both trained and untrained LSTMs store more local neighboring word identity information in lower layers and more distant word identity information in upper layers, which suggests that depth in LSTMs allow them to capture larger context information. ",
+        "bbox": [
+            174,
+            799,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            287,
+            117
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yossi Adi, Einat Kermany, Yonatan Belinkov, Ofer Lavi, and Yoav Goldberg. Fine-grained Analysis of Sentence Embeddings Using Auxiliary Prediction Tasks. ICLR, 2016. URL http://arxiv. org/abs/1608.04207. ",
+        "bbox": [
+            176,
+            126,
+            821,
+            167
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural Machine Translation by Jointly Learning to Align and Translate. ICLR, 2015. ",
+        "bbox": [
+            173,
+            178,
+            823,
+            207
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yonatan Belinkov, Llu´ıs Marquez, Hassan Sajjad, Nadir Durrani, Fahim Dalvi, and James Glass. \\` Evaluating Layers of Representation in Neural Machine Translation on Part-of-Speech and Semantic Tagging Tasks. IJCNLP, 2017b. URL https://arxiv.org/abs/1801.07772. ",
+        "bbox": [
+            178,
+            215,
+            823,
+            260
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yonatan Belinkov, Nadir Durrani, Fahim Dalvi, Hassan Sajjad, and James R. Glass. What do Neural Machine Translation Models Learn about Morphology? ACL, 2017a. URL http://arxiv. org/abs/1704.03471. ",
+        "bbox": [
+            176,
+            268,
+            821,
+            311
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Terra Blevins, Omer Levy, and Luke Zettlemoyer. Deep RNNs Learn Hierarchical Syntax. ACL, 2018. ",
+        "bbox": [
+            173,
+            320,
+            821,
+            349
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ondrej Bojar, Rajen Chatterjee, Christian Federmann, Yvette Graham, Barry Haddow, Matthias Huck, Antonio Jimeno Yepes, Philipp Koehn, Varvara Logacheva, Christof Monz, Matteo Negri, Aurelie Neveol, Mariana Neves, Martin Popel, Matt Post, Raphael Rubino, Carolina Scarton, Lucia Specia, Marco Turchi, Karin Verspoor, and Marcos Zampieri. Findings of the 2016 Conference on Machine Translation (WMT16). ACL, 2016. ",
+        "bbox": [
+            173,
+            359,
+            825,
+            430
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Alexis Conneau, Douwe Kiela, Holger Schwenk, Loic Barrault, and Antoine Bordes. Supervised Learning of Universal Sentence Representations from Natural Language Inference Data. ACL, 2017. ",
+        "bbox": [
+            174,
+            439,
+            823,
+            481
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Alexis Conneau, German Kruszewski, Guillaume Lample, Lo \\` ¨ı Barrault, and Marco Baroni. What you can cram into a single \\$&!#\\* vector: Probing sentence embeddings for linguistic properties. ACL, 2018. ",
+        "bbox": [
+            173,
+            491,
+            823,
+            534
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Joel Hestness, Sharan Narang, Newsha Ardalani, Gregory F. Diamos, Heewoo Jun, Hassan Kianinejad, Md. Mostofa Ali Patwary, Yang Yang, and Yanqi Zhou. Deep Learning Scaling is Predictable, Empirically. arXiv preprint 1712.00409, 2017. URL http://arxiv.org/abs/ 1712.00409. ",
+        "bbox": [
+            173,
+            542,
+            825,
+            599
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sepp Hochreiter and Juergen Schmidhuber. Long Short-Term Memory. ¨ Neural Computation, 9(8): 1735–1780, 1997. ",
+        "bbox": [
+            173,
+            609,
+            823,
+            638
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Julia Hockenmaier and Mark Steedman. CCGbank: A Corpus of CCG Derivations and Dependency Structures Extracted from the Penn Treebank. Computational Linguistics, 2007. URL http: //www.aclweb.org/anthology/J07-3004. ",
+        "bbox": [
+            173,
+            647,
+            825,
+            690
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jeremy Howard and Sebastian Ruder. Universal Language Model Fine-tuning for Text Classification. ACL, 2018. URL http://arxiv.org/abs/1801.06146. ",
+        "bbox": [
+            171,
+            699,
+            823,
+            729
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ryan Kiros, Yukun Zhu, Ruslan Salakhutdinov, Richard S. Zemel, Antonio Torralba, Raquel Urtasun, and Sanja Fidler. Skip-Thought Vectors. NIPS, 2015. URL http://arxiv.org/abs/ 1506.06726. ",
+        "bbox": [
+            173,
+            738,
+            825,
+            781
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Guillaume Klein, Yoon Kim, Yuntian Deng, Jean Senellart, and Alexander M. Rush. OpenNMT: Open-Source Toolkit for Neural Machine Translation. ACL, 2017. doi: 10.18653/v1/P17-4012. URL https://doi.org/10.18653/v1/P17-4012. ",
+        "bbox": [
+            176,
+            790,
+            823,
+            833
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Philip Koehn and Rebecca Knowles. Six Challenges for Neural Machine Translation. ACL, 2017. ",
+        "bbox": [
+            169,
+            842,
+            812,
+            858
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Philipp Koehn, Hieu Hoang, Alexandra Birch, Chris Callison-Burch, Marcello Federico, Nicola Bertoldi, Brooke Cowan, Wade Shen, Christine Moran, Richard Zens, Chris Dyer, Ondˇrej Bojar, Alexandra Constantin, and Evan Herbst. Moses: Open Source Toolkit for Statistical Machine Translation. ACL, 2007. URL http://www.statmt.org/moses/. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Mantas Lukosevi ˇ cius and Herbert Jaeger. Reservoir computing approaches to recurrent neural net- ˇ work training. In Computer Science Review, volume 3, pp. 127–149, 2009. ",
+        "bbox": [
+            171,
+            103,
+            821,
+            132
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Mitchell P. Marcus, Mary Ann Marcinkiewicz, and Beatrice Santorini. Building a Large Annotated Corpus of English: The Penn Treebank. Computational Linguistics, 1993. URL http://dl. acm.org/citation.cfm?id $=$ 972470.972475. ",
+        "bbox": [
+            176,
+            140,
+            821,
+            184
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Bryan McCann, James Bradbury, Caiming Xiong, and Richard Socher. Learned in Translation: Contextualized Word Vectors. NIPS, 2017. ",
+        "bbox": [
+            171,
+            193,
+            823,
+            222
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kishore Papineni, Salim Roukos, Todd Ward, and Wei-Jing Zhu. Bleu: a Method for Automatic Evaluation of Machine Translation. ACL, 2002. URL http://www.aclweb.org/ anthology/P02-1040.pdf. ",
+        "bbox": [
+            174,
+            231,
+            823,
+            273
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Matthew E. Peters, Mark Neumann, Mohit Iyyer, Matt Gardner, Christopher Clark, Kenton Lee, and Luke Zettlemoyer. Deep contextualized word representations. NAACL, 2018. URL http: //arxiv.org/abs/1802.05365. ",
+        "bbox": [
+            173,
+            281,
+            825,
+            325
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alec Radford, Karthik Narasimhan, Tim Salimans, and Ilya Sutskever. Improving Language Understanding by Generative Pre-Training. 2018. URL http://openai-assets.s3. amazonaws.com/research-covers/language-unsupervised/language_ understanding_paper.pdf. ",
+        "bbox": [
+            174,
+            333,
+            825,
+            390
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Xing Shi, Inkit Padhi, and Kevin Knight. Does String-Based Neural MT Learn Source Syntax? EMNLP, 2016. URL https://www.isi.edu/natural-language/mt/ emnlp16-nmt-grammar.pdf. ",
+        "bbox": [
+            174,
+            398,
+            826,
+            441
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Xiaochuan Sun, Tao Li, Qun Li, Yue Huang, and Yingqi Li. Deep belief echo-state network and its application to time series prediction. Knowl.-Based Syst., 130:17–29, 2017. ",
+        "bbox": [
+            171,
+            450,
+            823,
+            479
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Matthew H. Tong, Adam D. Bickett, Eric M. Christiansen, and Garrison W. Cottrell. Learning grammatical structure with echo state networks. Neural Networks, 20(3):424–432, 2007. doi: 10. 1016/j.neunet.2007.04.013. URL https://doi.org/10.1016/j.neunet.2007.04. 013. ",
+        "bbox": [
+            174,
+            488,
+            825,
+            545
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Dmitry Ulyanov, Andrea Vedaldi, and Victor Lempitsky. Deep Image Prior. NIPS, 2017. ",
+        "bbox": [
+            173,
+            553,
+            758,
+            569
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "David Verstraeten, Benjamin Schrauwen, and Dirk Stroobandt. Reservoir-based techniques for speech recognition. In The 2006 IEEE International Joint Conference on Neural Network Proceedings, pp. 1050–1053, July 2006. doi: 10.1109/IJCNN.2006.246804. ",
+        "bbox": [
+            176,
+            577,
+            825,
+            621
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Pascal Vincent, Hugo Larochelle, Yoshua Bengio, and Pierre-Antoine Manzagol. Extracting and Composing Robust Features with Denoising Autoencoders. In Machine Learning, Proceedings of the Twenty-Fifth International Conference (ICML 2008), Helsinki, Finland, June 5-9, 2008, pp. 1096–1103, 2008. ",
+        "bbox": [
+            173,
+            628,
+            826,
+            685
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alex Wang, Amapreet Singh, Julian Michael, Felix Hill, Omer Levy, and Samuel R. Bowman. GLUE: A Multi-Task Benchmark and Analysis Platform for Natural Language Understanding. 2018. URL https://arxiv.org/abs/1804.07461. ",
+        "bbox": [
+            174,
+            695,
+            826,
+            738
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "A RANDOMLY INITIALIZED ENCODERS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            516,
+            118
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/b1b4708c094604f919e241a22de7653a27769afbaac44d978caf9231a0eea125.jpg",
+        "image_caption": [
+            "Figure 6: Here we display results for the word identity prediction task with randomly initialized LSTM encoders with up to 4 layers. Lower layers have a more peaked shape and upper layers a more flat shape, meaning that the lower layers encode relatively more nearby neighboring word information, while upper layers encode relatively more distant neighboring word information. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            251,
+            138,
+            741,
+            503
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "B POS AND CCG EVALUATION FULL RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            102,
+            583,
+            118
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/ea097286bb986cf6908099e158f4dfeb60eda0631981c2b754ddbc8b19fd963c.jpg",
+        "table_caption": [
+            "B.1 TRAINING CLASSIFIERS ON ALL DATA ",
+            "Table 2: Here we display results for training on all of auxiliary task data. Word-conditional most frequent class baselines for this amount of training data are $8 9 . 9 \\%$ for POS tagging and $7 1 . 6 \\%$ for CCG supertagging. For each task, we underline the best performance for each training dataset size and bold the best overall performance. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Training task</td><td>Data</td><td>Attention</td><td>POS L2</td><td>POS L1</td><td>POS LO</td><td>CCG L2</td><td>CCG L1</td><td>CCG LO</td></tr><tr><td>Random Init 1</td><td>None</td><td>N/A</td><td>90.5</td><td>93.7</td><td>90.2</td><td>83.5</td><td>85.4</td><td>71.6</td></tr><tr><td>Random Init 2</td><td>None</td><td>N/A</td><td>90.3</td><td>93.8</td><td>90.1</td><td>83.3</td><td>85.3</td><td>71.5</td></tr><tr><td>Translation</td><td>1M</td><td>Yes</td><td>95.6</td><td>95.7</td><td>90.0</td><td>91.4</td><td>91.2</td><td>71.5</td></tr><tr><td>Translation</td><td>1M</td><td>No</td><td>92.5</td><td>95.0</td><td>90.0</td><td>88.2</td><td>90.1</td><td>71.3</td></tr><tr><td>LM (Bidir)</td><td>1M</td><td>No</td><td>96.4</td><td>96.1</td><td>90.2</td><td>92.5</td><td>92.0</td><td>71.6</td></tr><tr><td>LM (Forward)</td><td>1M</td><td>No</td><td>94.3</td><td>94.5</td><td>90.1</td><td>83.5</td><td>83.1</td><td>71.5</td></tr><tr><td>Skip-thought</td><td>1M</td><td>Yes</td><td>44.3</td><td>88.6</td><td>89.9</td><td>45.3</td><td>81.0</td><td>71.1</td></tr><tr><td>Skip-thought</td><td>1M</td><td>No</td><td>78.1</td><td>90.8</td><td>89.9</td><td>74.5</td><td>84.4</td><td>71.1</td></tr><tr><td>Autoencoder</td><td>1M</td><td>Yes</td><td>80.8</td><td>92.4</td><td>89.6</td><td>73.6</td><td>83.7</td><td>71.2</td></tr><tr><td>Autoencoder</td><td>1M</td><td>No</td><td>79.8</td><td>90.8</td><td>89.9</td><td>79.2</td><td>84.0</td><td>71.1</td></tr><tr><td>Translation</td><td>5M</td><td>Yes</td><td>96.0</td><td>95.9</td><td>90.2</td><td>92.2</td><td>91.6</td><td>71.5</td></tr><tr><td>Translation</td><td>5M</td><td>No</td><td>92.9</td><td>95.8</td><td>90.2</td><td>89.6</td><td>91.2</td><td>71.5</td></tr><tr><td>LM(Bidir)</td><td>5M</td><td>No</td><td>96.6</td><td>96.2</td><td>90.3</td><td>92.6</td><td>92.4</td><td>71.6</td></tr><tr><td>LM (Forward)</td><td>5M</td><td>No</td><td>94.6</td><td>94.7</td><td>90.2</td><td>84.0</td><td>83.5</td><td>71.5</td></tr><tr><td>Skip-thought</td><td>5M</td><td>Yes</td><td>76.4</td><td>92.2</td><td>90.0</td><td>68.4</td><td>86.4</td><td>71.1</td></tr><tr><td>Skip-thought</td><td>5M</td><td>No</td><td>86.1</td><td>94.3</td><td>90.0</td><td>81.2</td><td>88.6</td><td>71.2</td></tr><tr><td>Autoencoder</td><td>5M</td><td>Yes</td><td>88.1</td><td>91.8</td><td>89.6</td><td>76.5</td><td>82.5</td><td>70.8</td></tr><tr><td>Autoencoder</td><td>5M</td><td>No</td><td>70.7</td><td>92.1</td><td>89.8</td><td>72.7</td><td>83.7</td><td>71.0</td></tr><tr><td>LM (Bidir)</td><td>15M</td><td>No</td><td>97.0</td><td>96.8</td><td>90.6</td><td>93.1</td><td>92.9</td><td>72.0</td></tr><tr><td>LM (Forward)</td><td>15M</td><td>No</td><td>95.3</td><td>95.3</td><td>90.6</td><td>84.9</td><td>84.5</td><td>72.0</td></tr><tr><td>Skip-thought</td><td>15M</td><td>Yes</td><td>82.3</td><td>93.8</td><td>90.2</td><td>70.4</td><td>87.6</td><td>71.6</td></tr><tr><td>Skip-thought</td><td>15M</td><td>No</td><td>90.1</td><td>95.1</td><td>90.3</td><td>85.8</td><td>89.8</td><td>71.5</td></tr><tr><td>Autoencoder</td><td>15M</td><td>Yes</td><td>91.9</td><td>93.1</td><td>90.1</td><td>82.6</td><td>84.5</td><td>71.4</td></tr><tr><td>Autoencoder</td><td>15M</td><td>No</td><td>71.6</td><td>92.0</td><td>89.8</td><td>71.0</td><td>83.7</td><td>71.2</td></tr><tr><td>LM (Bidir)</td><td>63M</td><td>No</td><td>96.9</td><td>96.7</td><td>90.6</td><td>93.1</td><td>93.0</td><td>72.0</td></tr><tr><td>LM (Forward)</td><td>63M</td><td>No</td><td>95.3</td><td>95.4</td><td>90.6</td><td>84.9</td><td>84.5</td><td>72.0</td></tr><tr><td>Skip-thought</td><td>63M</td><td>Yes</td><td>90.6</td><td>95.5</td><td>90.3</td><td>80.9</td><td>90.1</td><td>71.6</td></tr><tr><td>Skip-thought</td><td>63M</td><td>No</td><td>91.6</td><td>95.6</td><td>90.3</td><td>86.8</td><td>90.3</td><td>71.6</td></tr><tr><td>Autoencoder</td><td>63M</td><td>Yes</td><td>89.4</td><td>91.8</td><td>89.6</td><td>78.4</td><td>83.2</td><td>71.2</td></tr><tr><td>Autoencoder</td><td>63M</td><td>No</td><td>70.2</td><td>91.7</td><td>89.9</td><td>70.5</td><td>83.1</td><td>71.3</td></tr></table>",
+        "bbox": [
+            176,
+            162,
+            823,
+            594
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/ab5a1e3f8756daf6e5ea37e649a639cabf7ec201701ccab7e52d69e4c144e942.jpg",
+        "table_caption": [
+            "B.2 TRAINING CLASSIFIERS ON $10 \\%$ OF DATA ",
+            "Table 3: Here we display results for training on $10 \\%$ of auxiliary task data. Word-conditional most frequent class baselines for this amount of training data are $8 8 . 6 \\%$ for POS tagging and $6 8 . 3 \\%$ for CCG supertagging. For each task, we underline the best performance for each training dataset size and bold the best overall performance. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Training task</td><td>Data</td><td>Attention</td><td>POS L2</td><td>POS L1</td><td>POS LO</td><td>CCG L2</td><td>CCG L1</td><td>CCG L0</td></tr><tr><td>Random Init 1</td><td>None</td><td>N/A</td><td>85.0</td><td>90.5</td><td>88.3</td><td>71.8</td><td>77.0</td><td>68.3</td></tr><tr><td>Random Init 2</td><td>None</td><td>N/A</td><td>84.9</td><td>90.6</td><td>88.3</td><td>72.7</td><td>77.0</td><td>68.3</td></tr><tr><td>Translation</td><td>1M</td><td>Yes</td><td>93.4</td><td>94.3</td><td>89.1</td><td>88.4</td><td>87.6</td><td>69.5</td></tr><tr><td>Translation</td><td>1M</td><td>No</td><td>89.9</td><td>93.4</td><td>89.0</td><td>82.9</td><td>86.0</td><td>69.5</td></tr><tr><td>LM (Bidir)</td><td>1M</td><td>No</td><td>95.5</td><td>95.2</td><td>89.7</td><td>89.4</td><td>88.6</td><td>70.1</td></tr><tr><td>LMForward</td><td>1M</td><td>No</td><td>93.2</td><td>93.5</td><td>89.5</td><td>80.8</td><td>80.2</td><td>69.9</td></tr><tr><td>Skip-thought</td><td>1M</td><td>Yes</td><td>34.3</td><td>84.1</td><td>88.2</td><td>36.7</td><td>74.0</td><td>68.3</td></tr><tr><td>Skip-thought</td><td>1M</td><td>No</td><td>71.3</td><td>86.9</td><td>88.2</td><td>64.9</td><td>78.0</td><td>68.1</td></tr><tr><td>Autoencoder</td><td>1M</td><td>Yes</td><td>77.9</td><td>89.6</td><td>87.7</td><td>71.5</td><td>77.4</td><td>68.3</td></tr><tr><td>Autoencoder</td><td>1M</td><td>No</td><td>71.2</td><td>87.9</td><td>88.6</td><td>71.8</td><td>78.1</td><td>68.8</td></tr><tr><td>Translation</td><td>5M</td><td>Yes</td><td>94.1</td><td>94.8</td><td>89.5</td><td>88.9</td><td>88.2</td><td>69.8</td></tr><tr><td>Translation</td><td>5M</td><td>No</td><td>89.2</td><td>94.4</td><td>89.5</td><td>85.4</td><td>87.6</td><td>69.9</td></tr><tr><td>LM (Bidir)</td><td>5M</td><td>No</td><td>95.7</td><td>95.3</td><td>89.8</td><td>89.6</td><td>88.9</td><td>70.2</td></tr><tr><td>LMForward</td><td>5M</td><td>No</td><td>93.3</td><td>93.7</td><td>89.7</td><td>81.4</td><td>80.6</td><td>70.1</td></tr><tr><td>Skip-thought</td><td>5M</td><td>Yes</td><td>66.8</td><td>89.6</td><td>88.7</td><td>60.8</td><td>81.0</td><td>68.7</td></tr><tr><td>Skip-thought</td><td>5M</td><td>No</td><td>81.2</td><td>92.1</td><td>88.7</td><td>73.4</td><td>83.7</td><td>68.7</td></tr><tr><td>Autoencoder</td><td>5M</td><td>Yes</td><td>84.9</td><td>89.0</td><td>87.6</td><td>71.8</td><td>76.1</td><td>67.9</td></tr><tr><td>Autoencoder</td><td>5M</td><td>No</td><td>65.6</td><td>89.6</td><td>88.4</td><td>65.8</td><td>77.9</td><td>68.3</td></tr><tr><td>LM (Bidir)</td><td>15M</td><td>No</td><td>96.1</td><td>95.9</td><td>90.2</td><td>89.7</td><td>89.9</td><td>70.6</td></tr><tr><td>LMForward</td><td>15M</td><td>No</td><td>94.1</td><td>94.5</td><td>90.1</td><td>82.1</td><td>81.8</td><td>70.6</td></tr><tr><td>Skip-thought</td><td>15M</td><td>Yes</td><td>72.8</td><td>91.4</td><td>89.0</td><td>63.2</td><td>82.6</td><td>68.9</td></tr><tr><td>Skip-thought</td><td>15M</td><td>No</td><td>84.6</td><td>93.2</td><td>89.0</td><td>79.8</td><td>85.5</td><td>69.1</td></tr><tr><td>Autoencoder</td><td>15M</td><td>Yes</td><td>88.3</td><td>90.3</td><td>88.4</td><td>76.6</td><td>78.9</td><td>68.7</td></tr><tr><td>Autoencoder</td><td>15M</td><td>No</td><td>68.5</td><td>89.2</td><td>88.3</td><td>68.6</td><td>78.1</td><td>68.6</td></tr><tr><td>LM (Bidir)</td><td>63M</td><td>No</td><td>96.1</td><td>96.0</td><td>90.2</td><td>90.0</td><td>90.1</td><td>70.7</td></tr><tr><td>LMForward</td><td>63M</td><td>No</td><td>94.3</td><td>94.4</td><td>90.2</td><td>82.3</td><td>81.8</td><td>70.6</td></tr><tr><td>Skip-thought</td><td>63M</td><td>Yes</td><td>85.0</td><td>94.0</td><td>89.2</td><td>73.9</td><td>86.0</td><td>69.4</td></tr><tr><td>Skip-thought</td><td>63M</td><td>No</td><td>88.0</td><td>94.0</td><td>89.3</td><td>81.6</td><td>86.1</td><td>69.3</td></tr><tr><td>Autoencoder</td><td>63M</td><td>Yes</td><td>82.8</td><td>88.9</td><td>87.4</td><td>72.7</td><td>77.3</td><td>68.4</td></tr><tr><td>Autoencoder</td><td>63M</td><td>No</td><td>67.2</td><td>89.5</td><td>88.5</td><td>66.1</td><td>77.2</td><td>68.5</td></tr></table>",
+        "bbox": [
+            176,
+            132,
+            823,
+            564
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/eae772e071c74995517ec06d3e6fdfc9bdb65486361d131d2af5abb51b6c72f1.jpg",
+        "table_caption": [
+            "B.3 TRAINING CLASSIFIERS ON $1 \\%$ OF DATA "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Training task</td><td>Data</td><td>Attn.</td><td>POS L2</td><td>POS L1</td><td>POS LO</td><td>CCG L2</td><td>CCG L1</td><td>CCG L0</td></tr><tr><td>Random Init 1</td><td>None</td><td>N/A</td><td>68.7</td><td>74.5</td><td>79.1</td><td>54.4</td><td>60.9</td><td>59.3</td></tr><tr><td>Random Init 2</td><td>None</td><td>N/A</td><td>68.8</td><td>74.5</td><td>79.5</td><td>55.5</td><td>62.0</td><td>58.8</td></tr><tr><td>Translation</td><td>1M</td><td>Yes</td><td>90.8</td><td>91.7</td><td>87.2</td><td>79.1</td><td>81.0</td><td>65.4</td></tr><tr><td>Translation</td><td>1M</td><td>No</td><td>82.5</td><td>89.9</td><td>86.9</td><td>69.0</td><td>78.3</td><td>65.0</td></tr><tr><td>LM (Bidir)</td><td>1M</td><td>No</td><td>93.5</td><td>93.8</td><td>89.0</td><td>82.8</td><td>81.6</td><td>67.1</td></tr><tr><td>LMForward</td><td>1M</td><td>No</td><td>90.8</td><td>91.8</td><td>88.5</td><td>74.3</td><td>74.1</td><td>66.5</td></tr><tr><td>Skip-thought</td><td>1M</td><td>Yes</td><td>27.2</td><td>73.2</td><td>81.4</td><td>28.7</td><td>63.3</td><td>60.7</td></tr><tr><td>Skip-thought</td><td>1M</td><td>No</td><td>57.8</td><td>77.5</td><td>81.3</td><td>47.4</td><td>67.9</td><td>61.0</td></tr><tr><td>Autoencoder</td><td>1M</td><td>Yes</td><td>71.2</td><td>81.4</td><td>81.8</td><td>59.0</td><td>67.4</td><td>61.9</td></tr><tr><td>Autoencoder</td><td>1M</td><td>No</td><td>62.2</td><td>78.7</td><td>84.2</td><td>60.2</td><td>69.4</td><td>63.5</td></tr><tr><td>Translation</td><td>5M</td><td>Yes</td><td>92.1</td><td>92.9</td><td>88.2</td><td>77.3</td><td>81.2</td><td>65.7</td></tr><tr><td>Translation</td><td>5M</td><td>No</td><td>82.7</td><td>91.7</td><td>88.0</td><td>73.5</td><td>80.7</td><td>65.9</td></tr><tr><td>LM (Bidir)</td><td>5M</td><td>No</td><td>93.7</td><td>94.0</td><td>89.1</td><td>83.0</td><td>82.4</td><td>67.1</td></tr><tr><td>LMForward</td><td>5M</td><td>No</td><td>90.7</td><td>92.1</td><td>88.8</td><td>74.3</td><td>74.3</td><td>66.7</td></tr><tr><td>Skip-thought</td><td>5M</td><td>Yes</td><td>55.3</td><td>83.4</td><td>84.8</td><td>44.5</td><td>72.4</td><td>63.0</td></tr><tr><td>Skip-thought</td><td>5M</td><td>No</td><td>69.6</td><td>86.0</td><td>84.4</td><td>53.5</td><td>75.1</td><td>62.7</td></tr><tr><td>Autoencoder</td><td>5M</td><td>Yes</td><td>67.6</td><td>79.5</td><td>80.8</td><td>58.8</td><td>64.6</td><td>61.0</td></tr><tr><td>Autoencoder</td><td>5M</td><td>No</td><td>60.7</td><td>81.1</td><td>82.6</td><td>56.0</td><td>68.7</td><td>61.8</td></tr><tr><td>LM (Bidir)</td><td>15M</td><td>No</td><td>94.4</td><td>94.7</td><td>89.6</td><td>82.8</td><td>83.7</td><td>67.5</td></tr><tr><td>LMForward</td><td>15M</td><td>No</td><td>91.7</td><td>93.1</td><td>89.3</td><td>74.8</td><td>75.8</td><td>67.3</td></tr><tr><td>Skip-thought</td><td>15M</td><td>Yes</td><td>50.7</td><td>85.4</td><td>84.9</td><td>29.6</td><td>73.8</td><td>63.5</td></tr><tr><td>Skip-thought</td><td>15M</td><td>No</td><td>75.2</td><td>88.1</td><td>84.9</td><td>63.5</td><td>77.4</td><td>63.7</td></tr><tr><td>Autoencoder</td><td>15M</td><td>Yes</td><td>77.9</td><td>82.3</td><td>81.9</td><td>66.9</td><td>68.7</td><td>62.6</td></tr><tr><td>Autoencoder</td><td>15M</td><td>No</td><td>61.2</td><td>80.4</td><td>82.3</td><td>56.6</td><td>69.8</td><td>62.0</td></tr><tr><td>LM (Bidir)</td><td>63M</td><td>No</td><td>94.3</td><td>94.8</td><td>89.7</td><td>82.9</td><td>83.9</td><td>67.5</td></tr><tr><td>LMForward</td><td>63M</td><td>No</td><td>92.1</td><td>93.3</td><td>89.4</td><td>74.9</td><td>76.2</td><td>67.6</td></tr><tr><td>Skip-thought</td><td>63M</td><td>Yes</td><td>69.8</td><td>90.2</td><td>86.3</td><td>55.4</td><td>78.1</td><td>64.4</td></tr><tr><td>Skip-thought</td><td>63M</td><td>No</td><td>77.9</td><td>89.6</td><td>86.1</td><td>64.8</td><td>78.4</td><td>64.0</td></tr><tr><td>Autoencoder</td><td>63M</td><td>Yes</td><td>72.1</td><td>80.1</td><td>81.5</td><td>58.7</td><td>66.8</td><td>61.3</td></tr><tr><td>Autoencoder</td><td>63M</td><td>No</td><td>60.6</td><td>80.6</td><td>82.3</td><td>55.7</td><td>68.6</td><td>61.7</td></tr></table>",
+        "bbox": [
+            189,
+            132,
+            808,
+            564
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Table 4: Here we display results for training on $1 \\%$ of auxiliary task data. Word-conditional most frequent class baselines for this amount of training data are $8 1 . 8 \\%$ for POS tagging and $6 2 . 3 \\%$ for CCG supertagging. For each task, we underline the best performance for each training dataset size and bold the best overall performance. ",
+        "bbox": [
+            173,
+            574,
+            825,
+            631
+        ],
+        "page_idx": 13
+    }
+]