Add files using upload-large-folder tool

parse/train/B13njo1R-/B13njo1R-.md

@@ -0,0 +1,293 @@
+# PROGRESSIVE REINFORCEMENT LEARNING WITH DISTILLATION FOR MULTI-SKILLED MOTION CONTROL
+
+Glen Berseth\*, Cheng Xie\*, Paul Cernek, Michiel Van de Panne
+
+gberseth@cs.ubc.ca,cheng.k.xie@gmail.com,pcernek@cs.ubc.ca,   
+van@cs.ubc.ca   
+University of British Colubia
+
+# ABSTRACT
+
+Deep reinforcement learning has demonstrated increasing capabilities for continuous control problems, including agents that can move with skill and agility through their environment. An open problem in this setting is that of developing good strategies for integrating or merging policies for multiple skills, where each individual skill is a specialist in a specific skill and its associated state distribution. We extend policy distillation methods to the continuous action setting and leverage this technique to combine expert policies, as evaluated in the domain of simulated bipedal locomotion across different classes of terrain. We also introduce an input injection method for augmenting an existing policy network to exploit new input features. Lastly, our method uses transfer learning to assist in the efficient acquisition of new skills. The combination of these methods allows a policy to be incrementally augmented with new skills. We compare our progressive learning and integration via distillation (PLAID) method against three alternative baselines.
+
+# 1 INTRODUCTION
+
+As they gain experience, humans develop rich repertoires of motion skills that are useful in different contexts and environments. Recent advances in reinforcement learning provide an opportunity to understand how motion repertoires can best be learned, recalled, and augmented. Inspired by studies on the development and recall of movement patterns useful for different locomotion contexts (Roemmich & Bastian, 2015), we develop and evaluate an approach for learning multi-skilled movement repertoires. In what follows, we refer to the proposed method as PLAID: Progressive Learning and Integration via Distillation.
+
+For long lived applications of complex control tasks a learning system may need to acquire and integrate additional skills. Accordingly, our problem is defined by the sequential acquisition and integration of new skills. Given an existing controller that is capable of one-or-more skills, we wish to: (a) efficiently learn a new skill or movement pattern in a way that is informed by the existing control policy, and (b) to reintegrate that into a single controller that is capable of the full motion repertoire. This process can then be repeated as necessary. We view PLAID as a continual learning method, in that we consider a context where all tasks are not known in advance and we wish to learn any new task in an efficient manner. However, it is also proves surprisingly effective as a multitask solution, given the three specific benchmarks that we compare against. In the process of acquiring a new skill, we also allow for a control policy to be augmented with additional inputs, without adversely impacting its performance. This is a process we refer to as input injection.
+
+Understanding the time course of sensorimotor learning in human motor control is an open research problem (Wolpert & Flanagan, 2016) that exists concurrently with recent advances in deep reinforcement learning. Issues of generalization, context-dependent recall, transfer or ”savings” in fast learning, forgetting, and scalability are all in play for both human motor control models and the learning curricula proposed in reinforcement learning. While the development of hierarchical models for skills offers one particular solution that supports scalability and that avoids problems related to forgetting, we eschew this approach in this work and instead investigate a progressive approach to integration into a control policy defined by a single deep network.
+
+Distillation refers to the problem of combining the policies of one or more experts in order to create one single controller that can perform the tasks of a set of experts. It can be cast as a supervised regression problem where the objective is to learn a model that matches the output distributions of all expert policies (Parisotto et al., 2015; Teh et al., 2017; Rusu et al., 2015). However, given a new task for which an expert is not given, it is less clear how to learn the new task while successfully integrating this new skill in the pre-existing repertoire of the control policy for an agent. One wellknown technique in machine learning to significantly improve sample efficiency across similar tasks is to use Transfer Learning (TL) (Pan & Yang, 2010), which seeks to reuse knowledge learned from solving a previous task to efficiently learn a new task. However, transferring knowledge from previous tasks to new tasks may not be straightforward; there can be negative transfer wherein a previously-trained model can take longer to learn a new task via fine-tuning than would a randomlyinitialized model (Rajendran et al., 2015). Additionally, while learning a new skill, the control policy should not forget how to perform old skills.
+
+The core contribution of this paper is a method Progressive Learning and Integration via Distillation (PLAiD) to repeatedly expand and integrate a motion control repertoire. The main building blocks consist of policy transfer and multi-task policy distillation, and the method is evaluated in the context of a continuous motor control problem, that of robust locomotion over distinct classes of terrain. We evaluate the method against three alternative baselines. We also introduce input injection, a convenient mechanism for adding inputs to control policies in support of new skills, while preserving existing capabilities.
+
+# 2 RELATED WORK
+
+Transfer learning and distillation are of broad interest in machine learning and RL (Pan & Yang, 2010; Taylor & Stone, 2009; Teh et al., 2017). Here we outline some of the most relevant work in the area of Deep Reinforcement Learning (DRL) for continuous control environments.
+
+Distillation Recent works have explored the problem of combining multiple expert policies in the reinforcement learning setting. A popular approach uses supervised learning to combine each policy by regression over the action distribution. This approach yields model compression (Rusu et al., 2015) as well as a viable method for multi-task policy transfer (Parisotto et al., 2015) on discrete action domains including the Arcade Learning Environment (Bellemare et al., 2013). We adopt these techniques and extend them for the case of complex continuous action space tasks and make use of them as building block.
+
+Transfer Learning Transfer learning exploits the structure learned from a previous task in learning a new task. Our focus here is on transfer learning in environments consisting of continuous control tasks. The concept of appending additional network structure while keeping the previous structure to reduce catastrophic forgetting has worked well on Atari games (Rusu et al., 2015; Parisotto et al., 2015; Rusu et al., 2016; Chen et al., 2015) Other methods reproduce data from all tasks to reduce the possibility of forgetting how to perform previously learned skills e.g, (Shin et al., 2017; Li & Hoiem, 2016). Recent work seeks to mitigate this issue using selective learning rates for specific network parameters (Kirkpatrick et al., 2017). A different approach to combining policies is to use a hierarchical structure (Tessler et al., 2016). In this setting, previously-learned policies are available as options to execute for a policy trained on a new task. However, this approach assumes that the new tasks will be at least a partial composition of previous tasks, and there is no reintegration of newly learned tasks. A recent promising approach has been to apply meta-learning to achieve control policies that can quickly adapt their behaviour according to current rewards (Finn et al., 2017). This work is demonstrated on parameterized task domains. The Powerplay method provides a general framework for training an increasingly general problem solver (Schmidhuber, 2011; Srivastava et al., 2012). It is based on iteratively: inventing a new task using play or invention; solving this task; and, lastly, demonstrating the ability to solve all the previous tasks. The last two stages are broadly similar to our PLAID approach, although to the best of our knowledge, there are no experiments on motor control tasks of comparable complexity to the ones we tackle. In our work, we develop a specific progressive learning-and-distillation methodology for motor skills, and provide a detailed evaluation as compared to three other plausible baselines. We are specifically interested in understanding issues that arise from the interplay between transfer from related tasks and the forgetting that may occur.
+
+Hierarchical RL further uses modularity to achieve transfer learning for robotic tasks (Tessler et al., 2016) This allows for the substitution of network modules for different robot types over a similar tasks (Devin et al., 2017). Other methods use Hierarchical Reinforcement Learning (HRL) as a method for simplifying a complex motor control problem, defining a decomposition of the overall task into smaller tasks (Kulkarni et al., 2016; Heess et al., 2016; Peng et al., 2017) While these methods examine knowledge transfer, they do not examine the reintegration of policies for related tasks and the associated problems such as catastrophic forgetting. Recent work examines learned motions that can be shaped by prior mocap clips (Merel et al., 2017), and that these can then be integrated in a hierarchical controller.
+
+# 3 FRAMEWORK
+
+In this section we outline the details of the Reinforcement Learning (RL) framework. We also give an introduction to the concepts of $\mathrm { T L }$ and distillation.
+
+# 3.1 REINFORCEMENT LEARNING
+
+Leveraging the framework of reinforcement learning, we frame the problem as a Markov Decision Processes (MDP): at each time step $t$ , the world (including the agent) is in a state $s _ { t } \in S$ , wherein the agent is able to perform actions $a _ { t } \in A$ , sampled from a policy $\dot { \pi } ( s _ { t } , a _ { t } ) = p ( a _ { t } | s _ { t } )$ and resulting in state $s _ { t + 1 } \in S$ according to transition probabilities $T ( s _ { t } , a _ { t } , s _ { t + 1 } )$ . Performing action $a _ { t }$ from state $s _ { t }$ produces a reward $r _ { t }$ ; the expected cumulative reward earned from following some policy $\pi$ may then be written as:
+
+$$
+J ( \pi ) = \mathbb { E } _ { r _ { 0 } , \ldots , r _ { T } } \left[ \sum _ { t = 0 } ^ { T } \gamma ^ { t } r _ { t } \right]
+$$
+
+where $T$ is the time horizon, and $\gamma$ is the discount factor, defining the planning horizon length.
+
+The agent’s goal is to learn an optimal policy, $\pi ^ { * }$ , maximizing $J ( \pi )$ . If the policy has parameters $\theta _ { \pi }$ , then the goal may be reformulated to identify the optimal parameters $\theta _ { \pi } ^ { * }$ :
+
+$$
+\theta _ { \pi } ^ { * } = \arg \operatorname* { m a x } _ { \theta _ { \pi } } J ( \pi ( \cdot | \theta _ { \pi } ) )
+$$
+
+Our policy models a Gaussian distribution with a mean state dependent mean, $\mu _ { \theta _ { t } } ( s _ { t } )$ . Thus, our stochastic policy may be formulated as follows:
+
+$$
+a _ { t } \sim \pi ( a _ { t } \mid s _ { t } , \theta _ { \pi } ) = \mathcal { N } ( \mu ( s _ { t } \mid \theta _ { \mu } ) , \Sigma ) \qquad \Sigma = d i a g \{ \sigma _ { i } ^ { 2 } \}
+$$
+
+where $\Sigma$ is a diagonal covariance matrix with entries $\sigma _ { i } ^ { 2 }$ on the diagonal, similar to (Peng et al., 2017).
+
+To optimize our policy, we use stochastic policy gradient methods, which are well-established family of techniques for reinforcement learning (Sutton et al., 2000). The gradient of the expected reward with respect to the policy parameters, $\bar { \nabla _ { \theta _ { \pi } } } J ( \pi ( \cdot | \theta _ { \pi } ) )$ , is given by:
+
+$$
+\nabla _ { \theta _ { \pi } } J ( \pi ( \cdot | \theta _ { \pi } ) ) = \int _ { S } d \theta ( s ) \int _ { A } \nabla _ { \theta _ { \pi } } \log ( \pi ( a , s | \theta _ { \pi } ) ) A _ { \pi } ( s , a ) d a d s
+$$
+
+where $\begin{array} { r } { d _ { \theta } = \int _ { S } \sum _ { t = 0 } ^ { T } \gamma ^ { t } p _ { 0 } ( s _ { 0 } ) ( s _ { 0 } \to s \mid t , \pi _ { 0 } ) \ d s _ { 0 } } \end{array}$ is the discounted state distribution, $p _ { 0 } ( s )$ represents the initial state distribution, and $p _ { 0 } ( s _ { 0 } ) ( s _ { 0 } \to s \mid t , \pi _ { 0 } )$ models the likelihood of reaching
+
+state $s$ by starting at state $s _ { 0 }$ and following the policy $\pi ( a , s | \theta _ { \pi } )$ for $T$ steps (Silver et al., 2014). $A _ { \pi } ( s , a )$ represents an advantage function (Schulman et al., 2016). In this work, we use the Positive Temporal Difference (PTD) update proposed by (Van Hasselt, 2012) for $A _ { \pi } ( s , a )$ :
+
+$$
+A _ { \pi } ( s _ { t } , a _ { t } ) = I \left[ \delta _ { t } > 0 \right] = { \binom { 1 , \quad \delta _ { t } > 0 } { 0 , \quad \mathrm { o t h e r w i s e } } }
+$$
+
+$$
+\delta _ { t } = r _ { t } + \gamma V _ { \pi } ( s _ { t + 1 } ) - V _ { \pi } ( s _ { t } )
+$$
+
+where $\begin{array} { r } { V _ { \pi } ( s ) = \mathbb { E } \left[ \sum _ { t = 0 } ^ { T } \gamma ^ { t } r _ { t } \mid s _ { 0 } = s \right] } \end{array}$ is the value function, which gives the expected discounted cumulative reward from following policy $\pi$ starting in state $s$ . PTD has the benefit of being insensitive to the advantage function scale. Furthermore, limiting policy updates in this way to be only in the direction of actions that have a positive advantage has been found to increase the stability of learning (Van Hasselt, 2012). Because the true value function is unknown, an approximation $V _ { \pi } ( \cdot \mid \theta _ { v } )$ with parameters $\theta _ { v }$ is learned, which is formulated as the regression problem:
+
+$$
+\mathrm { m i n i m i z e } _ { s _ { t } , r _ { t } , s _ { t + 1 } } \mathbb { E } \left[ \frac { 1 } { 2 } \left( y _ { t } - V _ { \pi } ( s \mid \theta _ { v } ) \right) ^ { 2 } \right] , \qquad y _ { t } = r _ { t } + \gamma V _ { \pi } ( s _ { t + 1 } \mid \theta _ { v } )
+$$
+
+# 3.2 POLICY DISTILLATION
+
+Given a set of expert agents that have solved/mastered different tasks we may want to combine the skills of these different experts into a single multi-skilled agent. This process is referred to as distillation. Distillation does not necessarily produce an optimal mix of the given experts but instead tries to produce an expert that best matches the action distributions produced by all experts. This method functions independent of the reward functions used to train each expert. Distillation also scales well with respect to the number of tasks or experts that are being combined.
+
+# 3.3 TRANSFER LEARNING
+
+Given an expert that has solved/mastered a task we want to reuse that expert knowledge in order to learn a new task efficiently. This problem falls in the area of Transfer Learning (Pan & Yang, 2010). Considering the state distribution expert is skilled at solving, $D _ { \omega _ { i } }$ the source distribution) it can be advantageous to start learning a new, target task $\omega _ { i + 1 }$ with target distribution $D _ { \omega _ { i + 1 } }$ using assistance from the expert. The agent learning how to solve the target task with domain $D _ { \omega _ { i + 1 } }$ is referred to as the student. When the expert is used to assist the student in learning the target task it can be referred to as the teacher. The success of these methods are dependent on overlap between the $D _ { \omega _ { i } }$ and $D _ { \omega _ { i + 1 } }$ state distributions.
+
+# 4 PROGRESSIVE LEARNING
+
+Although we focus on the problem of being presented with tasks sequentially, there exist other methods for learning a multi-skilled character. We considered 4 overall integration methods for learning multiple skills, the first being a controller that learns multiple tasks at the same time (MultiTasker), where a number of skills are learned at the same time. It has been shown that learning many tasks together can be faster than learning each task separately (Parisotto et al., 2015). The curriculum for using this method is shown in Figure 1a were during a single RL simulation all tasks are learned together. It is also possible to randomly initialize controllers and train in parallel (Parallel) and then combine the resulting policies Figure 1b. We found that learning many skills from scratch was challenging, we were only able to get fair results for the flat task. Also, when a new task is to be learned with the Parallel model it would occur outside of the original parallel learning, leading to a more sequential method. A TL-Only method that uses TL while learning tasks in a sequence Figure 1c, possibly ending with a distillation step to combine the learned policies to decrease forgetting. For more details see Appendix: 8.4. The last version (PLAiD) learns each task sequentially using TL from the previous, most skilled policy, in the end resulting in a policy capable of solving all tasks Figure 1d. This method works well for both combining learned skills and learning new skills.
+
+![](images/76282a8dcb9c4a51633a2b51e08f18fda8a64c91c0411601f745ca180a064ad8.jpg)  
+Figure 1: Different curriculum learning process. The red box with a $D$ in it denotes a distillation step that combines policies. Each gray box denotes one iteration of learning a new policy. The larger red boxes with an $L _ { t e r r a i n - t y p e }$ denotes a learning step where a new skill is learned.
+
+# 4.1 PROGRESSIVE LEARNING AND INTEGRATION VIA DISTILLATION
+
+In this section, we detail our proposed learning framework for continual policy transfer and distillation (PLAiD). In the acquisition (TL) step, we are interested in learning a new task $\omega _ { i + 1 }$ . Here transfer can be beneficial if the task structure is somewhat similar to previous tasks $\omega _ { i }$ . We adopt the TL strategy of using an existing policy network and fine-tuning it to a new task. Since we are not concerned with retaining previous skills in this step, we can update this policy without concern for forgetting. As the agent learns it will develop more skills and the addition of every new skill can increase the probability of transferring knowledge to assist the learning of the next skill.
+
+In the integration (distillation) step, we are interested in combining all past skills $( \pi _ { 0 } , \ldots , \pi _ { i } )$ with the newly acquired skill $\pi _ { i + 1 }$ . Traditional approaches have used policy regression where data is generated by collecting trajectories of the expert policy on a task. Training the student on these trajectories does not always result in robust behaviour. This poor behaviour is caused by the student experiencing a different distribution of trajectories than the expert during evaluation. To compensate for this distribution difference, portions of the trajectories should be generated by the student. This allows the expert to suggest behaviour that will pull the state distribution of the student closer to the expert’s. This is a common problem in learning a model to reproduce a given distribution of trajectories (Ross et al., 2010; Bengio et al., 2015; Martinez et al., 2017; Lamb et al., 2016). We use a method similar to the DAGGER algorithm (Ross et al., 2010) which is useful for distilling policies (Parisotto et al., 2015). See Appendix: 8.2.1 for more details. As our RL algorithm is an actor-critic method, we also perform regression on the critic by fitting both in the same step.
+
+# 4.2 HIGH LEVEL EXPERIMENT DESIGN
+
+The results presented in this work cover a range of tasks that share a similar action space and state space. Our focus is to demonstrate continual learning between related tasks. In addition, the conceptual framework allows for extensions that would permit differing state spaces, described later in Section: 5.2.
+
+# 5 RESULTS
+
+In this experiment, our set of tasks consists of 5 different terrains that a 2D humanoid walker (pdbiped) learns to traverse. The humanoid walker is trained to navigate multiple types of terrain including flat in (Figure 6a), incline (Figure 6b), steps (Figure 6c), slopes (Figure 6d), gaps (Figure 6e) and a combination of all terrains mixed (Figure 6f) on which agents are trained. The goal in these tasks is to maintain a consistent forward velocity traversing various terrains, while also matching a motion capture clip of a natural human walking gait on flat ground, similar to (Peng & van de Panne, 2016). The pd-biped receives as input both a character and (eventually) a terrain state representation, consisting of the terrains heights of 50 equally-spaced points in front of the character. The action space is 11-dimensional, corresponding to the joints. Reasonable torque limits are applied, which helps produce more natural motions and makes the control problem more difficult. A detailed description of the experimental setup is included in Section: 8.5. The tasks are presented to the agent sequentially and the goal is to progressively learn to traverse all terrain types.
+
+We evaluate our approach against three baselines. First, we compare the above learning curriculum from learning new tasks in PLAiD with learning new tasks in Parallel. This will demonstrate that knowledge from previous tasks can be effectively transferred after distillation steps. Second, we compare to the MultiTasker to demonstrate that iterated distillation is effective for the retention of learned skills. The MultiTasker is also used as a baseline for comparing learning speed. Last, a method that performs TL between tasks and concludes with a distillation step is evaluated to illustrate the result of different TL and distillation schedules. The results of the PLAiD controller are displayed in the accompanying Video 1
+
+# 5.1 TRANSFER LEARNING
+
+First, the pd-biped is trained to produce a walking motion on flat ground (flat). In Figure 2a PLAiD is compared to the three baselines for training on incline. The TL-Only method learns fast as it is given significant information about how to perform similar skills. The Parallel method is given no prior information leading to a less skilled policy. The first MultiTasker for the incline task is initialized from a terrain injected controller that was trained to walk on flat ground. Any subsequent MultiTasker is initialized from the final MultiTasker model of the preceding task. This controller has to learn multiple tasks together, which can complicate the learning process, as simulation for each task is split across the training and the overall RL task can be challenging. This is in contrast to using PLAiD, that is also initialized with the same policy trained on flat, that will integrate skills together after each new skill is learned.
+
+In Figure 2b the MultiTasker is learning the new task (steps) with similar speed to PLAiD. However, after adding more tasks the MultiTasker is beginning to struggle in Figure 2c and starts to forget in Figure 2d, with the number of tasks it must learn at the same time. While PLAiD learns the new tasks faster and is able to integrate the new skill required to solve the task robustly. TL-Only is also able to learn the new tasks very efficiently.
+
+# 5.2 INPUT FEATURE INJECTION
+
+An appealing property of using distillation in PLAiD is that the combined policy model need not resemble that of the individual expert controllers. For example, two different experts lacking state features and trained without a local map of the terrain can be combined into a single policy that has new state features for the terrain. These new terrain features can assist the agent in the task domain in which it operates.
+
+We introduce the idea of input injection for this purpose. We augment a policy with additional input features while allowing it to retain its original functional behaviour similar to (Chen et al., 2015). This is achieved by adding additional inputs to the neural network and initializing the connecting layer weights and biases to 0. By only setting the weights and biases in the layer connecting the new features to the original network to 0, the gradient can still propagate to any lower layers which are initialized random without changing the functional behaviour. This is performed when distilling the flat and incline experts. Further details can be found in Appendix: 8.3.
+
+# 5.3 DISTILLING MULTIPLE POLICIES
+
+Training over multiple tasks at the same time may help the agent learn skills quicker, but this may not scale with respect to the number of tasks. When training the MultiTasker over two or even three tasks (Figure 3a) the method displays good results, however when learning a fourth or more tasks the method struggles, as shown in Figure 3b and 3b. Part of the reason for this struggle is when new
+
+![](images/3ad2c2c9fa06c9e089f875efc852e274d11ed29956c99132554707e1f7495ded.jpg)  
+Figure 2: Learning comparison over each of the environments. These plots show the mean and std over 5 simulations, each initialized with different random seeds. The learning for PLAiD is split into two steps, with TL (in green) going first followed by the distillation part (in yellow).
+
+<table><tr><td rowspan=1 colspan=1>Tasks</td><td rowspan=1 colspan=1>flat</td><td rowspan=1 colspan=1>incline</td><td rowspan=1 colspan=1>steps</td><td rowspan=1 colspan=1>slopes</td><td rowspan=1 colspan=1>gaps</td><td rowspan=1 colspan=1>average</td></tr><tr><td rowspan=1 colspan=1>PLAiD</td><td rowspan=1 colspan=1>0.054</td><td rowspan=1 colspan=1>0.155</td><td rowspan=1 colspan=1>0.001</td><td rowspan=1 colspan=1>0.043</td><td rowspan=1 colspan=1>-0.083</td><td rowspan=1 colspan=1>0.063</td></tr><tr><td rowspan=1 colspan=1>TL-Only</td><td rowspan=1 colspan=1>-0.065</td><td rowspan=1 colspan=1>-0.044</td><td rowspan=1 colspan=1>-0.235</td><td rowspan=1 colspan=1>-0.242</td><td rowspan=1 colspan=1>0.000</td><td rowspan=1 colspan=1>-0.147</td></tr><tr><td rowspan=1 colspan=1>TL-Only (with Distill)</td><td rowspan=1 colspan=1>0.068</td><td rowspan=1 colspan=1>0.039</td><td rowspan=1 colspan=1>-0.030</td><td rowspan=1 colspan=1>-0.062</td><td rowspan=1 colspan=1>-0.133</td><td rowspan=1 colspan=1>-0.024</td></tr><tr><td rowspan=1 colspan=1>MultiTasker</td><td rowspan=1 colspan=1>-0.001</td><td rowspan=1 colspan=1>-0.053</td><td rowspan=1 colspan=1>-0.030</td><td rowspan=1 colspan=1>0.119</td><td rowspan=1 colspan=1>0.000</td><td rowspan=1 colspan=1>0.009</td></tr></table>
+
+Table 1: These values are relative percentage changes in the average reward, where a value of 0 is no forgetting and a value of $- 1$ corresponds to completely forgetting how to perform the task. A value $> 0$ corresponds to the agent learning how to better perform a task after training on other tasks. Here, the final policy after training on gaps compared to the original polices produced at the end of training for the task noted in the column heading. The TL-Only baseline forgets more than PLAiD. The MultiTasker forgets less than PLAiD but has a lower average reward over the tasks.
+
+tasks are added the MultiTasker has to make trade-offs between more tasks to maximizes. As more tasks are added, this trade-off becomes increasingly complex resulting in the MultiTasker favouring easier tasks. Using PLAiD to combine the skills of many policies appears to scale better with respect to the number of skills being integrated. This is likely because distillation is a semi-supervised method which is more stable than the un-supervised RL solution. This can be seen in Figure 3d, 3e and especially in 3f where PLAiD combines the skills faster and can find higher value policies in practice. PLAiD also presents zero-shot training on tasks which it has never been trained on. In Figure 7 this generalization is shown as the agent navigates across the mixed environment.
+
+This is also reflected in Table 1, that shows the final average reward when comparing methods before and after distillation. The TL-Only is able to achieve high performance but much is lost when learning new tasks. A final distillation step helps mitigate this issue but does not work as well as PLAiD. It is possible performing a large final distillation step can lead to over-fitting.
+
+There are some indications that distillation is hindering training during the initial few iterations. We are initializing the network used in distillation with the most recently learning policy after TL. The large change in the initial state distribution from the previous seen distribution during TL could be causing larger gradients to appear, disrupting some of the structure learned during the TL step, shown in Figure 3d and 3e. There also might not exist a smooth transition in policy space between the newly learned policy and the previous policy distribution.
+
+![](images/d210c17dc800c8ec77184c7bfac03028cd6fc46014c8e1889265f74a53c2bb2d.jpg)  
+Figure 3: These figures show the average reward a particular policy achieves over a number of tasks.
+
+# 6 DISCUSSION
+
+MultiTasker vs PLAiD: The MultiTasker may be able to produce a policy that has higher overall average reward, but in practise constraints can keep the method from combining skills gracefully. If the reward functions are different between tasks, the MultiTasker can favour a task with higher rewards, as these tasks may receive higher advantage. It is also a non-trivial task to normalize the reward functions for each task in order to combine them. The MultiTasker may also favour tasks that are easier than other tasks in general. We have shown that the PLAiD scales better with respect to the number of tasks than the MultiTasker. We expect PLAiD would further outperform the MultiTasker if the tasks were more difficult and the reward functions dissimilar.
+
+In our evaluation we compare the number of iterations PLAiD uses to the number the MultiTasker uses on only the new task, which is not necessarily fair. The MultiTasker gains its benefits from training on the other tasks together. If the idea is to reduce the number of simulation samples that are needed to learn new tasks then the MultiTasker would fall far behind. Distillation is also very efficient with respect to the number of simulation steps needed. Data could be collected from the simulator in groups and learned from in many batches before more data is needed as is common for behavioural cloning. We expect another reason distillation benefits learning multiple tasks is that the integration process assists in pulling policies out of the local minima RL is prone to.
+
+Transfer Learning: Because we are using an actor-critic learning method, we also studied the possibility of using the value functions for TL. We did not discover any empirical evidence that this assisted the learning process. When transferring to a new task, the state distribution has changed and the reward function may be completely different. This makes it unlikely that the value function will be accurate on this new task. In addition, value functions are in general easier and faster to learn than policies, implying that value function reuse is less important to transfer. We also find that helpfulness of TL depends on not only the task difficulty but the reward function as well. Two tasks may overlap in state space but the area they overlap could be easily reachable. In this case TL may not give significant benefit because the overall RL problem is easy. The greatest benefit is gained from TL when the state space that overlaps for two tasks is difficult to reach and in that difficult to reach area is where the highest rewards are achieved.
+
+# 6.1 LIMITATIONS:
+
+Once integrated, the skills for our locomotion tasks are self-selecting based on their context, i.e., the knowledge of the upcoming terrain. It may be that other augmentation and distillation strategies are better for situations where either the reward functions are different or a one-hot vector is used to select the currently active expert. In our transfer learning results we could be over fitting the initial expert for the particular task it was learning. Making it more challenging for the policy to learn a new task, resulting in negative transfer. After learning many new tasks the previous tasks may not receive a large enough potion of the distillation training process to preserve the experts skill well enough. How best to chose which data should be trained on next to best preserve the behaviour of experts is a general problem with multi-task learning. Distillation treats all tasks equally independent of their reward. This can result in very low value tasks, receiving potentially more distribution than desired and high value tasks receiving not enough. We have not needed the use a one-hot vector to indicate what task the agent is performing. We want the agent to be able to recognize which task it is given but we do realize that some tasks could be too similar to differentiate, such as, walking vs jogging on flat ground.
+
+# 6.2 FUTURE WORK:
+
+It would be interesting to develop a method to prioritize tasks during the distillation step. This could assist the agent with forgetting issues or help with relearning tasks. While we currently use the Mean Squared Error (MSE) to pull the distributions of student policies in line with expert polices for distillation, better distance metrics would likely be helpful. Previous methods have used KL Divergence in the discrete action space domain where the state-action value function encodes the policy, e.g., as with Deep Q-Network (DQN). In this work we do not focus on producing the best policy from a mixture of experts, but instead we match the distributions from a number of experts. The difference is subtle but in practice it can be more challengine to balance many experts with respect to their reward functions. It could also be beneficial to use a KL penalty while performing distillation, i.e., something similar to the work in (Teh et al., 2017) in order to keep the policy from changing too rapidly during training.
+
+# 7 CONCLUSION
+
+We have proposed and evaluated a method for the progressive learning and integration (via distillation) of motion skills. The method exploits transfer learning to speed learning of new skills, along with input injection where needed, as well as continuous-action distillation, using DAGGER-style learning. This compares favorably to baselines consisting of learning all skills together, or learning all the skills individually before integration. We believe that there remains much to learned about the best training and integration methods for movement skill repertoires, as is also reflected in the human motor learning literature.
+
+# REFERENCES
+
+Marc G Bellemare, Yavar Naddaf, Joel Veness, and Michael Bowling. The arcade learning environment: An evaluation platform for general agents. J. Artif. Intell. Res.(JAIR), 47:253–279, 2013.
+
+Samy Bengio, Oriol Vinyals, Navdeep Jaitly, and Noam Shazeer. Scheduled sampling for sequence prediction with recurrent neural networks. In C. Cortes, N. D. Lawrence, D. D. Lee, M. Sugiyama, and R. Garnett (eds.), Advances in Neural Information Processing Systems 28, pp. 1171–1179. Curran Associates, Inc., 2015. URL http://papers.nips.cc/paper/ 5956-scheduled-sampling-for-sequence-prediction-with-recurrent-neural-networks.pdf.
+
+Tianqi Chen, Ian Goodfellow, and Jonathon Shlens. Net2net: Accelerating learning via knowledge transfer. arXiv preprint arXiv:1511.05641, 2015.
+
+Coline Devin, Abhishek Gupta, Trevor Darrell, Pieter Abbeel, and Sergey Levine. Learning modular neural network policies for multi-task and multi-robot transfer. In Robotics and Automation (ICRA), 2017 IEEE International Conference on, pp. 2169–2176. IEEE, 2017.
+
+Chelsea Finn, Pieter Abbeel, and Sergey Levine. Model-agnostic meta-learning for fast adaptation of deep networks. arXiv preprint arXiv:1703.03400, 2017.
+
+Nicolas Heess, Gregory Wayne, Yuval Tassa, Timothy P. Lillicrap, Martin A. Riedmiller, and David Silver. Learning and transfer of modulated locomotor controllers. CoRR, abs/1610.05182, 2016. URL http://arxiv.org/abs/1610.05182.
+
+James Kirkpatrick, Razvan Pascanu, Neil Rabinowitz, Joel Veness, Guillaume Desjardins, Andrei A. Rusu, Kieran Milan, John Quan, Tiago Ramalho, Agnieszka Grabska-Barwinska, Demis Hassabis, Claudia Clopath, Dharshan Kumaran, and Raia Hadsell. Overcoming catastrophic forgetting in neural networks. Proceedings of the National Academy of Sciences, 114(13):3521–3526, 2017. doi: 10.1073/pnas.1611835114. URL http://www.pnas.org/content/114/13/3521.abstract.
+
+Tejas D Kulkarni, Karthik Narasimhan, Ardavan Saeedi, and Josh Tenenbaum. Hierarchical deep reinforcement learning: Integrating temporal abstraction and intrinsic motivation. In Advances in Neural Information Processing Systems 29, pp. 3675–3683. 2016.
+
+Alex M Lamb, Anirudh Goyal ALIAS PARTH GOYAL, Ying Zhang, Saizheng Zhang, Aaron C Courville, and Yoshua Bengio. Professor forcing: A new algorithm for training recurrent networks. In D. D. Lee, M. Sugiyama, U. V. Luxburg, I. Guyon, and R. Garnett (eds.), Advances in Neural Information Processing Systems 29, pp. 4601–4609. Curran Associates, Inc., 2016. URL http://papers.nips.cc/paper/ 6099-professor-forcing-a-new-algorithm-for-training-recurrent-networks.pdf.
+
+Zhizhong Li and Derek Hoiem. Learning without forgetting. CoRR, abs/1606.09282, 2016. URL http://arxiv.org/abs/1606.09282.
+
+Julieta Martinez, Michael J. Black, and Javier Romero. On human motion prediction using recurrent neural networks. CoRR, abs/1705.02445, 2017. URL http://arxiv.org/abs/1705.02445.
+
+Josh Merel, Yuval Tassa, Sriram Srinivasan, Jay Lemmon, Ziyu Wang, Greg Wayne, and Nicolas Heess. Learning human behaviors from motion capture by adversarial imitation. arXiv preprint arXiv:1707.02201, 2017.
+
+S. J. Pan and Q. Yang. A survey on transfer learning. IEEE Transactions on Knowledge and Data Engineering, 22(10):1345–1359, Oct 2010. ISSN 1041-4347. doi: 10.1109/TKDE.2009.191.
+
+Emilio Parisotto, Jimmy Lei Ba, and Ruslan Salakhutdinov. Actor-mimic: Deep multitask and transfer reinforcement learning. arXiv preprint arXiv:1511.06342, 2015.
+
+Xue Bin Peng and Michiel van de Panne. Learning locomotion skills using deeprl: Does the choice of action space matter? CoRR, abs/1611.01055, 2016. URL http://arxiv.org/abs/1611.01055.
+
+Xue Bin Peng, Glen Berseth, Kangkang Yin, and Michiel Van De Panne. Deeploco: Dynamic locomotion skills using hierarchical deep reinforcement learning. ACM Transactions on Graphics (TOG), 36(4):41, 2017.
+
+J. Rajendran, A. S. Lakshminarayanan, M. M. Khapra, P Prasanna, and B. Ravindran. Attend, adapt and transfer: Attentive deep architecture for adaptive transfer from multiple sources in the same domain. arXiv preprint arXiv:1510.02879, October 2015.
+
+Ryan T Roemmich and Amy J Bastian. Two ways to save a newly learned motor pattern. Journal of neurophysiology, 113(10):3519–3530, 2015.
+
+Stephane Ross, Geoffrey J. Gordon, and J. Andrew Bagnell. No-regret reductions for imitation ´ learning and structured prediction. CoRR, abs/1011.0686, 2010. URL http://arxiv.org/abs/1011. 0686.
+
+Andrei A Rusu, Sergio Gomez Colmenarejo, Caglar Gulcehre, Guillaume Desjardins, James Kirkpatrick, Razvan Pascanu, Volodymyr Mnih, Koray Kavukcuoglu, and Raia Hadsell. Policy distillation. arXiv preprint arXiv:1511.06295, 2015.
+
+Andrei A. Rusu, Neil C. Rabinowitz, Guillaume Desjardins, Hubert Soyer, James Kirkpatrick, Koray Kavukcuoglu, Razvan Pascanu, and Raia Hadsell. Progressive Neural Networks. arXiv, 2016. URL http://arxiv.org/abs/1606.04671.
+
+Jurgen Schmidhuber. POWERPLAY: training an increasingly general problem solver by continually ¨ searching for the simplest still unsolvable problem. CoRR, abs/1112.5309, 2011. URL http: //arxiv.org/abs/1112.5309.
+
+John Schulman, Philipp Moritz, Sergey Levine, Michael Jordan, and Pieter Abbeel. Highdimensional continuous control using generalized advantage estimation. In International Conference on Learning Representations (ICLR 2016), 2016.
+
+Hanul Shin, Jung Kwon Lee, Jaehong Kim, and Jiwon Kim. Continual learning with deep generative replay. arXiv preprint arXiv:1705.08690, 2017.
+
+David Silver, Guy Lever, Nicolas Heess, Thomas Degris, Daan Wierstra, and Martin Riedmiller. Deterministic policy gradient algorithms. In ICML, 2014.
+
+Rupesh Kumar Srivastava, Bas R. Steunebrink, and Jurgen Schmidhuber. First experiments with ¨ powerplay. CoRR, abs/1210.8385, 2012. URL http://arxiv.org/abs/1210.8385.
+
+Richard S Sutton, David A McAllester, Satinder P Singh, and Yishay Mansour. Policy gradient methods for reinforcement learning with function approximation. In Advances in neural information processing systems, pp. 1057–1063, 2000.
+
+Matthew E Taylor and Peter Stone. Transfer learning for reinforcement learning domains: A survey. Journal of Machine Learning Research, 10(Jul):1633–1685, 2009.
+
+Yee Whye Teh, Victor Bapst, Wojciech Marian Czarnecki, John Quan, James Kirkpatrick, Raia Hadsell, Nicolas Heess, and Razvan Pascanu. Distral: Robust multitask reinforcement learning. arXiv preprint arXiv:1707.04175, 2017.
+
+Chen Tessler, Shahar Givony, Tom Zahavy, Daniel J Mankowitz, and Shie Mannor. A Deep Hierarchical Approach to Lifelong Learning in Minecraft. arXiv, pp. 1–6, 2016. URL http: //arxiv.org/abs/1604.07255.
+
+Hado Van Hasselt. Reinforcement learning in continuous state and action spaces. In Reinforcement Learning, pp. 207–251. Springer, 2012.
+
+Daniel M Wolpert and J Randall Flanagan. Computations underlying sensorimotor learning. Current opinion in neurobiology, 37:7–11, 2016.
+
+# 8 APPENDIX
+
+# 8.1 NETWORK MODELS
+
+We used two different Network models for the experiments in this paper. The first model is a blind model that does not have any terrain features. The blind policy is a Neural Network with 2 hidden layers $( 5 1 2 \times 2 5 6 )$ with ReLU activations. The output layer of the policy network has linear activations. The network used for the value function has the same design except there is 1 output on the final layer. This design is used for the flat and incline tasks.
+
+We augment the blind network design by adding features for terrain to create an agent with sight. This network with terrain features has a single convolution layer with 8 filters of width 3. This constitutional layer is followed by a dense layer of 32 units. The dense layer is then concatenated twice, once along each of the original two hidden layers in the blind version of the policy.
+
+# 8.2 HYPER PARAMETERS AND TRAINING
+
+The policy network models a Gaussian distribution by outputting a state dependant mean. We use a state independent standard deviation that normalized with respect to the action space and multiplied by 0.1. We also use a version of epsilon greedy exploration where with $\epsilon$ probability an exploration action is generated. For all of our experiments we linearly anneal $\epsilon$ from 0.2 to 0.1 in 100, 000 iterations and leave it from that point on. Each training simulation takes approximately 5 hours across 8 threads. For network training we use Stochastic Gradient Decent (SGD) with momentum. During the distillation step we use gradually anneal the probability of selecting an expert action from 1 to 0 over 10, 000 iterations.
+
+For the evaluation of each model on a particular task we use the average reward achieved by the agent over at most 100 seconds of simulation time. We average this over running the agent over a number of randomly generated simulation runs.
+
+# 8.2.1 DISTILLATION
+
+For each of the distillation steps we initialize the policy from the most recently trained policy. This policy has seen all of the tasks thus far but may have overfit the most recent tasks. We us a version of the DAGGER algorithm for the distillation process (Ross et al., 2010). We anneal from selecting actions from the expert polices to selecting actions from the student policy The probability of selecting an action from the expert is annealed to near zero after $1 0 , 0 0 0$ training updates. We still add exploration noise to the policies when generating actions to take in the simulation. This is also annealed along with the probability of selecting from the expert policy. The actions used for training always come from the expert policy. Although some actions are applied in the simulation from the student, during a training update those actions will be replaced with ones from the proper expert. The expert used to generate actions for tasks $0 - i$ is $\pi _ { i }$ and the expert used to generate action for task $i + 1$ is $\pi _ { i + 1 }$ . We keep around at most 2 policies at any time.
+
+# 8.3 INPUT FEATURES AND INJECTION
+
+In order to add additional input features to the policy network we construct a new network. This new network has a portion of it that is the same design as the previous network plus additional parameters. First we initialize the new network with random parameters. Then we copy over the values from the previous network into the new one for the portion of the network design that matches the old. Then the weight for the layers that connect the old portion of the network to the new are set to 0. This will allow the network to preserve the previous distribution it modeled. Having the parameters from the old network will also help generate gradients to train the new 0 valued network parameters. We use feature injection to assist the learning method with differentiating between different states. For example, it could be challenging to discover the difference between the flat and incline tasks using only the character features. Therefore, we add new terrain features to allow the controller to better differentiate between these two different tasks.
+
+# 8.4 TL-ONLY BASELINE
+
+We also evaluate a baseline where we TL for all tasks. In this baseline TL is performed for a number of tasks and then distillation is used to combined these many learned skills. This method can be considered a version of PLAiD where tasks are learned in groups and after some number of tasks, a collection of policies/skills are distilled together. In Figure 5 the learning curves for the TL-Only baseline are given. The TL-Only method learns new tasks well. We do not show the incline tasks as the two methods are the same up to starting the steps tasks. In Table 1 the amount of forgetting is compared between methods. To compare the amount of forgetting between TL-Only and PLAiD we show the relative loss in average reward between the original policy trained for the tasks steps and slopes and the final polices for each method on gaps. The TL-Only method shows a larger drop in
+
+![](images/9c660ef62d2a56de4a641b330d126aac0a2ac2b9dd9cfeefdfa332b4964a851b.jpg)  
+Figure 4: (a) The input features include both the character state shown as the red lines between the root of the character and the character’s links and the terrain features shown as the blue arrows along the ground. (b) A diagram of method used to inject additional state features for the terrain.
+
+<table><tr><td rowspan=1 colspan=1>Tasks</td><td rowspan=1 colspan=1>flat</td><td rowspan=1 colspan=1>incline</td><td rowspan=1 colspan=1>steps</td><td rowspan=1 colspan=1>slopes</td><td rowspan=1 colspan=1>gaps</td><td rowspan=1 colspan=1>average</td></tr><tr><td rowspan=1 colspan=1>PLAiD</td><td rowspan=1 colspan=1>0.891</td><td rowspan=1 colspan=1>0.800</td><td rowspan=1 colspan=1>0.666</td><td rowspan=1 colspan=1>0.602</td><td rowspan=1 colspan=1>0.529</td><td rowspan=1 colspan=1>0.698</td></tr><tr><td rowspan=1 colspan=1>TL-Only</td><td rowspan=1 colspan=1>0.790</td><td rowspan=1 colspan=1>0.662</td><td rowspan=1 colspan=1>0.615</td><td rowspan=1 colspan=1>0.543</td><td rowspan=1 colspan=1>0.626</td><td rowspan=1 colspan=1>0.647</td></tr><tr><td rowspan=1 colspan=1>TL-Only (with Distill)</td><td rowspan=1 colspan=1>0.903</td><td rowspan=1 colspan=1>0.719</td><td rowspan=1 colspan=1>0.781</td><td rowspan=1 colspan=1>0.671</td><td rowspan=1 colspan=1>0.543</td><td rowspan=1 colspan=1>0.723</td></tr><tr><td rowspan=1 colspan=1>MultiTasker</td><td rowspan=1 colspan=1>0.844</td><td rowspan=1 colspan=1>0.757</td><td rowspan=1 colspan=1>0.677</td><td rowspan=1 colspan=1>0.656</td><td rowspan=1 colspan=1>0.504</td><td rowspan=1 colspan=1>0.688</td></tr></table>
+
+Table 2: Final average reward for each method. Higher is better. Here, the final policy is after training on gaps. the PLAiD method achieves on average higher values across tasks.
+
+policy performance corresponding to a large amount of forgeting compared to PLAiD, in particular for the more complex tasks steps and slopes. Interestingly, the final distllation step for TL-Only appears to reduce the performance of the policy. We believe this is related to the final distillation step being more challenging than performing a simpler distillation after each new task. Note that we only compare these two steps because the process for the first two tasks for PLAiD and TL-Only are the same. A comparison of the average rewards for the final policies are given in Table 2.
+
+![](images/1ed68d2dc9fafb1d593037526d0a41547396f861268e7b1e1d7bfc3b03a7250f.jpg)  
+Figure 5: Transfer learning only baselines for each of the new tasks.
+
+# 8.5 AGENT DESIGN
+
+The agent used in the simulation models the dimensions and masses of the average adult. The size of the character state is 50 parameters that include the relative position and velocity of the links in the agent (Figure 4a). The action space consists of 11 parameters that indicate target joint positions for the agent. The target joint positions (pd-targets) are turned into joint torques via proportional derivative controllers at each joint.
+
+The reward function for the agent consists of 3 primary terms. The first is a velocity term the rewards the agent for going at velocity of $1 ~ \mathrm { m / s }$ The second term is the difference between the pose of the agent and the current pose of a kinematic character controlled via a motion capture clip. The difference between the agent and the clip consists of the rotational difference between each corresponding joint and the difference in angular velocity. The angular velocity for the clip is approximated via finite differences between the current pose of the clip and it’s last pose. The last term is an L2 penalty on the torques generated by the agent to help reduce spastic motions. We also impose torque limits on the joints to reduce unrealistic behaviour, limits: Hips 150, knees 125, ankles 100, shoulders 100, elbows 75 and neck $5 0 \mathrm { { N / m } }$ .
+
+Terrain Types All terrain types are randomly generated per episode, except for the flat terrain. The incline terrain is slanted and the slant of the terrain is randomly sampled between 20 and 25 degrees. The steps terrain consists of flat segments with widths randomly sampled from $1 . 0 \mathrm { ~ m ~ }$ to $1 . 5 \textrm { m }$ followed by sharp steps that have randomly generated heights between $5 \mathrm { \ c m }$ and $1 5 ~ \mathrm { c m }$ . The slopes terrain is randomly generated by updating the slope of the previous point in the ground with a value sampled from $- 2 0$ and 20 degrees to generate a new portion of the ground every $1 0 ~ \mathrm { c m }$ . The gaps terrain generate gaps of width $2 5 \textrm { - } 3 0 \ \mathrm { c m }$ separated by flat segments of widths sampled from $2 . 0 \textrm { m }$ to $2 . 5 \textrm { m }$ . The mixed terrain is a combination of the above terrains where a portion is randomly chosen from the above terrain types.
+
+![](images/220ff1dfc480f93ba710e4bf63078533ec173fdf104585fc9c94acd963d2ed0d.jpg)  
+Figure 6: The environments used to evaluate PLAiD.
+
+![](images/4f2d76308c96b5e55985187fa1f526683327dd8e0f93fd24854330bb283e5f5c.jpg)  
+Figure 7: Still frame shots of the pd-biped traversing the mixed environment.
+
+# 8.6 MULTITASKER
+
+In certain cases the MultiTasker can learn new task faster than PLAiD. In Figure 8a we present the MultiTasker and compare it to PLAiD. In this case the MultiTasker splits its training time across multiple tasks, here we compare the two methods with respect to the time spent learning on the single new task. This is a good baseline to compare our method against but in some ways this is not fair. If the real measure of how efficient a learning method is the number of simulation samples that are needed to learn would fall far behind as the MultiTasker needs to train across all tasks to gain the benefits of improving a single task without forgetting the old tasks.
+
+![](images/6104bfa844eaee20828e3951320d95bb6db5ef54eb255e2b4df87ee596371125.jpg)  
+Figure 8: (a) Shows that the MultiTasker can learn faster on steps, flat and incline than PLAiD (expert) learning the single task steps with TL.

parse/train/B13njo1R-/B13njo1R-_content_list.json

@@ -0,0 +1,1622 @@
+[
+    {
+        "type": "text",
+        "text": "PROGRESSIVE REINFORCEMENT LEARNING WITH DISTILLATION FOR MULTI-SKILLED MOTION CONTROL ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            699,
+            171
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Glen Berseth\\*, Cheng Xie\\*, Paul Cernek, Michiel Van de Panne ",
+        "bbox": [
+            187,
+            194,
+            633,
+            209
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "gberseth@cs.ubc.ca,cheng.k.xie@gmail.com,pcernek@cs.ubc.ca,   \nvan@cs.ubc.ca   \nUniversity of British Colubia ",
+        "bbox": [
+            181,
+            210,
+            759,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            287,
+            544,
+            303
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep reinforcement learning has demonstrated increasing capabilities for continuous control problems, including agents that can move with skill and agility through their environment. An open problem in this setting is that of developing good strategies for integrating or merging policies for multiple skills, where each individual skill is a specialist in a specific skill and its associated state distribution. We extend policy distillation methods to the continuous action setting and leverage this technique to combine expert policies, as evaluated in the domain of simulated bipedal locomotion across different classes of terrain. We also introduce an input injection method for augmenting an existing policy network to exploit new input features. Lastly, our method uses transfer learning to assist in the efficient acquisition of new skills. The combination of these methods allows a policy to be incrementally augmented with new skills. We compare our progressive learning and integration via distillation (PLAID) method against three alternative baselines. ",
+        "bbox": [
+            233,
+            319,
+            764,
+            512
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            565,
+            336,
+            580
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "As they gain experience, humans develop rich repertoires of motion skills that are useful in different contexts and environments. Recent advances in reinforcement learning provide an opportunity to understand how motion repertoires can best be learned, recalled, and augmented. Inspired by studies on the development and recall of movement patterns useful for different locomotion contexts (Roemmich & Bastian, 2015), we develop and evaluate an approach for learning multi-skilled movement repertoires. In what follows, we refer to the proposed method as PLAID: Progressive Learning and Integration via Distillation. ",
+        "bbox": [
+            174,
+            595,
+            823,
+            693
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "For long lived applications of complex control tasks a learning system may need to acquire and integrate additional skills. Accordingly, our problem is defined by the sequential acquisition and integration of new skills. Given an existing controller that is capable of one-or-more skills, we wish to: (a) efficiently learn a new skill or movement pattern in a way that is informed by the existing control policy, and (b) to reintegrate that into a single controller that is capable of the full motion repertoire. This process can then be repeated as necessary. We view PLAID as a continual learning method, in that we consider a context where all tasks are not known in advance and we wish to learn any new task in an efficient manner. However, it is also proves surprisingly effective as a multitask solution, given the three specific benchmarks that we compare against. In the process of acquiring a new skill, we also allow for a control policy to be augmented with additional inputs, without adversely impacting its performance. This is a process we refer to as input injection. ",
+        "bbox": [
+            174,
+            700,
+            825,
+            853
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Understanding the time course of sensorimotor learning in human motor control is an open research problem (Wolpert & Flanagan, 2016) that exists concurrently with recent advances in deep reinforcement learning. Issues of generalization, context-dependent recall, transfer or ”savings” in fast learning, forgetting, and scalability are all in play for both human motor control models and the learning curricula proposed in reinforcement learning. While the development of hierarchical models for skills offers one particular solution that supports scalability and that avoids problems related to forgetting, we eschew this approach in this work and instead investigate a progressive approach to integration into a control policy defined by a single deep network. ",
+        "bbox": [
+            176,
+            859,
+            823,
+            902
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            174
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Distillation refers to the problem of combining the policies of one or more experts in order to create one single controller that can perform the tasks of a set of experts. It can be cast as a supervised regression problem where the objective is to learn a model that matches the output distributions of all expert policies (Parisotto et al., 2015; Teh et al., 2017; Rusu et al., 2015). However, given a new task for which an expert is not given, it is less clear how to learn the new task while successfully integrating this new skill in the pre-existing repertoire of the control policy for an agent. One wellknown technique in machine learning to significantly improve sample efficiency across similar tasks is to use Transfer Learning (TL) (Pan & Yang, 2010), which seeks to reuse knowledge learned from solving a previous task to efficiently learn a new task. However, transferring knowledge from previous tasks to new tasks may not be straightforward; there can be negative transfer wherein a previously-trained model can take longer to learn a new task via fine-tuning than would a randomlyinitialized model (Rajendran et al., 2015). Additionally, while learning a new skill, the control policy should not forget how to perform old skills. ",
+        "bbox": [
+            174,
+            180,
+            825,
+            361
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The core contribution of this paper is a method Progressive Learning and Integration via Distillation (PLAiD) to repeatedly expand and integrate a motion control repertoire. The main building blocks consist of policy transfer and multi-task policy distillation, and the method is evaluated in the context of a continuous motor control problem, that of robust locomotion over distinct classes of terrain. We evaluate the method against three alternative baselines. We also introduce input injection, a convenient mechanism for adding inputs to control policies in support of new skills, while preserving existing capabilities. ",
+        "bbox": [
+            174,
+            367,
+            825,
+            465
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            484,
+            344,
+            501
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Transfer learning and distillation are of broad interest in machine learning and RL (Pan & Yang, 2010; Taylor & Stone, 2009; Teh et al., 2017). Here we outline some of the most relevant work in the area of Deep Reinforcement Learning (DRL) for continuous control environments. ",
+        "bbox": [
+            176,
+            517,
+            823,
+            559
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Distillation Recent works have explored the problem of combining multiple expert policies in the reinforcement learning setting. A popular approach uses supervised learning to combine each policy by regression over the action distribution. This approach yields model compression (Rusu et al., 2015) as well as a viable method for multi-task policy transfer (Parisotto et al., 2015) on discrete action domains including the Arcade Learning Environment (Bellemare et al., 2013). We adopt these techniques and extend them for the case of complex continuous action space tasks and make use of them as building block. ",
+        "bbox": [
+            174,
+            575,
+            825,
+            672
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Transfer Learning Transfer learning exploits the structure learned from a previous task in learning a new task. Our focus here is on transfer learning in environments consisting of continuous control tasks. The concept of appending additional network structure while keeping the previous structure to reduce catastrophic forgetting has worked well on Atari games (Rusu et al., 2015; Parisotto et al., 2015; Rusu et al., 2016; Chen et al., 2015) Other methods reproduce data from all tasks to reduce the possibility of forgetting how to perform previously learned skills e.g, (Shin et al., 2017; Li & Hoiem, 2016). Recent work seeks to mitigate this issue using selective learning rates for specific network parameters (Kirkpatrick et al., 2017). A different approach to combining policies is to use a hierarchical structure (Tessler et al., 2016). In this setting, previously-learned policies are available as options to execute for a policy trained on a new task. However, this approach assumes that the new tasks will be at least a partial composition of previous tasks, and there is no reintegration of newly learned tasks. A recent promising approach has been to apply meta-learning to achieve control policies that can quickly adapt their behaviour according to current rewards (Finn et al., 2017). This work is demonstrated on parameterized task domains. The Powerplay method provides a general framework for training an increasingly general problem solver (Schmidhuber, 2011; Srivastava et al., 2012). It is based on iteratively: inventing a new task using play or invention; solving this task; and, lastly, demonstrating the ability to solve all the previous tasks. The last two stages are broadly similar to our PLAID approach, although to the best of our knowledge, there are no experiments on motor control tasks of comparable complexity to the ones we tackle. In our work, we develop a specific progressive learning-and-distillation methodology for motor skills, and provide a detailed evaluation as compared to three other plausible baselines. We are specifically interested in understanding issues that arise from the interplay between transfer from related tasks and the forgetting that may occur. ",
+        "bbox": [
+            174,
+            688,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            188
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Hierarchical RL further uses modularity to achieve transfer learning for robotic tasks (Tessler et al., 2016) This allows for the substitution of network modules for different robot types over a similar tasks (Devin et al., 2017). Other methods use Hierarchical Reinforcement Learning (HRL) as a method for simplifying a complex motor control problem, defining a decomposition of the overall task into smaller tasks (Kulkarni et al., 2016; Heess et al., 2016; Peng et al., 2017) While these methods examine knowledge transfer, they do not examine the reintegration of policies for related tasks and the associated problems such as catastrophic forgetting. Recent work examines learned motions that can be shaped by prior mocap clips (Merel et al., 2017), and that these can then be integrated in a hierarchical controller. ",
+        "bbox": [
+            174,
+            202,
+            825,
+            328
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 FRAMEWORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            347,
+            318,
+            363
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section we outline the details of the Reinforcement Learning (RL) framework. We also give an introduction to the concepts of $\\mathrm { T L }$ and distillation. ",
+        "bbox": [
+            174,
+            377,
+            823,
+            407
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 REINFORCEMENT LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            422,
+            415,
+            438
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Leveraging the framework of reinforcement learning, we frame the problem as a Markov Decision Processes (MDP): at each time step $t$ , the world (including the agent) is in a state $s _ { t } \\in S$ , wherein the agent is able to perform actions $a _ { t } \\in A$ , sampled from a policy $\\dot { \\pi } ( s _ { t } , a _ { t } ) = p ( a _ { t } | s _ { t } )$ and resulting in state $s _ { t + 1 } \\in S$ according to transition probabilities $T ( s _ { t } , a _ { t } , s _ { t + 1 } )$ . Performing action $a _ { t }$ from state $s _ { t }$ produces a reward $r _ { t }$ ; the expected cumulative reward earned from following some policy $\\pi$ may then be written as: ",
+        "bbox": [
+            173,
+            448,
+            825,
+            532
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/838d032b21a29ce027cac3c8bb067babd56666104667c67a6b7691335938c4cb.jpg",
+        "text": "$$\nJ ( \\pi ) = \\mathbb { E } _ { r _ { 0 } , \\ldots , r _ { T } } \\left[ \\sum _ { t = 0 } ^ { T } \\gamma ^ { t } r _ { t } \\right]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            401,
+            531,
+            596,
+            575
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $T$ is the time horizon, and $\\gamma$ is the discount factor, defining the planning horizon length. ",
+        "bbox": [
+            173,
+            582,
+            792,
+            597
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The agent’s goal is to learn an optimal policy, $\\pi ^ { * }$ , maximizing $J ( \\pi )$ . If the policy has parameters $\\theta _ { \\pi }$ , then the goal may be reformulated to identify the optimal parameters $\\theta _ { \\pi } ^ { * }$ : ",
+        "bbox": [
+            171,
+            603,
+            823,
+            633
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/da857d01bded569abc8a69e7a10203504c7d28f92af5e75e15b9e22c16d78726.jpg",
+        "text": "$$\n\\theta _ { \\pi } ^ { * } = \\arg \\operatorname* { m a x } _ { \\theta _ { \\pi } } J ( \\pi ( \\cdot | \\theta _ { \\pi } ) )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            411,
+            651,
+            584,
+            678
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our policy models a Gaussian distribution with a mean state dependent mean, $\\mu _ { \\theta _ { t } } ( s _ { t } )$ . Thus, our stochastic policy may be formulated as follows: ",
+        "bbox": [
+            173,
+            688,
+            826,
+            717
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/672c2035593d556f6738b99f58583afe097aa5a56a8120d886949709dae9f432.jpg",
+        "text": "$$\na _ { t } \\sim \\pi ( a _ { t } \\mid s _ { t } , \\theta _ { \\pi } ) = \\mathcal { N } ( \\mu ( s _ { t } \\mid \\theta _ { \\mu } ) , \\Sigma ) \\qquad \\Sigma = d i a g \\{ \\sigma _ { i } ^ { 2 } \\}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            303,
+            734,
+            694,
+            753
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\Sigma$ is a diagonal covariance matrix with entries $\\sigma _ { i } ^ { 2 }$ on the diagonal, similar to (Peng et al., 2017). ",
+        "bbox": [
+            173,
+            755,
+            821,
+            784
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To optimize our policy, we use stochastic policy gradient methods, which are well-established family of techniques for reinforcement learning (Sutton et al., 2000). The gradient of the expected reward with respect to the policy parameters, $\\bar { \\nabla _ { \\theta _ { \\pi } } } J ( \\pi ( \\cdot | \\theta _ { \\pi } ) )$ , is given by: ",
+        "bbox": [
+            173,
+            790,
+            825,
+            834
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f54681db07aba3a81ef3afbfe75f4ad96329f25b04124b1f83557c168080b393.jpg",
+        "text": "$$\n\\nabla _ { \\theta _ { \\pi } } J ( \\pi ( \\cdot | \\theta _ { \\pi } ) ) = \\int _ { S } d \\theta ( s ) \\int _ { A } \\nabla _ { \\theta _ { \\pi } } \\log ( \\pi ( a , s | \\theta _ { \\pi } ) ) A _ { \\pi } ( s , a ) d a d s\n$$",
+        "text_format": "latex",
+        "bbox": [
+            279,
+            849,
+            718,
+            882
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\begin{array} { r } { d _ { \\theta } = \\int _ { S } \\sum _ { t = 0 } ^ { T } \\gamma ^ { t } p _ { 0 } ( s _ { 0 } ) ( s _ { 0 } \\to s \\mid t , \\pi _ { 0 } ) \\ d s _ { 0 } } \\end{array}$ is the discounted state distribution, $p _ { 0 } ( s )$ represents the initial state distribution, and $p _ { 0 } ( s _ { 0 } ) ( s _ { 0 } \\to s \\mid t , \\pi _ { 0 } )$ models the likelihood of reaching ",
+        "bbox": [
+            176,
+            891,
+            821,
+            925
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "state $s$ by starting at state $s _ { 0 }$ and following the policy $\\pi ( a , s | \\theta _ { \\pi } )$ for $T$ steps (Silver et al., 2014). $A _ { \\pi } ( s , a )$ represents an advantage function (Schulman et al., 2016). In this work, we use the Positive Temporal Difference (PTD) update proposed by (Van Hasselt, 2012) for $A _ { \\pi } ( s , a )$ : ",
+        "bbox": [
+            174,
+            103,
+            825,
+            146
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4b5354156e9e61839907082425aec6beb39de513c7c6b2c6ef7345c1f3709344.jpg",
+        "text": "$$\nA _ { \\pi } ( s _ { t } , a _ { t } ) = I \\left[ \\delta _ { t } > 0 \\right] = { \\binom { 1 , \\quad \\delta _ { t } > 0 } { 0 , \\quad \\mathrm { o t h e r w i s e } } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            346,
+            164,
+            632,
+            199
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/239cec7d07c1912cdeacc6faa40eb707b59e0b761f96562f292fada5da01cbf1.jpg",
+        "text": "$$\n\\delta _ { t } = r _ { t } + \\gamma V _ { \\pi } ( s _ { t + 1 } ) - V _ { \\pi } ( s _ { t } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            395,
+            213,
+            602,
+            231
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\begin{array} { r } { V _ { \\pi } ( s ) = \\mathbb { E } \\left[ \\sum _ { t = 0 } ^ { T } \\gamma ^ { t } r _ { t } \\mid s _ { 0 } = s \\right] } \\end{array}$ is the value function, which gives the expected discounted cumulative reward from following policy $\\pi$ starting in state $s$ . PTD has the benefit of being insensitive to the advantage function scale. Furthermore, limiting policy updates in this way to be only in the direction of actions that have a positive advantage has been found to increase the stability of learning (Van Hasselt, 2012). Because the true value function is unknown, an approximation $V _ { \\pi } ( \\cdot \\mid \\theta _ { v } )$ with parameters $\\theta _ { v }$ is learned, which is formulated as the regression problem: ",
+        "bbox": [
+            174,
+            241,
+            825,
+            334
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b8fc5693b2f9333970d1d23df51d629be04a642a73d5c42f5312c30a537d92ab.jpg",
+        "text": "$$\n\\mathrm { m i n i m i z e } _ { s _ { t } , r _ { t } , s _ { t + 1 } } \\mathbb { E } \\left[ \\frac { 1 } { 2 } \\left( y _ { t } - V _ { \\pi } ( s \\mid \\theta _ { v } ) \\right) ^ { 2 } \\right] , \\qquad y _ { t } = r _ { t } + \\gamma V _ { \\pi } ( s _ { t + 1 } \\mid \\theta _ { v } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            254,
+            349,
+            741,
+            385
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 POLICY DISTILLATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            398,
+            374,
+            414
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Given a set of expert agents that have solved/mastered different tasks we may want to combine the skills of these different experts into a single multi-skilled agent. This process is referred to as distillation. Distillation does not necessarily produce an optimal mix of the given experts but instead tries to produce an expert that best matches the action distributions produced by all experts. This method functions independent of the reward functions used to train each expert. Distillation also scales well with respect to the number of tasks or experts that are being combined. ",
+        "bbox": [
+            174,
+            425,
+            825,
+            510
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.3 TRANSFER LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            526,
+            369,
+            540
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Given an expert that has solved/mastered a task we want to reuse that expert knowledge in order to learn a new task efficiently. This problem falls in the area of Transfer Learning (Pan & Yang, 2010). Considering the state distribution expert is skilled at solving, $D _ { \\omega _ { i } }$ the source distribution) it can be advantageous to start learning a new, target task $\\omega _ { i + 1 }$ with target distribution $D _ { \\omega _ { i + 1 } }$ using assistance from the expert. The agent learning how to solve the target task with domain $D _ { \\omega _ { i + 1 } }$ is referred to as the student. When the expert is used to assist the student in learning the target task it can be referred to as the teacher. The success of these methods are dependent on overlap between the $D _ { \\omega _ { i } }$ and $D _ { \\omega _ { i + 1 } }$ state distributions. ",
+        "bbox": [
+            174,
+            551,
+            825,
+            664
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 PROGRESSIVE LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            684,
+            418,
+            699
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Although we focus on the problem of being presented with tasks sequentially, there exist other methods for learning a multi-skilled character. We considered 4 overall integration methods for learning multiple skills, the first being a controller that learns multiple tasks at the same time (MultiTasker), where a number of skills are learned at the same time. It has been shown that learning many tasks together can be faster than learning each task separately (Parisotto et al., 2015). The curriculum for using this method is shown in Figure 1a were during a single RL simulation all tasks are learned together. It is also possible to randomly initialize controllers and train in parallel (Parallel) and then combine the resulting policies Figure 1b. We found that learning many skills from scratch was challenging, we were only able to get fair results for the flat task. Also, when a new task is to be learned with the Parallel model it would occur outside of the original parallel learning, leading to a more sequential method. A TL-Only method that uses TL while learning tasks in a sequence Figure 1c, possibly ending with a distillation step to combine the learned policies to decrease forgetting. For more details see Appendix: 8.4. The last version (PLAiD) learns each task sequentially using TL from the previous, most skilled policy, in the end resulting in a policy capable of solving all tasks Figure 1d. This method works well for both combining learned skills and learning new skills. ",
+        "bbox": [
+            174,
+            715,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/76282a8dcb9c4a51633a2b51e08f18fda8a64c91c0411601f745ca180a064ad8.jpg",
+        "image_caption": [
+            "Figure 1: Different curriculum learning process. The red box with a $D$ in it denotes a distillation step that combines policies. Each gray box denotes one iteration of learning a new policy. The larger red boxes with an $L _ { t e r r a i n - t y p e }$ denotes a learning step where a new skill is learned. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            98,
+            818,
+            324
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 PROGRESSIVE LEARNING AND INTEGRATION VIA DISTILLATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            406,
+            661,
+            420
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this section, we detail our proposed learning framework for continual policy transfer and distillation (PLAiD). In the acquisition (TL) step, we are interested in learning a new task $\\omega _ { i + 1 }$ . Here transfer can be beneficial if the task structure is somewhat similar to previous tasks $\\omega _ { i }$ . We adopt the TL strategy of using an existing policy network and fine-tuning it to a new task. Since we are not concerned with retaining previous skills in this step, we can update this policy without concern for forgetting. As the agent learns it will develop more skills and the addition of every new skill can increase the probability of transferring knowledge to assist the learning of the next skill. ",
+        "bbox": [
+            174,
+            431,
+            825,
+            529
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In the integration (distillation) step, we are interested in combining all past skills $( \\pi _ { 0 } , \\ldots , \\pi _ { i } )$ with the newly acquired skill $\\pi _ { i + 1 }$ . Traditional approaches have used policy regression where data is generated by collecting trajectories of the expert policy on a task. Training the student on these trajectories does not always result in robust behaviour. This poor behaviour is caused by the student experiencing a different distribution of trajectories than the expert during evaluation. To compensate for this distribution difference, portions of the trajectories should be generated by the student. This allows the expert to suggest behaviour that will pull the state distribution of the student closer to the expert’s. This is a common problem in learning a model to reproduce a given distribution of trajectories (Ross et al., 2010; Bengio et al., 2015; Martinez et al., 2017; Lamb et al., 2016). We use a method similar to the DAGGER algorithm (Ross et al., 2010) which is useful for distilling policies (Parisotto et al., 2015). See Appendix: 8.2.1 for more details. As our RL algorithm is an actor-critic method, we also perform regression on the critic by fitting both in the same step. ",
+        "bbox": [
+            174,
+            536,
+            825,
+            702
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.2 HIGH LEVEL EXPERIMENT DESIGN ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            719,
+            460,
+            733
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The results presented in this work cover a range of tasks that share a similar action space and state space. Our focus is to demonstrate continual learning between related tasks. In addition, the conceptual framework allows for extensions that would permit differing state spaces, described later in Section: 5.2. ",
+        "bbox": [
+            174,
+            746,
+            823,
+            801
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "5 RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            821,
+            281,
+            838
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this experiment, our set of tasks consists of 5 different terrains that a 2D humanoid walker (pdbiped) learns to traverse. The humanoid walker is trained to navigate multiple types of terrain including flat in (Figure 6a), incline (Figure 6b), steps (Figure 6c), slopes (Figure 6d), gaps (Figure 6e) and a combination of all terrains mixed (Figure 6f) on which agents are trained. The goal in these tasks is to maintain a consistent forward velocity traversing various terrains, while also matching a motion capture clip of a natural human walking gait on flat ground, similar to (Peng & van de Panne, 2016). The pd-biped receives as input both a character and (eventually) a terrain state representation, consisting of the terrains heights of 50 equally-spaced points in front of the character. The action space is 11-dimensional, corresponding to the joints. Reasonable torque limits are applied, which helps produce more natural motions and makes the control problem more difficult. A detailed description of the experimental setup is included in Section: 8.5. The tasks are presented to the agent sequentially and the goal is to progressively learn to traverse all terrain types. ",
+        "bbox": [
+            174,
+            853,
+            823,
+            922
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            202
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We evaluate our approach against three baselines. First, we compare the above learning curriculum from learning new tasks in PLAiD with learning new tasks in Parallel. This will demonstrate that knowledge from previous tasks can be effectively transferred after distillation steps. Second, we compare to the MultiTasker to demonstrate that iterated distillation is effective for the retention of learned skills. The MultiTasker is also used as a baseline for comparing learning speed. Last, a method that performs TL between tasks and concludes with a distillation step is evaluated to illustrate the result of different TL and distillation schedules. The results of the PLAiD controller are displayed in the accompanying Video 1 ",
+        "bbox": [
+            174,
+            208,
+            823,
+            319
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.1 TRANSFER LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            337,
+            369,
+            352
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "First, the pd-biped is trained to produce a walking motion on flat ground (flat). In Figure 2a PLAiD is compared to the three baselines for training on incline. The TL-Only method learns fast as it is given significant information about how to perform similar skills. The Parallel method is given no prior information leading to a less skilled policy. The first MultiTasker for the incline task is initialized from a terrain injected controller that was trained to walk on flat ground. Any subsequent MultiTasker is initialized from the final MultiTasker model of the preceding task. This controller has to learn multiple tasks together, which can complicate the learning process, as simulation for each task is split across the training and the overall RL task can be challenging. This is in contrast to using PLAiD, that is also initialized with the same policy trained on flat, that will integrate skills together after each new skill is learned. ",
+        "bbox": [
+            174,
+            363,
+            825,
+            502
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In Figure 2b the MultiTasker is learning the new task (steps) with similar speed to PLAiD. However, after adding more tasks the MultiTasker is beginning to struggle in Figure 2c and starts to forget in Figure 2d, with the number of tasks it must learn at the same time. While PLAiD learns the new tasks faster and is able to integrate the new skill required to solve the task robustly. TL-Only is also able to learn the new tasks very efficiently. ",
+        "bbox": [
+            174,
+            510,
+            823,
+            579
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.2 INPUT FEATURE INJECTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            597,
+            405,
+            611
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "An appealing property of using distillation in PLAiD is that the combined policy model need not resemble that of the individual expert controllers. For example, two different experts lacking state features and trained without a local map of the terrain can be combined into a single policy that has new state features for the terrain. These new terrain features can assist the agent in the task domain in which it operates. ",
+        "bbox": [
+            174,
+            623,
+            825,
+            693
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We introduce the idea of input injection for this purpose. We augment a policy with additional input features while allowing it to retain its original functional behaviour similar to (Chen et al., 2015). This is achieved by adding additional inputs to the neural network and initializing the connecting layer weights and biases to 0. By only setting the weights and biases in the layer connecting the new features to the original network to 0, the gradient can still propagate to any lower layers which are initialized random without changing the functional behaviour. This is performed when distilling the flat and incline experts. Further details can be found in Appendix: 8.3. ",
+        "bbox": [
+            174,
+            700,
+            825,
+            797
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.3 DISTILLING MULTIPLE POLICIES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            815,
+            442,
+            830
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Training over multiple tasks at the same time may help the agent learn skills quicker, but this may not scale with respect to the number of tasks. When training the MultiTasker over two or even three tasks (Figure 3a) the method displays good results, however when learning a fourth or more tasks the method struggles, as shown in Figure 3b and 3b. Part of the reason for this struggle is when new ",
+        "bbox": [
+            176,
+            843,
+            823,
+            898
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/3ad2c2c9fa06c9e089f875efc852e274d11ed29956c99132554707e1f7495ded.jpg",
+        "image_caption": [
+            "Figure 2: Learning comparison over each of the environments. These plots show the mean and std over 5 simulations, each initialized with different random seeds. The learning for PLAiD is split into two steps, with TL (in green) going first followed by the distillation part (in yellow). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            99,
+            816,
+            422
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/e06814376ef110ed8f112f489c0753e628b304844ec96b1d5ff2d0064ea1593f.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Tasks</td><td rowspan=1 colspan=1>flat</td><td rowspan=1 colspan=1>incline</td><td rowspan=1 colspan=1>steps</td><td rowspan=1 colspan=1>slopes</td><td rowspan=1 colspan=1>gaps</td><td rowspan=1 colspan=1>average</td></tr><tr><td rowspan=1 colspan=1>PLAiD</td><td rowspan=1 colspan=1>0.054</td><td rowspan=1 colspan=1>0.155</td><td rowspan=1 colspan=1>0.001</td><td rowspan=1 colspan=1>0.043</td><td rowspan=1 colspan=1>-0.083</td><td rowspan=1 colspan=1>0.063</td></tr><tr><td rowspan=1 colspan=1>TL-Only</td><td rowspan=1 colspan=1>-0.065</td><td rowspan=1 colspan=1>-0.044</td><td rowspan=1 colspan=1>-0.235</td><td rowspan=1 colspan=1>-0.242</td><td rowspan=1 colspan=1>0.000</td><td rowspan=1 colspan=1>-0.147</td></tr><tr><td rowspan=1 colspan=1>TL-Only (with Distill)</td><td rowspan=1 colspan=1>0.068</td><td rowspan=1 colspan=1>0.039</td><td rowspan=1 colspan=1>-0.030</td><td rowspan=1 colspan=1>-0.062</td><td rowspan=1 colspan=1>-0.133</td><td rowspan=1 colspan=1>-0.024</td></tr><tr><td rowspan=1 colspan=1>MultiTasker</td><td rowspan=1 colspan=1>-0.001</td><td rowspan=1 colspan=1>-0.053</td><td rowspan=1 colspan=1>-0.030</td><td rowspan=1 colspan=1>0.119</td><td rowspan=1 colspan=1>0.000</td><td rowspan=1 colspan=1>0.009</td></tr></table>",
+        "bbox": [
+            174,
+            496,
+            823,
+            574
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 1: These values are relative percentage changes in the average reward, where a value of 0 is no forgetting and a value of $- 1$ corresponds to completely forgetting how to perform the task. A value $> 0$ corresponds to the agent learning how to better perform a task after training on other tasks. Here, the final policy after training on gaps compared to the original polices produced at the end of training for the task noted in the column heading. The TL-Only baseline forgets more than PLAiD. The MultiTasker forgets less than PLAiD but has a lower average reward over the tasks. ",
+        "bbox": [
+            173,
+            583,
+            825,
+            667
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "tasks are added the MultiTasker has to make trade-offs between more tasks to maximizes. As more tasks are added, this trade-off becomes increasingly complex resulting in the MultiTasker favouring easier tasks. Using PLAiD to combine the skills of many policies appears to scale better with respect to the number of skills being integrated. This is likely because distillation is a semi-supervised method which is more stable than the un-supervised RL solution. This can be seen in Figure 3d, 3e and especially in 3f where PLAiD combines the skills faster and can find higher value policies in practice. PLAiD also presents zero-shot training on tasks which it has never been trained on. In Figure 7 this generalization is shown as the agent navigates across the mixed environment. ",
+        "bbox": [
+            174,
+            699,
+            825,
+            811
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "This is also reflected in Table 1, that shows the final average reward when comparing methods before and after distillation. The TL-Only is able to achieve high performance but much is lost when learning new tasks. A final distillation step helps mitigate this issue but does not work as well as PLAiD. It is possible performing a large final distillation step can lead to over-fitting. ",
+        "bbox": [
+            174,
+            819,
+            823,
+            875
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "There are some indications that distillation is hindering training during the initial few iterations. We are initializing the network used in distillation with the most recently learning policy after TL. The large change in the initial state distribution from the previous seen distribution during TL could be causing larger gradients to appear, disrupting some of the structure learned during the TL step, shown in Figure 3d and 3e. There also might not exist a smooth transition in policy space between the newly learned policy and the previous policy distribution. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/d210c17dc800c8ec77184c7bfac03028cd6fc46014c8e1889265f74a53c2bb2d.jpg",
+        "image_caption": [
+            "Figure 3: These figures show the average reward a particular policy achieves over a number of tasks. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            113,
+            803,
+            497
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            551,
+            821,
+            593
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            616,
+            310,
+            632
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "MultiTasker vs PLAiD: The MultiTasker may be able to produce a policy that has higher overall average reward, but in practise constraints can keep the method from combining skills gracefully. If the reward functions are different between tasks, the MultiTasker can favour a task with higher rewards, as these tasks may receive higher advantage. It is also a non-trivial task to normalize the reward functions for each task in order to combine them. The MultiTasker may also favour tasks that are easier than other tasks in general. We have shown that the PLAiD scales better with respect to the number of tasks than the MultiTasker. We expect PLAiD would further outperform the MultiTasker if the tasks were more difficult and the reward functions dissimilar. ",
+        "bbox": [
+            174,
+            648,
+            825,
+            760
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In our evaluation we compare the number of iterations PLAiD uses to the number the MultiTasker uses on only the new task, which is not necessarily fair. The MultiTasker gains its benefits from training on the other tasks together. If the idea is to reduce the number of simulation samples that are needed to learn new tasks then the MultiTasker would fall far behind. Distillation is also very efficient with respect to the number of simulation steps needed. Data could be collected from the simulator in groups and learned from in many batches before more data is needed as is common for behavioural cloning. We expect another reason distillation benefits learning multiple tasks is that the integration process assists in pulling policies out of the local minima RL is prone to. ",
+        "bbox": [
+            174,
+            766,
+            825,
+            878
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Transfer Learning: Because we are using an actor-critic learning method, we also studied the possibility of using the value functions for TL. We did not discover any empirical evidence that this assisted the learning process. When transferring to a new task, the state distribution has changed and the reward function may be completely different. This makes it unlikely that the value function will be accurate on this new task. In addition, value functions are in general easier and faster to learn than policies, implying that value function reuse is less important to transfer. We also find that helpfulness of TL depends on not only the task difficulty but the reward function as well. Two tasks may overlap in state space but the area they overlap could be easily reachable. In this case TL may not give significant benefit because the overall RL problem is easy. The greatest benefit is gained from TL when the state space that overlaps for two tasks is difficult to reach and in that difficult to reach area is where the highest rewards are achieved. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            228
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6.1 LIMITATIONS: ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            251,
+            310,
+            263
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Once integrated, the skills for our locomotion tasks are self-selecting based on their context, i.e., the knowledge of the upcoming terrain. It may be that other augmentation and distillation strategies are better for situations where either the reward functions are different or a one-hot vector is used to select the currently active expert. In our transfer learning results we could be over fitting the initial expert for the particular task it was learning. Making it more challenging for the policy to learn a new task, resulting in negative transfer. After learning many new tasks the previous tasks may not receive a large enough potion of the distillation training process to preserve the experts skill well enough. How best to chose which data should be trained on next to best preserve the behaviour of experts is a general problem with multi-task learning. Distillation treats all tasks equally independent of their reward. This can result in very low value tasks, receiving potentially more distribution than desired and high value tasks receiving not enough. We have not needed the use a one-hot vector to indicate what task the agent is performing. We want the agent to be able to recognize which task it is given but we do realize that some tasks could be too similar to differentiate, such as, walking vs jogging on flat ground. ",
+        "bbox": [
+            174,
+            277,
+            825,
+            472
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6.2 FUTURE WORK: ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            493,
+            326,
+            507
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "It would be interesting to develop a method to prioritize tasks during the distillation step. This could assist the agent with forgetting issues or help with relearning tasks. While we currently use the Mean Squared Error (MSE) to pull the distributions of student policies in line with expert polices for distillation, better distance metrics would likely be helpful. Previous methods have used KL Divergence in the discrete action space domain where the state-action value function encodes the policy, e.g., as with Deep Q-Network (DQN). In this work we do not focus on producing the best policy from a mixture of experts, but instead we match the distributions from a number of experts. The difference is subtle but in practice it can be more challengine to balance many experts with respect to their reward functions. It could also be beneficial to use a KL penalty while performing distillation, i.e., something similar to the work in (Teh et al., 2017) in order to keep the policy from changing too rapidly during training. ",
+        "bbox": [
+            174,
+            521,
+            825,
+            674
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "7 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            699,
+            318,
+            714
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We have proposed and evaluated a method for the progressive learning and integration (via distillation) of motion skills. The method exploits transfer learning to speed learning of new skills, along with input injection where needed, as well as continuous-action distillation, using DAGGER-style learning. This compares favorably to baselines consisting of learning all skills together, or learning all the skills individually before integration. We believe that there remains much to learned about the best training and integration methods for movement skill repertoires, as is also reflected in the human motor learning literature. ",
+        "bbox": [
+            174,
+            733,
+            825,
+            830
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            856,
+            285,
+            871
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Marc G Bellemare, Yavar Naddaf, Joel Veness, and Michael Bowling. The arcade learning environment: An evaluation platform for general agents. J. Artif. Intell. Res.(JAIR), 47:253–279, 2013. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            922
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Samy Bengio, Oriol Vinyals, Navdeep Jaitly, and Noam Shazeer. Scheduled sampling for sequence prediction with recurrent neural networks. In C. Cortes, N. D. Lawrence, D. D. Lee, M. Sugiyama, and R. Garnett (eds.), Advances in Neural Information Processing Systems 28, pp. 1171–1179. Curran Associates, Inc., 2015. URL http://papers.nips.cc/paper/ 5956-scheduled-sampling-for-sequence-prediction-with-recurrent-neural-networks.pdf. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tianqi Chen, Ian Goodfellow, and Jonathon Shlens. Net2net: Accelerating learning via knowledge transfer. arXiv preprint arXiv:1511.05641, 2015. ",
+        "bbox": [
+            176,
+            183,
+            820,
+            212
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Coline Devin, Abhishek Gupta, Trevor Darrell, Pieter Abbeel, and Sergey Levine. Learning modular neural network policies for multi-task and multi-robot transfer. In Robotics and Automation (ICRA), 2017 IEEE International Conference on, pp. 2169–2176. IEEE, 2017. ",
+        "bbox": [
+            173,
+            220,
+            823,
+            263
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Chelsea Finn, Pieter Abbeel, and Sergey Levine. Model-agnostic meta-learning for fast adaptation of deep networks. arXiv preprint arXiv:1703.03400, 2017. ",
+        "bbox": [
+            171,
+            272,
+            825,
+            301
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nicolas Heess, Gregory Wayne, Yuval Tassa, Timothy P. Lillicrap, Martin A. Riedmiller, and David Silver. Learning and transfer of modulated locomotor controllers. CoRR, abs/1610.05182, 2016. URL http://arxiv.org/abs/1610.05182. ",
+        "bbox": [
+            174,
+            310,
+            825,
+            353
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "James Kirkpatrick, Razvan Pascanu, Neil Rabinowitz, Joel Veness, Guillaume Desjardins, Andrei A. Rusu, Kieran Milan, John Quan, Tiago Ramalho, Agnieszka Grabska-Barwinska, Demis Hassabis, Claudia Clopath, Dharshan Kumaran, and Raia Hadsell. Overcoming catastrophic forgetting in neural networks. Proceedings of the National Academy of Sciences, 114(13):3521–3526, 2017. doi: 10.1073/pnas.1611835114. URL http://www.pnas.org/content/114/13/3521.abstract. ",
+        "bbox": [
+            173,
+            363,
+            825,
+            433
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tejas D Kulkarni, Karthik Narasimhan, Ardavan Saeedi, and Josh Tenenbaum. Hierarchical deep reinforcement learning: Integrating temporal abstraction and intrinsic motivation. In Advances in Neural Information Processing Systems 29, pp. 3675–3683. 2016. ",
+        "bbox": [
+            176,
+            443,
+            823,
+            484
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alex M Lamb, Anirudh Goyal ALIAS PARTH GOYAL, Ying Zhang, Saizheng Zhang, Aaron C Courville, and Yoshua Bengio. Professor forcing: A new algorithm for training recurrent networks. In D. D. Lee, M. Sugiyama, U. V. Luxburg, I. Guyon, and R. Garnett (eds.), Advances in Neural Information Processing Systems 29, pp. 4601–4609. Curran Associates, Inc., 2016. URL http://papers.nips.cc/paper/ 6099-professor-forcing-a-new-algorithm-for-training-recurrent-networks.pdf. ",
+        "bbox": [
+            174,
+            494,
+            825,
+            578
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Zhizhong Li and Derek Hoiem. Learning without forgetting. CoRR, abs/1606.09282, 2016. URL http://arxiv.org/abs/1606.09282. ",
+        "bbox": [
+            176,
+            588,
+            821,
+            616
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Julieta Martinez, Michael J. Black, and Javier Romero. On human motion prediction using recurrent neural networks. CoRR, abs/1705.02445, 2017. URL http://arxiv.org/abs/1705.02445. ",
+        "bbox": [
+            173,
+            626,
+            823,
+            655
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Josh Merel, Yuval Tassa, Sriram Srinivasan, Jay Lemmon, Ziyu Wang, Greg Wayne, and Nicolas Heess. Learning human behaviors from motion capture by adversarial imitation. arXiv preprint arXiv:1707.02201, 2017. ",
+        "bbox": [
+            173,
+            662,
+            823,
+            705
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "S. J. Pan and Q. Yang. A survey on transfer learning. IEEE Transactions on Knowledge and Data Engineering, 22(10):1345–1359, Oct 2010. ISSN 1041-4347. doi: 10.1109/TKDE.2009.191. ",
+        "bbox": [
+            169,
+            715,
+            823,
+            744
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Emilio Parisotto, Jimmy Lei Ba, and Ruslan Salakhutdinov. Actor-mimic: Deep multitask and transfer reinforcement learning. arXiv preprint arXiv:1511.06342, 2015. ",
+        "bbox": [
+            173,
+            753,
+            823,
+            782
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Xue Bin Peng and Michiel van de Panne. Learning locomotion skills using deeprl: Does the choice of action space matter? CoRR, abs/1611.01055, 2016. URL http://arxiv.org/abs/1611.01055. ",
+        "bbox": [
+            171,
+            791,
+            825,
+            820
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Xue Bin Peng, Glen Berseth, Kangkang Yin, and Michiel Van De Panne. Deeploco: Dynamic locomotion skills using hierarchical deep reinforcement learning. ACM Transactions on Graphics (TOG), 36(4):41, 2017. ",
+        "bbox": [
+            173,
+            829,
+            823,
+            872
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "J. Rajendran, A. S. Lakshminarayanan, M. M. Khapra, P Prasanna, and B. Ravindran. Attend, adapt and transfer: Attentive deep architecture for adaptive transfer from multiple sources in the same domain. arXiv preprint arXiv:1510.02879, October 2015. ",
+        "bbox": [
+            174,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ryan T Roemmich and Amy J Bastian. Two ways to save a newly learned motor pattern. Journal of neurophysiology, 113(10):3519–3530, 2015. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Stephane Ross, Geoffrey J. Gordon, and J. Andrew Bagnell. No-regret reductions for imitation ´ learning and structured prediction. CoRR, abs/1011.0686, 2010. URL http://arxiv.org/abs/1011. 0686. ",
+        "bbox": [
+            176,
+            141,
+            823,
+            183
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Andrei A Rusu, Sergio Gomez Colmenarejo, Caglar Gulcehre, Guillaume Desjardins, James Kirkpatrick, Razvan Pascanu, Volodymyr Mnih, Koray Kavukcuoglu, and Raia Hadsell. Policy distillation. arXiv preprint arXiv:1511.06295, 2015. ",
+        "bbox": [
+            174,
+            193,
+            821,
+            236
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Andrei A. Rusu, Neil C. Rabinowitz, Guillaume Desjardins, Hubert Soyer, James Kirkpatrick, Koray Kavukcuoglu, Razvan Pascanu, and Raia Hadsell. Progressive Neural Networks. arXiv, 2016. URL http://arxiv.org/abs/1606.04671. ",
+        "bbox": [
+            174,
+            244,
+            823,
+            286
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jurgen Schmidhuber. POWERPLAY: training an increasingly general problem solver by continually ¨ searching for the simplest still unsolvable problem. CoRR, abs/1112.5309, 2011. URL http: //arxiv.org/abs/1112.5309. ",
+        "bbox": [
+            173,
+            295,
+            825,
+            338
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "John Schulman, Philipp Moritz, Sergey Levine, Michael Jordan, and Pieter Abbeel. Highdimensional continuous control using generalized advantage estimation. In International Conference on Learning Representations (ICLR 2016), 2016. ",
+        "bbox": [
+            173,
+            347,
+            821,
+            390
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Hanul Shin, Jung Kwon Lee, Jaehong Kim, and Jiwon Kim. Continual learning with deep generative replay. arXiv preprint arXiv:1705.08690, 2017. ",
+        "bbox": [
+            173,
+            397,
+            823,
+            428
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "David Silver, Guy Lever, Nicolas Heess, Thomas Degris, Daan Wierstra, and Martin Riedmiller. Deterministic policy gradient algorithms. In ICML, 2014. ",
+        "bbox": [
+            174,
+            435,
+            823,
+            465
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Rupesh Kumar Srivastava, Bas R. Steunebrink, and Jurgen Schmidhuber. First experiments with ¨ powerplay. CoRR, abs/1210.8385, 2012. URL http://arxiv.org/abs/1210.8385. ",
+        "bbox": [
+            173,
+            473,
+            823,
+            503
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Richard S Sutton, David A McAllester, Satinder P Singh, and Yishay Mansour. Policy gradient methods for reinforcement learning with function approximation. In Advances in neural information processing systems, pp. 1057–1063, 2000. ",
+        "bbox": [
+            171,
+            511,
+            823,
+            554
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Matthew E Taylor and Peter Stone. Transfer learning for reinforcement learning domains: A survey. Journal of Machine Learning Research, 10(Jul):1633–1685, 2009. ",
+        "bbox": [
+            173,
+            563,
+            823,
+            592
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yee Whye Teh, Victor Bapst, Wojciech Marian Czarnecki, John Quan, James Kirkpatrick, Raia Hadsell, Nicolas Heess, and Razvan Pascanu. Distral: Robust multitask reinforcement learning. arXiv preprint arXiv:1707.04175, 2017. ",
+        "bbox": [
+            176,
+            601,
+            823,
+            643
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Chen Tessler, Shahar Givony, Tom Zahavy, Daniel J Mankowitz, and Shie Mannor. A Deep Hierarchical Approach to Lifelong Learning in Minecraft. arXiv, pp. 1–6, 2016. URL http: //arxiv.org/abs/1604.07255. ",
+        "bbox": [
+            174,
+            652,
+            821,
+            694
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Hado Van Hasselt. Reinforcement learning in continuous state and action spaces. In Reinforcement Learning, pp. 207–251. Springer, 2012. ",
+        "bbox": [
+            173,
+            704,
+            823,
+            733
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Daniel M Wolpert and J Randall Flanagan. Computations underlying sensorimotor learning. Current opinion in neurobiology, 37:7–11, 2016. ",
+        "bbox": [
+            173,
+            742,
+            825,
+            770
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "8 APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            796,
+            294,
+            813
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "8.1 NETWORK MODELS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            828,
+            352,
+            842
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We used two different Network models for the experiments in this paper. The first model is a blind model that does not have any terrain features. The blind policy is a Neural Network with 2 hidden layers $( 5 1 2 \\times 2 5 6 )$ with ReLU activations. The output layer of the policy network has linear activations. The network used for the value function has the same design except there is 1 output on the final layer. This design is used for the flat and incline tasks. ",
+        "bbox": [
+            174,
+            854,
+            825,
+            922
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We augment the blind network design by adding features for terrain to create an agent with sight. This network with terrain features has a single convolution layer with 8 filters of width 3. This constitutional layer is followed by a dense layer of 32 units. The dense layer is then concatenated twice, once along each of the original two hidden layers in the blind version of the policy. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            160
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "8.2 HYPER PARAMETERS AND TRAINING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            178,
+            472,
+            191
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "The policy network models a Gaussian distribution by outputting a state dependant mean. We use a state independent standard deviation that normalized with respect to the action space and multiplied by 0.1. We also use a version of epsilon greedy exploration where with $\\epsilon$ probability an exploration action is generated. For all of our experiments we linearly anneal $\\epsilon$ from 0.2 to 0.1 in 100, 000 iterations and leave it from that point on. Each training simulation takes approximately 5 hours across 8 threads. For network training we use Stochastic Gradient Decent (SGD) with momentum. During the distillation step we use gradually anneal the probability of selecting an expert action from 1 to 0 over 10, 000 iterations. ",
+        "bbox": [
+            174,
+            203,
+            825,
+            314
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "For the evaluation of each model on a particular task we use the average reward achieved by the agent over at most 100 seconds of simulation time. We average this over running the agent over a number of randomly generated simulation runs. ",
+        "bbox": [
+            174,
+            321,
+            825,
+            363
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "8.2.1 DISTILLATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            380,
+            330,
+            395
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "For each of the distillation steps we initialize the policy from the most recently trained policy. This policy has seen all of the tasks thus far but may have overfit the most recent tasks. We us a version of the DAGGER algorithm for the distillation process (Ross et al., 2010). We anneal from selecting actions from the expert polices to selecting actions from the student policy The probability of selecting an action from the expert is annealed to near zero after $1 0 , 0 0 0$ training updates. We still add exploration noise to the policies when generating actions to take in the simulation. This is also annealed along with the probability of selecting from the expert policy. The actions used for training always come from the expert policy. Although some actions are applied in the simulation from the student, during a training update those actions will be replaced with ones from the proper expert. The expert used to generate actions for tasks $0 - i$ is $\\pi _ { i }$ and the expert used to generate action for task $i + 1$ is $\\pi _ { i + 1 }$ . We keep around at most 2 policies at any time. ",
+        "bbox": [
+            174,
+            405,
+            825,
+            558
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "8.3 INPUT FEATURES AND INJECTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            575,
+            447,
+            589
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "In order to add additional input features to the policy network we construct a new network. This new network has a portion of it that is the same design as the previous network plus additional parameters. First we initialize the new network with random parameters. Then we copy over the values from the previous network into the new one for the portion of the network design that matches the old. Then the weight for the layers that connect the old portion of the network to the new are set to 0. This will allow the network to preserve the previous distribution it modeled. Having the parameters from the old network will also help generate gradients to train the new 0 valued network parameters. We use feature injection to assist the learning method with differentiating between different states. For example, it could be challenging to discover the difference between the flat and incline tasks using only the character features. Therefore, we add new terrain features to allow the controller to better differentiate between these two different tasks. ",
+        "bbox": [
+            174,
+            602,
+            825,
+            753
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "8.4 TL-ONLY BASELINE",
+        "text_level": 1,
+        "bbox": [
+            176,
+            772,
+            357,
+            786
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We also evaluate a baseline where we TL for all tasks. In this baseline TL is performed for a number of tasks and then distillation is used to combined these many learned skills. This method can be considered a version of PLAiD where tasks are learned in groups and after some number of tasks, a collection of policies/skills are distilled together. In Figure 5 the learning curves for the TL-Only baseline are given. The TL-Only method learns new tasks well. We do not show the incline tasks as the two methods are the same up to starting the steps tasks. In Table 1 the amount of forgetting is compared between methods. To compare the amount of forgetting between TL-Only and PLAiD we show the relative loss in average reward between the original policy trained for the tasks steps and slopes and the final polices for each method on gaps. The TL-Only method shows a larger drop in ",
+        "bbox": [
+            174,
+            797,
+            825,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/9c660ef62d2a56de4a641b330d126aac0a2ac2b9dd9cfeefdfa332b4964a851b.jpg",
+        "image_caption": [
+            "Figure 4: (a) The input features include both the character state shown as the red lines between the root of the character and the character’s links and the terrain features shown as the blue arrows along the ground. (b) A diagram of method used to inject additional state features for the terrain. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            101,
+            816,
+            210
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/b2d8e1dd2627438c4627e5c36a63a2f03010d9fcba89c98432380098ce2da7b8.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Tasks</td><td rowspan=1 colspan=1>flat</td><td rowspan=1 colspan=1>incline</td><td rowspan=1 colspan=1>steps</td><td rowspan=1 colspan=1>slopes</td><td rowspan=1 colspan=1>gaps</td><td rowspan=1 colspan=1>average</td></tr><tr><td rowspan=1 colspan=1>PLAiD</td><td rowspan=1 colspan=1>0.891</td><td rowspan=1 colspan=1>0.800</td><td rowspan=1 colspan=1>0.666</td><td rowspan=1 colspan=1>0.602</td><td rowspan=1 colspan=1>0.529</td><td rowspan=1 colspan=1>0.698</td></tr><tr><td rowspan=1 colspan=1>TL-Only</td><td rowspan=1 colspan=1>0.790</td><td rowspan=1 colspan=1>0.662</td><td rowspan=1 colspan=1>0.615</td><td rowspan=1 colspan=1>0.543</td><td rowspan=1 colspan=1>0.626</td><td rowspan=1 colspan=1>0.647</td></tr><tr><td rowspan=1 colspan=1>TL-Only (with Distill)</td><td rowspan=1 colspan=1>0.903</td><td rowspan=1 colspan=1>0.719</td><td rowspan=1 colspan=1>0.781</td><td rowspan=1 colspan=1>0.671</td><td rowspan=1 colspan=1>0.543</td><td rowspan=1 colspan=1>0.723</td></tr><tr><td rowspan=1 colspan=1>MultiTasker</td><td rowspan=1 colspan=1>0.844</td><td rowspan=1 colspan=1>0.757</td><td rowspan=1 colspan=1>0.677</td><td rowspan=1 colspan=1>0.656</td><td rowspan=1 colspan=1>0.504</td><td rowspan=1 colspan=1>0.688</td></tr></table>",
+        "bbox": [
+            176,
+            280,
+            821,
+            358
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Table 2: Final average reward for each method. Higher is better. Here, the final policy is after training on gaps. the PLAiD method achieves on average higher values across tasks. ",
+        "bbox": [
+            173,
+            368,
+            823,
+            397
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "policy performance corresponding to a large amount of forgeting compared to PLAiD, in particular for the more complex tasks steps and slopes. Interestingly, the final distllation step for TL-Only appears to reduce the performance of the policy. We believe this is related to the final distillation step being more challenging than performing a simpler distillation after each new task. Note that we only compare these two steps because the process for the first two tasks for PLAiD and TL-Only are the same. A comparison of the average rewards for the final policies are given in Table 2. ",
+        "bbox": [
+            173,
+            426,
+            825,
+            511
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/1ed68d2dc9fafb1d593037526d0a41547396f861268e7b1e1d7bfc3b03a7250f.jpg",
+        "image_caption": [
+            "Figure 5: Transfer learning only baselines for each of the new tasks. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            525,
+            823,
+            637
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "8.5 AGENT DESIGN ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            694,
+            321,
+            708
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The agent used in the simulation models the dimensions and masses of the average adult. The size of the character state is 50 parameters that include the relative position and velocity of the links in the agent (Figure 4a). The action space consists of 11 parameters that indicate target joint positions for the agent. The target joint positions (pd-targets) are turned into joint torques via proportional derivative controllers at each joint. ",
+        "bbox": [
+            174,
+            722,
+            825,
+            791
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The reward function for the agent consists of 3 primary terms. The first is a velocity term the rewards the agent for going at velocity of $1 ~ \\mathrm { m / s }$ The second term is the difference between the pose of the agent and the current pose of a kinematic character controlled via a motion capture clip. The difference between the agent and the clip consists of the rotational difference between each corresponding joint and the difference in angular velocity. The angular velocity for the clip is approximated via finite differences between the current pose of the clip and it’s last pose. The last term is an L2 penalty on the torques generated by the agent to help reduce spastic motions. We also impose torque limits on the joints to reduce unrealistic behaviour, limits: Hips 150, knees 125, ankles 100, shoulders 100, elbows 75 and neck $5 0 \\mathrm { { N / m } }$ . ",
+        "bbox": [
+            173,
+            797,
+            825,
+            922
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Terrain Types All terrain types are randomly generated per episode, except for the flat terrain. The incline terrain is slanted and the slant of the terrain is randomly sampled between 20 and 25 degrees. The steps terrain consists of flat segments with widths randomly sampled from $1 . 0 \\mathrm { ~ m ~ }$ to $1 . 5 \\textrm { m }$ followed by sharp steps that have randomly generated heights between $5 \\mathrm { \\ c m }$ and $1 5 ~ \\mathrm { c m }$ . The slopes terrain is randomly generated by updating the slope of the previous point in the ground with a value sampled from $- 2 0$ and 20 degrees to generate a new portion of the ground every $1 0 ~ \\mathrm { c m }$ . The gaps terrain generate gaps of width $2 5 \\textrm { - } 3 0 \\ \\mathrm { c m }$ separated by flat segments of widths sampled from $2 . 0 \\textrm { m }$ to $2 . 5 \\textrm { m }$ . The mixed terrain is a combination of the above terrains where a portion is randomly chosen from the above terrain types. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            229
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/220ff1dfc480f93ba710e4bf63078533ec173fdf104585fc9c94acd963d2ed0d.jpg",
+        "image_caption": [
+            "Figure 6: The environments used to evaluate PLAiD. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            239,
+            821,
+            486
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/4f2d76308c96b5e55985187fa1f526683327dd8e0f93fd24854330bb283e5f5c.jpg",
+        "image_caption": [
+            "Figure 7: Still frame shots of the pd-biped traversing the mixed environment. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            531,
+            820,
+            664
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "8.6 MULTITASKER ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            714,
+            316,
+            728
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "In certain cases the MultiTasker can learn new task faster than PLAiD. In Figure 8a we present the MultiTasker and compare it to PLAiD. In this case the MultiTasker splits its training time across multiple tasks, here we compare the two methods with respect to the time spent learning on the single new task. This is a good baseline to compare our method against but in some ways this is not fair. If the real measure of how efficient a learning method is the number of simulation samples that are needed to learn would fall far behind as the MultiTasker needs to train across all tasks to gain the benefits of improving a single task without forgetting the old tasks. ",
+        "bbox": [
+            173,
+            739,
+            825,
+            838
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/6104bfa844eaee20828e3951320d95bb6db5ef54eb255e2b4df87ee596371125.jpg",
+        "image_caption": [
+            "Figure 8: (a) Shows that the MultiTasker can learn faster on steps, flat and incline than PLAiD (expert) learning the single task steps with TL. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            375,
+            409,
+            612,
+            569
+        ],
+        "page_idx": 14
+    }
+]

parse/train/ByJHuTgA-/ByJHuTgA-.md

@@ -0,0 +1,228 @@
+# ON THE STATE OF THE ART OF EVALUATION IN NEURAL LANGUAGE MODELS
+
+Gabor Melis´ †, Chris Dyer†, Phil Blunsom†‡   
+{melisgl,cdyer,pblunsom}@google.com   
+†DeepMind   
+‡University of Oxford
+
+# ABSTRACT
+
+Ongoing innovations in recurrent neural network architectures have provided a steady influx of apparently state-of-the-art results on language modelling benchmarks. However, these have been evaluated using differing codebases and limited computational resources, which represent uncontrolled sources of experimental variation. We reevaluate several popular architectures and regularisation methods with large-scale automatic black-box hyperparameter tuning and arrive at the somewhat surprising conclusion that standard LSTM architectures, when properly regularised, outperform more recent models. We establish a new state of the art on the Penn Treebank and Wikitext-2 corpora, as well as strong baselines on the Hutter Prize dataset.
+
+# 1 INTRODUCTION
+
+The scientific process by which the deep learning research community operates is guided by empirical studies that evaluate the relative quality of models. Complicating matters, the measured performance of a model depends not only on its architecture (and data), but it can strongly depend on hyperparameter values that affect learning, regularisation, and capacity. This hyperparameter dependence is an often inadequately controlled source of variation in experiments, which creates a risk that empirically unsound claims will be reported.
+
+In this paper, we use a black-box hyperparameter optimisation technique to control for hyperparameter effects while comparing the relative performance of language modelling architectures based on LSTMs, Recurrent Highway Networks (Zilly et al., 2016) and NAS (Zoph & Le, 2016). We specify flexible, parameterised model families with the ability to adjust embedding and recurrent cell sizes for a given parameter budget and with fine grain control over regularisation and learning hyperparameters.
+
+Once hyperparameters have been properly controlled for, we find that LSTMs outperform the more recent models, contra the published claims. Our result is therefore a demonstration that replication failures can happen due to poorly controlled hyperparameter variation, and this paper joins other recent papers in warning of the under-acknowledged existence of replication failure in deep learning (Henderson et al., 2017; Reimers & Gurevych, 2017). However, we do show that careful controls are possible, albeit at considerable computational cost.
+
+Several remarks can be made in light of these results. First, as (conditional) language models serve as the central building block of many tasks, including machine translation, there is little reason to expect that the problem of unreliable evaluation is unique to the tasks discussed here. However, in machine translation, carefully controlling for hyperparameter effects would be substantially more expensive because standard datasets are much larger. Second, the research community should strive for more consensus about appropriate experimental methodology that balances costs of careful experimentation with the risks associated with false claims. Finally, more attention should be paid to hyperparameter sensitivity. Models that introduce many new hyperparameters or which perform well only in narrow ranges of hyperparameter settings should be identified as such as part of standard publication practice.
+
+![](images/f81bf295401ea1f5d33b190a8279a379b919f6538c1f3652283719438ad90409.jpg)  
+Figure 1: Recurrent networks with optional down-projection (trapezoids), per-step and per-sequence dropout (dashed and solid lines).
+
+# 2 MODELS
+
+Our focus is on three recurrent architectures:
+
+• The Long Short-Term Memory (Hochreiter & Schmidhuber, 1997) serves as a well known and frequently used baseline.   
+• The recently proposed Recurrent Highway Network (Zilly et al., 2016) is chosen because it has demonstrated state-of-the-art performance on a number of datasets.   
+• Finally, we also include NAS (Zoph & Le, 2016), because of its impressive performance and because its architecture was the result of an automated reinforcement learning based optimisation process.
+
+Our aim is strictly to do better model comparisons for these architectures and we thus refrain from including techniques that are known to push perplexities even lower, but which are believed to be largely orthogonal to the question of the relative merits of these recurrent cells. In parallel work with a remarkable overlap with ours, Merity et al. (2017) demonstrate the utility of adding a Neural Cache (Grave et al., 2016). Building on their work, Krause et al. (2017) show that Dynamic Evaluation (Graves, 2013) contributes similarly to the final perplexity.
+
+As pictured in Fig. 1a, our models with LSTM or NAS cells have all the standard components: an input embedding lookup table, recurrent cells stacked as layers with additive skip connections combining outputs of all layers to ease optimisation. There is an optional down-projection whose presence is governed by a hyperparameter from this combined output to a smaller space which reduces the number of output embedding parameters. Unless otherwise noted, input and output embeddings are shared, see (Inan et al., 2016) and (Press & Wolf, 2016).
+
+Dropout is applied to feedforward connections denoted by dashed arrows in the figure. From the bottom up: to embedded inputs (input dropout), to connections between layers (intra-layer dropout), to the combined and the down-projected outputs (output dropout). All these dropouts have random masks drawn independently per time step, in contrast to the dropout on recurrent states where the same mask is used for all time steps in the sequence.
+
+RHN based models are typically conceived of as a single horizontal “highway” to emphasise how the recurrent state is processed through time. In Fig. 1b, we choose to draw their schema in a way that makes the differences from LSTMs immediately apparent. In a nutshell, the RHN state is passed from the topmost layer to the lowest layer of the next time step. In contrast, each LSTM layer has its own recurrent connection and state.
+
+The same dropout variants are applied to all three model types, with the exception of intra-layer dropout which does not apply to RHNs since only the recurrent state is passed between the layers.
+
+For the recurrent states, all architectures use either variational dropout (Gal & Ghahramani, 2016, state dropout)1 or recurrent dropout (Semeniuta et al., 2016), unless explicitly noted otherwise.
+
+# 3 EXPERIMENTAL SETUP
+
+# 3.1 DATASETS
+
+We compare models on three datasets. The smallest of them is the Penn Treebank corpus by Marcus et al. (1993) with preprocessing from Mikolov et al. (2010). We also include another word level corpus: Wikitext-2 by Merity et al. (2016). It is about twice the size of Penn Treebank with a larger vocabulary and much lighter preprocessing. The third corpus is Enwik8 from the Hutter Prize dataset (Hutter, 2012). Following common practice, we use the first 90 million characters for training, and the remaining 10 million evenly split between validation and test.
+
+# 4 TRAINING DETAILS
+
+When training word level models we follow common practice and use a batch size of 64, truncated backpropagation with 35 time steps, and we feed the final states from the previous batch as the initial state of the subsequent one. At the beginning of training and test time, the model starts with a zero state. To bias the model towards being able to easily start from such a state at test time, during training, with probability 0.01 a constant zero state is provided as the initial state.
+
+Optimisation is performed by Adam (Kingma & Ba, 2014) with $\beta _ { 1 } ~ = ~ 0$ but otherwise default parameters $( \beta _ { 2 } ~ = ~ 0 . 9 9 9$ , $\epsilon { \bf \bar { \alpha } } = 1 0 ^ { - 9 } $ ). Setting $\beta _ { 1 }$ so turns off the exponential moving average for the estimates of the means of the gradients and brings Adam very close to RMSProp without momentum, but due to Adam’s bias correction, larger learning rates can be used.
+
+Batch size is set to 64. The learning rate is multiplied by 0.1 whenever validation performance does not improve ever during 30 consecutive checkpoints. These checkpoints are performed after every 100 and 200 optimization steps for Penn Treebank and Wikitext-2, respectively.
+
+For character level models (i.e. Enwik8), the differences are: truncated backpropagation is performed with 50 time steps. Adam’s parameters are $\beta _ { 2 } ~ = ~ 0 . 9 9$ , $\epsilon = 1 0 ^ { - 5 }$ . Batch size is 128. Checkpoints are only every 400 optimisation steps and embeddings are not shared.
+
+# 5 EVALUATION
+
+For evaluation, the checkpoint with the best validation perplexity found by the tuner is loaded and the model is applied to the test set with a batch size of 1. For the word based datasets, using the training batch size makes results worse by $0 . 3 \ : \mathrm { P P L }$ while Enwik8 is practically unaffected due to its evaluation and training sets being much larger. Preliminary experiments indicate that MC averaging would bring a small improvement of about 0.4 in perplexity and 0.005 in bits per character, similar to the results of Gal & Ghahramani (2016), while being a 1000 times more expensive which is prohibitive on larger datasets. Therefore, throughout we use the mean-field approximation for dropout at test time.
+
+# 5.1 HYPERPARAMETER TUNING
+
+Hyperparameters are optimised by Google Vizier (Golovin et al., 2017), a black-box hyperparameter tuner based on batched GP bandits using the expected improvement acquisition function (Desautels et al., 2014). Tuners of this nature are generally more efficient than grid search when the number of hyperparameters is small. To keep the problem tractable, we restrict the set of hyperparameters to learning rate, input embedding ratio, input dropout, state dropout, output dropout, weight decay. For deep LSTMs, there is an extra hyperparameter to tune: intra-layer dropout. Even with this small set, thousands of evaluations are required to reach convergence.
+
+Table 1: Validation and test set perplexities on Penn Treebank for models with different numbers of parameters and depths. All results except those from Zaremba are with shared input and output embeddings. VD stands for Variational Dropout from Gal & Ghahramani (2016). †: parallel work.   
+
+<table><tr><td>Model</td><td>Size</td><td>Depth</td><td>Valid</td><td>Test</td></tr><tr><td>Medium LSTM, Zaremba et al. (2014)</td><td>10M</td><td>2</td><td>86.2</td><td>82.7</td></tr><tr><td>Large LSTM, Zaremba et al. (2014)</td><td>24M</td><td>2</td><td>82.2</td><td>78.4</td></tr><tr><td>VD LSTM,Press &amp; Wolf (2016)</td><td>51M</td><td>2</td><td>75.8</td><td>73.2</td></tr><tr><td>VD LSTM, Inan et al. (2016)</td><td>9M</td><td>2</td><td>77.1</td><td>73.9</td></tr><tr><td>VD LSTM, Inan et al. (2016)</td><td>28M</td><td>2</td><td>72.5</td><td>69.0</td></tr><tr><td>VD RHN, Zilly et al. (2016)</td><td>24M</td><td>10</td><td>67.9</td><td>65.4</td></tr><tr><td>NAS, Zoph &amp; Le (2016)</td><td>25M</td><td>-</td><td></td><td>64.0</td></tr><tr><td>NAS, Zoph &amp; Le (2016)</td><td>54M</td><td>1</td><td>=</td><td>62.4</td></tr><tr><td>AWD-LSTM, Merity et al. (2017) +</td><td>24M</td><td>3</td><td>60.0</td><td>57.3</td></tr><tr><td>LSTM</td><td rowspan="6">10M</td><td>1</td><td>61.8</td><td>59.6</td></tr><tr><td>LSTM</td><td>2</td><td>63.0</td><td>60.8</td></tr><tr><td>LSTM</td><td>4</td><td>62.4</td><td>60.1</td></tr><tr><td>RHN</td><td>5</td><td>66.0</td><td>63.5</td></tr><tr><td>NAS</td><td>1</td><td>65.6</td><td>62.7</td></tr><tr><td>LSTM</td><td>1</td><td>61.4</td><td>59.5</td></tr><tr><td>LSTM</td><td></td><td></td><td>62.1</td><td>59.6</td></tr><tr><td>LSTM</td><td>24M</td><td>2 4</td><td>60.9</td><td>58.3</td></tr><tr><td>RHN</td><td></td><td>5</td><td>64.8</td><td>62.2</td></tr><tr><td>NAS</td><td></td><td>1</td><td>62.1</td><td>59.7</td></tr></table>
+
+Parameter budget. Motivated by recent results from Collins et al. (2016), we compare models on the basis of the total number of trainable parameters as opposed to the number of hidden units. The tuner is given control over the presence and size of the down-projection, and thus over the tradeoff between the number of embedding vs. recurrent cell parameters. Consequently, the cells’ hidden size and the embedding size is determined by the actual parameter budget, depth and the input embedding ratio hyperparameter.
+
+For Enwik8 there are relatively few parameters in the embeddings since the vocabulary size is only 205. Here we choose not to share embeddings and to omit the down-projection unconditionally.
+
+# 6 RESULTS
+
+# 6.1 PENN TREEBANK
+
+We tested LSTMs of various depths and an RHN of depth 5 with parameter budgets of 10 and 24 million matching the sizes of the Medium and Large LSTMs by (Zaremba et al., 2014). The results are summarised in Table 1.
+
+Notably, in our experiments even the RHN with only 10M parameters has better perplexity than the 24M one in the original publication. Our 24M version improves on that further. However, a shallow LSTM-based model with only 10M parameters enjoys a very comfortable margin over that, with deeper models following near the estimated noise range. At 24M, all depths obtain very similar results, reaching 58.3 at depth 4. Unsurprisingly, NAS whose architecture was chosen based on its performance on this dataset does almost equally well, even better than in Zoph & Le (2016).
+
+# 6.2 WIKITEXT-2
+
+Wikitext-2 is not much larger than Penn Treebank, so it is not surprising that even models tuned for Penn Treebank perform reasonably on this dataset, and this is in fact how results in previous works were produced. For a fairer comparison, we also tune hyperparameters on the same dataset. In Table 2, we report numbers for both approaches. All our results are well below the previous state of the are for models without dynamic evaluation or caching. That said, our best result, 65.9 compares favourably even to the Neural Cache (Grave et al., 2016) whose innovations are fairly orthogonal to the base model.
+
+<table><tr><td>Model</td><td>Size</td><td>Depth</td><td>Valid</td><td>Test</td></tr><tr><td>VD LSTM, Merity et al. (2016)</td><td>20M</td><td>2</td><td>101.7</td><td>96.3</td></tr><tr><td>VD+Zoneout LSTM, Merity et al. (2016)</td><td>20M</td><td>2</td><td>108.7</td><td>100.9</td></tr><tr><td>VD LSTM, Inan et al. (2016)</td><td>22M</td><td>2</td><td>91.5</td><td>87.7</td></tr><tr><td>AWD-LSTM, Merity et al. (2017) t</td><td>33M</td><td>3</td><td>68.6</td><td>65.8</td></tr><tr><td>LSTM (tuned for PTB)</td><td></td><td>1</td><td>88.4</td><td>83.2</td></tr><tr><td>LSTM</td><td></td><td>1</td><td>72.7</td><td>69.1</td></tr><tr><td>LSTM</td><td>10M</td><td>2</td><td>73.8</td><td>70.7</td></tr><tr><td>LSTM</td><td></td><td>4</td><td>78.3</td><td>74.3</td></tr><tr><td>RHN</td><td></td><td>5</td><td>83.5</td><td>79.5</td></tr><tr><td>NAS</td><td></td><td>1</td><td>79.6</td><td>75.9</td></tr><tr><td>LSTM (tuned for PTB)</td><td></td><td>1</td><td>79.8</td><td>76.3</td></tr><tr><td>LSTM</td><td></td><td>1</td><td>69.3</td><td>65.9</td></tr><tr><td>LSTM</td><td>24M</td><td>2</td><td>69.1</td><td>65.9</td></tr><tr><td>LSTM</td><td></td><td>4</td><td>70.5</td><td>67.6</td></tr><tr><td>RHN</td><td></td><td>5</td><td>78.1</td><td>75.6</td></tr><tr><td>NAS</td><td></td><td>1</td><td>73.0</td><td>69.8</td></tr></table>
+
+Table 2: Validation and test set perplexities on Wikitext-2. All results are with shared input and output embeddings. †: parallel work.
+
+Shallow LSTMs do especially well here. Deeper models have gradually degrading perplexity, with RHNs lagging all of them by a significant margin. NAS is not quite up there with the LSTM suggesting its architecture might have overfitted to Penn Treebank, but data for deeper variants would be necessary to draw this conclusion.
+
+# 6.3 ENWIK8
+
+In contrast to the previous datasets, our numbers on this task (reported in BPC, following convetion) are slightly off the state of the art. This is most likely due to optimisation being limited to 14 epochs which is about a tenth of what the model of Zilly et al. (2016) was trained for. Nevertheless, we match their smaller RHN with our models which are very close to each other. NAS lags the other models by a surprising margin at this task.
+
+# 7 ANALYSIS
+
+On two of the three datasets, we improved previous results substantially by careful model specification and hyperparameter optimisation, but the improvement for RHNs is much smaller compared to that for LSTMs. While it cannot be ruled out that our particular setup somehow favours LSTMs, we believe it is more likely that this effect arises due to the original RHN experimental condition having been tuned more extensively (this is nearly unavoidable during model development).
+
+Naturally, NAS benefitted only to a limited degree from our tuning, since the numbers of Zoph & Le (2016) were already produced by employing similar regularisation methods and a grid search. The small edge can be attributed to the suboptimality of grid search (see Section 7.3).
+
+In summary, the three recurrent cell architectures are closely matched on all three datasets, with minuscule differences on Enwik8 where regularisation matters the least. These results support the claims of Collins et al. (2016), that capacities of various cells are very similar and their apparent differences result from trainability and regularisation. While comparing three similar architectures cannot prove this point, the inclusion of NAS certainly gives it more credence. This way we have two of the best human designed and one machine optimised cell that was the top performer among thousands of candidates.
+
+Table 3: Validation and test set BPCs on Enwik8 from the Hutter Prize dataset.   
+
+<table><tr><td>Model</td><td>Size</td><td>Depth</td><td>Valid</td><td>Test</td></tr><tr><td>Stacked LSTM, Graves (2013)</td><td>21M</td><td>7</td><td></td><td>1.67</td></tr><tr><td>Grid LSTM, Kalchbrenner et al. (2015)</td><td>17M</td><td>6</td><td></td><td>1.47</td></tr><tr><td>MI-LSTM, Wu et al. (2016)</td><td>17M</td><td>1</td><td>=</td><td>1.44</td></tr><tr><td>LN HM-LSTM, Chung et al. (2016)</td><td>35M</td><td>3</td><td></td><td>1.32</td></tr><tr><td>ByteNet, Kalchbrenner et al. (2016)</td><td>-</td><td>25</td><td></td><td>1.31</td></tr><tr><td>VD RHN, Zilly et al. (2016)</td><td>23M</td><td>5</td><td></td><td>1.31</td></tr><tr><td>VD RHN, Zilly et al. (2016)</td><td>21M</td><td>10</td><td></td><td>1.30</td></tr><tr><td>VD RHN, Zilly et al. (2016)</td><td>46M</td><td>10</td><td></td><td>1.27</td></tr><tr><td>LSTM</td><td></td><td>4</td><td>1.29</td><td>1.31</td></tr><tr><td>RHN</td><td>27M</td><td>5</td><td>1.30</td><td>1.31</td></tr><tr><td>NAS</td><td></td><td>4</td><td>1.38</td><td>1.40</td></tr><tr><td>LSTM</td><td>46M</td><td>4</td><td>1.28</td><td>1.30</td></tr><tr><td>RHN</td><td></td><td>5</td><td>1.29</td><td>1.30</td></tr><tr><td>NAS</td><td></td><td>4</td><td>1.32</td><td>1.33</td></tr></table>
+
+# 7.1 THE EFFECT OF INDIVIDUAL FEATURES
+
+Down-projection was found to be very beneficial by the tuner for some depth/budget combinations. On Penn Treebank, it improved results by about 2–5 perplexity points at depths 1 and 2 at 10M, and depth 1 at 24M, possibly by equipping the recurrent cells with more capacity. The very same models benefited from down-projection on Wikitext-2, but even more so with gaps of about 10–18 points which is readily explained by the larger vocabulary size.
+
+We further measured the contribution of other features of the models in a series of experiments. See Table 4. To limit the number of resource used, in these experiments only individual features were evaluated (not their combinations) on Penn Treebank at the best depth for each architecture (LSTM or RHN) and parameter budget (10M or 24M) as determined above.
+
+First, we untied input and output embeddings which made perplexities worse by about 6 points across the board which is consistent with the results of Inan et al. (2016).
+
+Second, without variational dropout the RHN models suffer quite a bit since there remains no dropout at all in between the layers. The deep LSTM also sees a similar loss of perplexity as having intra-layer dropout does not in itself provide enough regularisation.
+
+Third, we were also interested in how recurrent dropout (Semeniuta et al., 2016) would perform in lieu of variational dropout. Dropout masks were shared between time steps in both methods, and our results indicate no consistent advantage to either of them.
+
+# 7.2 MODEL SELECTION
+
+With a large number of hyperparameter combinations evaluated, the question of how much the tuner overfits arises. There are multiple sources of noise in play,
+
+(a) non-deterministic ordering of floating-point operations in optimised linear algebra routines, (b) different initialisation seeds, (c) the validation and test sets being finite samples from a infinite population.
+
+To assess the severity of these issues, we conducted the following experiment: models with the best hyperparameter settings for Penn Treebank and Wikitext-2 were retrained from scratch with various initialisation seeds and the validation and test scores were recorded. If during tuning, a model just got a lucky run due to a combination of (a) and (b), then retraining with the same hyperparameters but with different seeds would fail to reproduce the same good results.
+
+There are a few notable things about the results. First, in our environment (Tensorflow with a single GPU) even with the same seed as the one used by the tuner, the effect of (a) is almost as large as that of (a) and (b) combined. Second, the variance induced by (a) and (b) together is roughly equivalent to an absolute difference of 0.4 in perplexity on Penn Treebank and 0.5 on Wikitext-2.
+
+Table 4: Validation and test set perplexities on Penn Treebank for variants of our best LSTM and RHN models of two sizes.   
+
+<table><tr><td></td><td colspan="3">Size 10M</td><td colspan="3">Size 24M</td></tr><tr><td>Model</td><td>Depth</td><td>Valid</td><td>Test</td><td>Depth</td><td>Valid</td><td>Test</td></tr><tr><td>LSTM</td><td>1</td><td>61.8</td><td>59.6</td><td>4</td><td>60.9</td><td>58.3</td></tr><tr><td>- Shared Embeddings</td><td>1</td><td>67.6</td><td>65.2</td><td>4</td><td>65.6</td><td>63.2</td></tr><tr><td>- Variational Dropout</td><td>1</td><td>62.9</td><td>61.2</td><td>4</td><td>66.3</td><td>64.5</td></tr><tr><td>+ Recurrent Dropout</td><td>1</td><td>62.8</td><td>60.6</td><td>4</td><td>65.2</td><td>62.9</td></tr><tr><td>+ Untied gates</td><td>1</td><td>61.4</td><td>58.9</td><td>4</td><td>64.0</td><td>61.3</td></tr><tr><td>+ Tied gates</td><td>1</td><td>61.7</td><td>59.6</td><td>4</td><td>60.4</td><td>58.0</td></tr><tr><td>RHN</td><td>5</td><td>66.0</td><td>63.5</td><td>5</td><td>64.8</td><td>62.2</td></tr><tr><td>- Shared Embeddings</td><td>5</td><td>72.3</td><td>69.5</td><td>5</td><td>67.4</td><td>64.6</td></tr><tr><td>- Variational Dropout</td><td>5</td><td>74.4</td><td>71.7</td><td>5</td><td>74.7</td><td>71.7</td></tr><tr><td>+ Recurrent Dropout</td><td>5</td><td>65.5</td><td>63.0</td><td>5</td><td>63.4</td><td>61.0</td></tr></table>
+
+Third, the validation perplexities of the best checkpoints are about one standard deviation lower than the sample mean of the reruns, so the tuner could fit the noise only to a limited degree.
+
+Because we treat our corpora as a single sequence, test set contents are not i.i.d., and we cannot apply techniques such as the bootstrap to assess (c). Instead, we looked at the gap between validation and test scores as a proxy and observed that it is very stable, contributing variance of 0.12–0.3 perplexity to the final results on Penn Treebank and Wikitext-2, respectively.
+
+We have not explicitly dealt with the unknown uncertainty remaining in the Gaussian Process that may affect model comparisons, apart from running it until apparent convergence. All in all, our findings suggest that a gap in perplexity of 1.0 is a statistically robust difference between models trained in this way on these datasets. The distribution of results was approximately normal with roughly the same variance for all models, so we still report numbers in a tabular form instead of plotting the distribution of results, for example in a violin plot (Hintze & Nelson, 1998).
+
+# 7.3 SENSITIVITY
+
+To further verify that the best hyperparameter setting found by the tuner is not a fluke, we plotted the validation loss against the hyperparameter settings. Fig. 2 shows one such typical plot, for a 4-layer LSTM. We manually restricted the ranges around the best hyperparameter values to around $1 5 - 2 5 \%$ of the entire tuneable range, and observed that the vast majority of settings in that neighbourhood produced perplexities within 3.0 of the best value. Widening the ranges further leads to quickly deteriorating results.
+
+Satisfied that the hyperparameter surface is well behaved, we considered whether the same results could have possibly been achieved with a simple grid search. Omitting input embedding ratio because the tuner found having a down-projection suboptimal almost non-conditionally for this 4-layer LSTM, there remain six hyperparameters to tune. If there were 5 possible values on the grid for each hyperparameter (with one value in every $20 \%$ interval), then we would need $6 ^ { 5 }$ , nearly 8000 trials to get within 3.0 of the best perplexity achieved by the tuner in about 1500 trials.
+
+# 7.4 TYING LSTM GATES
+
+Normally, LSTMs have two independent gates controlling the retention of cell state and the admission of updates (Eq. 1). A minor variant which reduces the number of parameters at the loss of some flexibility is to tie the input and forget gates as in Eq. 2. A possible middle ground that keeps the number of parameters the same but ensures that values of the cell state $c$ remain in $[ - 1 , 1 ]$ is to cap
+
+![](images/eb7379d157cdc01f200e679d713c2374479d6c1a24ea6a64991bd147e3141cc8.jpg)  
+Figure 2: Average per-word negative log-likelihoods of hyperparameter combinations in the neighbourhood of the best solution for a 4-layer LSTM with 24M weights on the Penn Treebank dataset.
+
+the input gate as in Eq. 3.
+
+$$
+\begin{array} { r l } & { \mathbf { c } _ { t } = \mathbf { f } _ { t } \odot \mathbf { c } _ { t - 1 } + \mathbf { i } _ { t } \odot \mathbf { j } _ { t } } \\ & { \mathbf { c } _ { t } = \mathbf { f } _ { t } \odot \mathbf { c } _ { t - 1 } + \left( 1 - \mathbf { f } _ { t } \right) \odot \mathbf { j } _ { t } } \\ & { \mathbf { c } _ { t } = \mathbf { f } _ { t } \odot \mathbf { c } _ { t - 1 } + \operatorname* { m i n } ( 1 - \mathbf { f } _ { t } , \mathbf { i } _ { t } ) \odot \mathbf { j } _ { t } } \end{array}
+$$
+
+Where the equations are based on the formulation of Sak et al. (2014). All LSTM models in this paper use the third variant, except those titled “Untied gates” and “Tied gates” in Table 4 corresponding to Eq. 1 and 2, respectively.
+
+The results show that LSTMs are insensitive to these changes and the results vary only slightly even though more hidden units are allocated to the tied version to fill its parameter budget. Finally, the numbers suggest that deep LSTMs benefit from bounded cell states.
+
+# 8 CONCLUSION
+
+During the transitional period when deep neural language models began to supplant their shallower predecessors, effect sizes tended to be large, and robust conclusions about the value of the modelling innovations could be made, even in the presence of poorly controlled “hyperparameter noise.” However, now that the neural revolution is in full swing, researchers must often compare competing deep architectures. In this regime, effect sizes tend to be much smaller, and more methodological care is required to produce reliable results. Furthermore, with so much work carried out in parallel by a growing research community, the costs of faulty conclusions are increased.
+
+Although we can draw attention to this problem, this paper does not offer a practical methodological solution beyond establishing reliable baselines that can be the benchmarks for subsequent work. Still, we demonstrate how, with a huge amount of computation, noise levels of various origins can be carefully estimated and models meaningfully compared. This apparent tradeoff between the amount of computation and the reliability of results seems to lie at the heart of the matter. Solutions to the methodological challenges must therefore make model evaluation cheaper by, for instance, reducing the number of hyperparameters and the sensitivity of models to them, employing better hyperparameter optimisation strategies, or by defining “leagues” with predefined computational budgets for a single model representing different points on the tradeoff curve.
+
+# REFERENCES
+
+Junyoung Chung, Sungjin Ahn, and Yoshua Bengio. Hierarchical multiscale recurrent neural networks. CoRR, abs/1609.01704, 2016. URL http://arxiv.org/abs/1609.01704.
+
+Jasmine Collins, Jascha Sohl-Dickstein, and David Sussillo. Capacity and trainability in recurrent neural networks. arXiv preprint arXiv:1611.09913, 2016.
+
+Thomas Desautels, Andreas Krause, and Joel W. Burdick. Parallelizing exploration-exploitation tradeoffs in Gaussian process bandit optimization. Journal of Machine Learning Research, 15: 4053–4103, 2014. URL http://jmlr.org/papers/v15/desautels14a.html.
+
+Yarin Gal and Zoubin Ghahramani. A theoretically grounded application of dropout in recurrent neural networks. In Advances in Neural Information Processing Systems, pp. 1019–1027, 2016.
+
+Daniel Golovin, Benjamin Solnik, Subhodeep Moitra, Greg Kochanski, John Karro, and D Sculley. Google vizier: A service for black-box optimization. In Proceedings of the 23rd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, pp. 1487–1495. ACM, 2017.
+
+Edouard Grave, Armand Joulin, and Nicolas Usunier. Improving neural language models with a continuous cache. CoRR, abs/1612.04426, 2016. URL http://arxiv.org/abs/1612. 04426.
+
+Alex Graves. Generating sequences with recurrent neural networks. CoRR, abs/1308.0850, 2013. URL http://arxiv.org/abs/1308.0850.
+
+Peter Henderson, Riashat Islam, Philip Bachman, Joelle Pineau, Doina Precup, and David Meger. Deep reinforcement learning that matters. arXiv preprint arXiv:1709.06560, 2017.
+
+Jerry L Hintze and Ray D Nelson. Violin plots: a box plot-density trace synergism. The American Statistician, 52(2):181–184, 1998.
+
+Sepp Hochreiter and Jurgen Schmidhuber. Long Short-Term Memory. ¨ Neural Computation, 9 (8):1735–1780, November 1997. ISSN 0899-7667. doi: 10.1162/neco.1997.9.8.1735. URL http://dx.doi.org/10.1162/neco.1997.9.8.1735.
+
+Marcus Hutter. The human knowledge compression contest. 2012.
+
+Hakan Inan, Khashayar Khosravi, and Richard Socher. Tying word vectors and word classifiers: A loss framework for language modeling. CoRR, abs/1611.01462, 2016. URL http://arxiv. org/abs/1611.01462.
+
+Nal Kalchbrenner, Ivo Danihelka, and Alex Graves. Grid long short-term memory. CoRR, abs/1507.01526, 2015. URL http://arxiv.org/abs/1507.01526.
+
+Nal Kalchbrenner, Lasse Espeholt, Karen Simonyan, Aaron van den Oord, Alex Graves, and Koray ¨ Kavukcuoglu. Neural machine translation in linear time. CoRR, abs/1610.10099, 2016. URL http://arxiv.org/abs/1610.10099.
+
+Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
+
+Ben Krause, Emmanuel Kahembwe, Iain Murray, and Steve Renals. Dynamic evaluation of neural sequence models. arXiv preprint arXiv:1709.07432, 2017.
+
+Mitchell P Marcus, Mary Ann Marcinkiewicz, and Beatrice Santorini. Building a large annotated corpus of english: The Penn treebank. Computational linguistics, 19(2):313–330, 1993.
+
+Stephen Merity, Caiming Xiong, James Bradbury, and Richard Socher. Pointer sentinel mixture models. CoRR, abs/1609.07843, 2016. URL http://arxiv.org/abs/1609.07843.
+
+Stephen Merity, Nitish Shirish Keskar, and Richard Socher. Regularizing and optimizing LSTM language models. CoRR, abs/1708.02182, 2017. URL http://arxiv.org/abs/1708. 02182.
+
+Tomas Mikolov, Martin Karafiat, Lukas Burget, Jan Cernock ´ y, and Sanjeev Khudanpur. Recurrent\` neural network based language model. In Interspeech, volume 2, pp. 3, 2010.
+
+Ofir Press and Lior Wolf. Using the output embedding to improve language models. CoRR, abs/1608.05859, 2016. URL http://arxiv.org/abs/1608.05859.
+
+Nils Reimers and Iryna Gurevych. Reporting score distributions makes a difference: Performance study of lstm-networks for sequence tagging. CoRR, abs/1707.09861, 2017. URL http:// arxiv.org/abs/1707.09861.
+
+Hasim Sak, Andrew W. Senior, and Franc¸oise Beaufays. Long short-term memory based recurrent neural network architectures for large vocabulary speech recognition. CoRR, abs/1402.1128, 2014. URL http://arxiv.org/abs/1402.1128.
+
+Stanislau Semeniuta, Aliaksei Severyn, and Erhardt Barth. Recurrent dropout without memory loss. CoRR, abs/1603.05118, 2016. URL http://arxiv.org/abs/1603.05118.
+
+Yuhuai Wu, Saizheng Zhang, Ying Zhang, Yoshua Bengio, and Ruslan Salakhutdinov. On multiplicative integration with recurrent neural networks. CoRR, abs/1606.06630, 2016. URL http://arxiv.org/abs/1606.06630.
+
+Wojciech Zaremba, Ilya Sutskever, and Oriol Vinyals. Recurrent neural network regularization. CoRR, abs/1409.2329, 2014. URL http://arxiv.org/abs/1409.2329.
+
+Julian G. Zilly, Rupesh Kumar Srivastava, Jan Koutn´ık, and Jurgen Schmidhuber. Recurrent ¨ highway networks. CoRR, abs/1607.03474, 2016. URL http://arxiv.org/abs/1607. 03474.
+
+Barret Zoph and Quoc V Le. Neural architecture search with reinforcement learning. arXiv preprint arXiv:1611.01578, 2016.

parse/train/ByJHuTgA-/ByJHuTgA-_content_list.json

@@ -0,0 +1,1229 @@
+[
+    {
+        "type": "text",
+        "text": "ON THE STATE OF THE ART OF EVALUATION IN NEURAL LANGUAGE MODELS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            738,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Gabor Melis´ †, Chris Dyer†, Phil Blunsom†‡   \n{melisgl,cdyer,pblunsom}@google.com   \n†DeepMind   \n‡University of Oxford ",
+        "bbox": [
+            184,
+            169,
+            526,
+            228
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            265,
+            544,
+            280
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Ongoing innovations in recurrent neural network architectures have provided a steady influx of apparently state-of-the-art results on language modelling benchmarks. However, these have been evaluated using differing codebases and limited computational resources, which represent uncontrolled sources of experimental variation. We reevaluate several popular architectures and regularisation methods with large-scale automatic black-box hyperparameter tuning and arrive at the somewhat surprising conclusion that standard LSTM architectures, when properly regularised, outperform more recent models. We establish a new state of the art on the Penn Treebank and Wikitext-2 corpora, as well as strong baselines on the Hutter Prize dataset. ",
+        "bbox": [
+            233,
+            300,
+            764,
+            439
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            477,
+            336,
+            493
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The scientific process by which the deep learning research community operates is guided by empirical studies that evaluate the relative quality of models. Complicating matters, the measured performance of a model depends not only on its architecture (and data), but it can strongly depend on hyperparameter values that affect learning, regularisation, and capacity. This hyperparameter dependence is an often inadequately controlled source of variation in experiments, which creates a risk that empirically unsound claims will be reported. ",
+        "bbox": [
+            174,
+            513,
+            825,
+            597
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we use a black-box hyperparameter optimisation technique to control for hyperparameter effects while comparing the relative performance of language modelling architectures based on LSTMs, Recurrent Highway Networks (Zilly et al., 2016) and NAS (Zoph & Le, 2016). We specify flexible, parameterised model families with the ability to adjust embedding and recurrent cell sizes for a given parameter budget and with fine grain control over regularisation and learning hyperparameters. ",
+        "bbox": [
+            174,
+            603,
+            823,
+            688
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Once hyperparameters have been properly controlled for, we find that LSTMs outperform the more recent models, contra the published claims. Our result is therefore a demonstration that replication failures can happen due to poorly controlled hyperparameter variation, and this paper joins other recent papers in warning of the under-acknowledged existence of replication failure in deep learning (Henderson et al., 2017; Reimers & Gurevych, 2017). However, we do show that careful controls are possible, albeit at considerable computational cost. ",
+        "bbox": [
+            174,
+            694,
+            823,
+            777
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Several remarks can be made in light of these results. First, as (conditional) language models serve as the central building block of many tasks, including machine translation, there is little reason to expect that the problem of unreliable evaluation is unique to the tasks discussed here. However, in machine translation, carefully controlling for hyperparameter effects would be substantially more expensive because standard datasets are much larger. Second, the research community should strive for more consensus about appropriate experimental methodology that balances costs of careful experimentation with the risks associated with false claims. Finally, more attention should be paid to hyperparameter sensitivity. Models that introduce many new hyperparameters or which perform well only in narrow ranges of hyperparameter settings should be identified as such as part of standard publication practice. ",
+        "bbox": [
+            174,
+            785,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/f81bf295401ea1f5d33b190a8279a379b919f6538c1f3652283719438ad90409.jpg",
+        "image_caption": [
+            "Figure 1: Recurrent networks with optional down-projection (trapezoids), per-step and per-sequence dropout (dashed and solid lines). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            186,
+            106,
+            812,
+            272
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 MODELS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            344,
+            279,
+            361
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our focus is on three recurrent architectures: ",
+        "bbox": [
+            174,
+            383,
+            467,
+            398
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• The Long Short-Term Memory (Hochreiter & Schmidhuber, 1997) serves as a well known and frequently used baseline.   \n• The recently proposed Recurrent Highway Network (Zilly et al., 2016) is chosen because it has demonstrated state-of-the-art performance on a number of datasets.   \n• Finally, we also include NAS (Zoph & Le, 2016), because of its impressive performance and because its architecture was the result of an automated reinforcement learning based optimisation process. ",
+        "bbox": [
+            212,
+            415,
+            825,
+            544
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our aim is strictly to do better model comparisons for these architectures and we thus refrain from including techniques that are known to push perplexities even lower, but which are believed to be largely orthogonal to the question of the relative merits of these recurrent cells. In parallel work with a remarkable overlap with ours, Merity et al. (2017) demonstrate the utility of adding a Neural Cache (Grave et al., 2016). Building on their work, Krause et al. (2017) show that Dynamic Evaluation (Graves, 2013) contributes similarly to the final perplexity. ",
+        "bbox": [
+            174,
+            560,
+            825,
+            645
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "As pictured in Fig. 1a, our models with LSTM or NAS cells have all the standard components: an input embedding lookup table, recurrent cells stacked as layers with additive skip connections combining outputs of all layers to ease optimisation. There is an optional down-projection whose presence is governed by a hyperparameter from this combined output to a smaller space which reduces the number of output embedding parameters. Unless otherwise noted, input and output embeddings are shared, see (Inan et al., 2016) and (Press & Wolf, 2016). ",
+        "bbox": [
+            174,
+            651,
+            825,
+            734
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Dropout is applied to feedforward connections denoted by dashed arrows in the figure. From the bottom up: to embedded inputs (input dropout), to connections between layers (intra-layer dropout), to the combined and the down-projected outputs (output dropout). All these dropouts have random masks drawn independently per time step, in contrast to the dropout on recurrent states where the same mask is used for all time steps in the sequence. ",
+        "bbox": [
+            174,
+            742,
+            825,
+            811
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "RHN based models are typically conceived of as a single horizontal “highway” to emphasise how the recurrent state is processed through time. In Fig. 1b, we choose to draw their schema in a way that makes the differences from LSTMs immediately apparent. In a nutshell, the RHN state is passed from the topmost layer to the lowest layer of the next time step. In contrast, each LSTM layer has its own recurrent connection and state. ",
+        "bbox": [
+            174,
+            818,
+            823,
+            888
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The same dropout variants are applied to all three model types, with the exception of intra-layer dropout which does not apply to RHNs since only the recurrent state is passed between the layers. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "For the recurrent states, all architectures use either variational dropout (Gal & Ghahramani, 2016, state dropout)1 or recurrent dropout (Semeniuta et al., 2016), unless explicitly noted otherwise. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 EXPERIMENTAL SETUP ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            152,
+            398,
+            170
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 DATASETS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            184,
+            287,
+            199
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We compare models on three datasets. The smallest of them is the Penn Treebank corpus by Marcus et al. (1993) with preprocessing from Mikolov et al. (2010). We also include another word level corpus: Wikitext-2 by Merity et al. (2016). It is about twice the size of Penn Treebank with a larger vocabulary and much lighter preprocessing. The third corpus is Enwik8 from the Hutter Prize dataset (Hutter, 2012). Following common practice, we use the first 90 million characters for training, and the remaining 10 million evenly split between validation and test. ",
+        "bbox": [
+            174,
+            210,
+            825,
+            295
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "4 TRAINING DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            316,
+            367,
+            332
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "When training word level models we follow common practice and use a batch size of 64, truncated backpropagation with 35 time steps, and we feed the final states from the previous batch as the initial state of the subsequent one. At the beginning of training and test time, the model starts with a zero state. To bias the model towards being able to easily start from such a state at test time, during training, with probability 0.01 a constant zero state is provided as the initial state. ",
+        "bbox": [
+            174,
+            348,
+            825,
+            417
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Optimisation is performed by Adam (Kingma & Ba, 2014) with $\\beta _ { 1 } ~ = ~ 0$ but otherwise default parameters $( \\beta _ { 2 } ~ = ~ 0 . 9 9 9$ , $\\epsilon { \\bf \\bar { \\alpha } } = 1 0 ^ { - 9 } $ ). Setting $\\beta _ { 1 }$ so turns off the exponential moving average for the estimates of the means of the gradients and brings Adam very close to RMSProp without momentum, but due to Adam’s bias correction, larger learning rates can be used. ",
+        "bbox": [
+            174,
+            424,
+            825,
+            481
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Batch size is set to 64. The learning rate is multiplied by 0.1 whenever validation performance does not improve ever during 30 consecutive checkpoints. These checkpoints are performed after every 100 and 200 optimization steps for Penn Treebank and Wikitext-2, respectively. ",
+        "bbox": [
+            174,
+            488,
+            823,
+            530
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "For character level models (i.e. Enwik8), the differences are: truncated backpropagation is performed with 50 time steps. Adam’s parameters are $\\beta _ { 2 } ~ = ~ 0 . 9 9$ , $\\epsilon = 1 0 ^ { - 5 }$ . Batch size is 128. Checkpoints are only every 400 optimisation steps and embeddings are not shared. ",
+        "bbox": [
+            176,
+            536,
+            823,
+            579
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "5 EVALUATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            601,
+            315,
+            616
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "For evaluation, the checkpoint with the best validation perplexity found by the tuner is loaded and the model is applied to the test set with a batch size of 1. For the word based datasets, using the training batch size makes results worse by $0 . 3 \\ : \\mathrm { P P L }$ while Enwik8 is practically unaffected due to its evaluation and training sets being much larger. Preliminary experiments indicate that MC averaging would bring a small improvement of about 0.4 in perplexity and 0.005 in bits per character, similar to the results of Gal & Ghahramani (2016), while being a 1000 times more expensive which is prohibitive on larger datasets. Therefore, throughout we use the mean-field approximation for dropout at test time. ",
+        "bbox": [
+            174,
+            632,
+            825,
+            743
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "5.1 HYPERPARAMETER TUNING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            761,
+            408,
+            776
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Hyperparameters are optimised by Google Vizier (Golovin et al., 2017), a black-box hyperparameter tuner based on batched GP bandits using the expected improvement acquisition function (Desautels et al., 2014). Tuners of this nature are generally more efficient than grid search when the number of hyperparameters is small. To keep the problem tractable, we restrict the set of hyperparameters to learning rate, input embedding ratio, input dropout, state dropout, output dropout, weight decay. For deep LSTMs, there is an extra hyperparameter to tune: intra-layer dropout. Even with this small set, thousands of evaluations are required to reach convergence. ",
+        "bbox": [
+            174,
+            787,
+            825,
+            886
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "table",
+        "img_path": "images/eb27a749bafbd9e099f54de030d1cde2859b97fb13d106358e065c6e094c20bc.jpg",
+        "table_caption": [
+            "Table 1: Validation and test set perplexities on Penn Treebank for models with different numbers of parameters and depths. All results except those from Zaremba are with shared input and output embeddings. VD stands for Variational Dropout from Gal & Ghahramani (2016). †: parallel work. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Size</td><td>Depth</td><td>Valid</td><td>Test</td></tr><tr><td>Medium LSTM, Zaremba et al. (2014)</td><td>10M</td><td>2</td><td>86.2</td><td>82.7</td></tr><tr><td>Large LSTM, Zaremba et al. (2014)</td><td>24M</td><td>2</td><td>82.2</td><td>78.4</td></tr><tr><td>VD LSTM,Press &amp; Wolf (2016)</td><td>51M</td><td>2</td><td>75.8</td><td>73.2</td></tr><tr><td>VD LSTM, Inan et al. (2016)</td><td>9M</td><td>2</td><td>77.1</td><td>73.9</td></tr><tr><td>VD LSTM, Inan et al. (2016)</td><td>28M</td><td>2</td><td>72.5</td><td>69.0</td></tr><tr><td>VD RHN, Zilly et al. (2016)</td><td>24M</td><td>10</td><td>67.9</td><td>65.4</td></tr><tr><td>NAS, Zoph &amp; Le (2016)</td><td>25M</td><td>-</td><td></td><td>64.0</td></tr><tr><td>NAS, Zoph &amp; Le (2016)</td><td>54M</td><td>1</td><td>=</td><td>62.4</td></tr><tr><td>AWD-LSTM, Merity et al. (2017) +</td><td>24M</td><td>3</td><td>60.0</td><td>57.3</td></tr><tr><td>LSTM</td><td rowspan=\"6\">10M</td><td>1</td><td>61.8</td><td>59.6</td></tr><tr><td>LSTM</td><td>2</td><td>63.0</td><td>60.8</td></tr><tr><td>LSTM</td><td>4</td><td>62.4</td><td>60.1</td></tr><tr><td>RHN</td><td>5</td><td>66.0</td><td>63.5</td></tr><tr><td>NAS</td><td>1</td><td>65.6</td><td>62.7</td></tr><tr><td>LSTM</td><td>1</td><td>61.4</td><td>59.5</td></tr><tr><td>LSTM</td><td></td><td></td><td>62.1</td><td>59.6</td></tr><tr><td>LSTM</td><td>24M</td><td>2 4</td><td>60.9</td><td>58.3</td></tr><tr><td>RHN</td><td></td><td>5</td><td>64.8</td><td>62.2</td></tr><tr><td>NAS</td><td></td><td>1</td><td>62.1</td><td>59.7</td></tr></table>",
+        "bbox": [
+            282,
+            101,
+            715,
+            385
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Parameter budget. Motivated by recent results from Collins et al. (2016), we compare models on the basis of the total number of trainable parameters as opposed to the number of hidden units. The tuner is given control over the presence and size of the down-projection, and thus over the tradeoff between the number of embedding vs. recurrent cell parameters. Consequently, the cells’ hidden size and the embedding size is determined by the actual parameter budget, depth and the input embedding ratio hyperparameter. ",
+        "bbox": [
+            174,
+            464,
+            825,
+            549
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For Enwik8 there are relatively few parameters in the embeddings since the vocabulary size is only 205. Here we choose not to share embeddings and to omit the down-projection unconditionally. ",
+        "bbox": [
+            173,
+            555,
+            823,
+            583
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "6 RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            608,
+            281,
+            625
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "6.1 PENN TREEBANK ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            643,
+            334,
+            657
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We tested LSTMs of various depths and an RHN of depth 5 with parameter budgets of 10 and 24 million matching the sizes of the Medium and Large LSTMs by (Zaremba et al., 2014). The results are summarised in Table 1. ",
+        "bbox": [
+            176,
+            671,
+            823,
+            713
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Notably, in our experiments even the RHN with only 10M parameters has better perplexity than the 24M one in the original publication. Our 24M version improves on that further. However, a shallow LSTM-based model with only 10M parameters enjoys a very comfortable margin over that, with deeper models following near the estimated noise range. At 24M, all depths obtain very similar results, reaching 58.3 at depth 4. Unsurprisingly, NAS whose architecture was chosen based on its performance on this dataset does almost equally well, even better than in Zoph & Le (2016). ",
+        "bbox": [
+            174,
+            720,
+            825,
+            804
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "6.2 WIKITEXT-2 ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            825,
+            302,
+            840
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Wikitext-2 is not much larger than Penn Treebank, so it is not surprising that even models tuned for Penn Treebank perform reasonably on this dataset, and this is in fact how results in previous works were produced. For a fairer comparison, we also tune hyperparameters on the same dataset. In Table 2, we report numbers for both approaches. All our results are well below the previous state of the are for models without dynamic evaluation or caching. That said, our best result, 65.9 compares favourably even to the Neural Cache (Grave et al., 2016) whose innovations are fairly orthogonal to the base model. ",
+        "bbox": [
+            174,
+            854,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/93f3c34b3bc34722c4c2660b142dc57c58a490e22130bd03e4c8b0c5ff60aa36.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Table 2: Validation and test set perplexities on Wikitext-2. All results are with shared input and output embeddings. †: parallel work. "
+        ],
+        "table_body": "<table><tr><td>Model</td><td>Size</td><td>Depth</td><td>Valid</td><td>Test</td></tr><tr><td>VD LSTM, Merity et al. (2016)</td><td>20M</td><td>2</td><td>101.7</td><td>96.3</td></tr><tr><td>VD+Zoneout LSTM, Merity et al. (2016)</td><td>20M</td><td>2</td><td>108.7</td><td>100.9</td></tr><tr><td>VD LSTM, Inan et al. (2016)</td><td>22M</td><td>2</td><td>91.5</td><td>87.7</td></tr><tr><td>AWD-LSTM, Merity et al. (2017) t</td><td>33M</td><td>3</td><td>68.6</td><td>65.8</td></tr><tr><td>LSTM (tuned for PTB)</td><td></td><td>1</td><td>88.4</td><td>83.2</td></tr><tr><td>LSTM</td><td></td><td>1</td><td>72.7</td><td>69.1</td></tr><tr><td>LSTM</td><td>10M</td><td>2</td><td>73.8</td><td>70.7</td></tr><tr><td>LSTM</td><td></td><td>4</td><td>78.3</td><td>74.3</td></tr><tr><td>RHN</td><td></td><td>5</td><td>83.5</td><td>79.5</td></tr><tr><td>NAS</td><td></td><td>1</td><td>79.6</td><td>75.9</td></tr><tr><td>LSTM (tuned for PTB)</td><td></td><td>1</td><td>79.8</td><td>76.3</td></tr><tr><td>LSTM</td><td></td><td>1</td><td>69.3</td><td>65.9</td></tr><tr><td>LSTM</td><td>24M</td><td>2</td><td>69.1</td><td>65.9</td></tr><tr><td>LSTM</td><td></td><td>4</td><td>70.5</td><td>67.6</td></tr><tr><td>RHN</td><td></td><td>5</td><td>78.1</td><td>75.6</td></tr><tr><td>NAS</td><td></td><td>1</td><td>73.0</td><td>69.8</td></tr></table>",
+        "bbox": [
+            269,
+            101,
+            727,
+            347
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            417,
+            823,
+            445
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Shallow LSTMs do especially well here. Deeper models have gradually degrading perplexity, with RHNs lagging all of them by a significant margin. NAS is not quite up there with the LSTM suggesting its architecture might have overfitted to Penn Treebank, but data for deeper variants would be necessary to draw this conclusion. ",
+        "bbox": [
+            174,
+            453,
+            825,
+            508
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "6.3 ENWIK8 ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            535,
+            272,
+            549
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In contrast to the previous datasets, our numbers on this task (reported in BPC, following convetion) are slightly off the state of the art. This is most likely due to optimisation being limited to 14 epochs which is about a tenth of what the model of Zilly et al. (2016) was trained for. Nevertheless, we match their smaller RHN with our models which are very close to each other. NAS lags the other models by a surprising margin at this task. ",
+        "bbox": [
+            174,
+            564,
+            825,
+            635
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "7 ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            664,
+            290,
+            679
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "On two of the three datasets, we improved previous results substantially by careful model specification and hyperparameter optimisation, but the improvement for RHNs is much smaller compared to that for LSTMs. While it cannot be ruled out that our particular setup somehow favours LSTMs, we believe it is more likely that this effect arises due to the original RHN experimental condition having been tuned more extensively (this is nearly unavoidable during model development). ",
+        "bbox": [
+            174,
+            700,
+            825,
+            770
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Naturally, NAS benefitted only to a limited degree from our tuning, since the numbers of Zoph & Le (2016) were already produced by employing similar regularisation methods and a grid search. The small edge can be attributed to the suboptimality of grid search (see Section 7.3). ",
+        "bbox": [
+            174,
+            777,
+            821,
+            819
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In summary, the three recurrent cell architectures are closely matched on all three datasets, with minuscule differences on Enwik8 where regularisation matters the least. These results support the claims of Collins et al. (2016), that capacities of various cells are very similar and their apparent differences result from trainability and regularisation. While comparing three similar architectures cannot prove this point, the inclusion of NAS certainly gives it more credence. This way we have two of the best human designed and one machine optimised cell that was the top performer among thousands of candidates. ",
+        "bbox": [
+            174,
+            825,
+            825,
+            922
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/b00fb7be680cc3306daa277f84c3df8088ca5bf20affe653796613a50d530274.jpg",
+        "table_caption": [
+            "Table 3: Validation and test set BPCs on Enwik8 from the Hutter Prize dataset. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Size</td><td>Depth</td><td>Valid</td><td>Test</td></tr><tr><td>Stacked LSTM, Graves (2013)</td><td>21M</td><td>7</td><td></td><td>1.67</td></tr><tr><td>Grid LSTM, Kalchbrenner et al. (2015)</td><td>17M</td><td>6</td><td></td><td>1.47</td></tr><tr><td>MI-LSTM, Wu et al. (2016)</td><td>17M</td><td>1</td><td>=</td><td>1.44</td></tr><tr><td>LN HM-LSTM, Chung et al. (2016)</td><td>35M</td><td>3</td><td></td><td>1.32</td></tr><tr><td>ByteNet, Kalchbrenner et al. (2016)</td><td>-</td><td>25</td><td></td><td>1.31</td></tr><tr><td>VD RHN, Zilly et al. (2016)</td><td>23M</td><td>5</td><td></td><td>1.31</td></tr><tr><td>VD RHN, Zilly et al. (2016)</td><td>21M</td><td>10</td><td></td><td>1.30</td></tr><tr><td>VD RHN, Zilly et al. (2016)</td><td>46M</td><td>10</td><td></td><td>1.27</td></tr><tr><td>LSTM</td><td></td><td>4</td><td>1.29</td><td>1.31</td></tr><tr><td>RHN</td><td>27M</td><td>5</td><td>1.30</td><td>1.31</td></tr><tr><td>NAS</td><td></td><td>4</td><td>1.38</td><td>1.40</td></tr><tr><td>LSTM</td><td>46M</td><td>4</td><td>1.28</td><td>1.30</td></tr><tr><td>RHN</td><td></td><td>5</td><td>1.29</td><td>1.30</td></tr><tr><td>NAS</td><td></td><td>4</td><td>1.32</td><td>1.33</td></tr></table>",
+        "bbox": [
+            281,
+            101,
+            717,
+            321
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "7.1 THE EFFECT OF INDIVIDUAL FEATURES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            371,
+            491,
+            386
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Down-projection was found to be very beneficial by the tuner for some depth/budget combinations. On Penn Treebank, it improved results by about 2–5 perplexity points at depths 1 and 2 at 10M, and depth 1 at 24M, possibly by equipping the recurrent cells with more capacity. The very same models benefited from down-projection on Wikitext-2, but even more so with gaps of about 10–18 points which is readily explained by the larger vocabulary size. ",
+        "bbox": [
+            174,
+            397,
+            825,
+            468
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We further measured the contribution of other features of the models in a series of experiments. See Table 4. To limit the number of resource used, in these experiments only individual features were evaluated (not their combinations) on Penn Treebank at the best depth for each architecture (LSTM or RHN) and parameter budget (10M or 24M) as determined above. ",
+        "bbox": [
+            174,
+            474,
+            825,
+            530
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "First, we untied input and output embeddings which made perplexities worse by about 6 points across the board which is consistent with the results of Inan et al. (2016). ",
+        "bbox": [
+            176,
+            537,
+            823,
+            565
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Second, without variational dropout the RHN models suffer quite a bit since there remains no dropout at all in between the layers. The deep LSTM also sees a similar loss of perplexity as having intra-layer dropout does not in itself provide enough regularisation. ",
+        "bbox": [
+            174,
+            571,
+            825,
+            614
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Third, we were also interested in how recurrent dropout (Semeniuta et al., 2016) would perform in lieu of variational dropout. Dropout masks were shared between time steps in both methods, and our results indicate no consistent advantage to either of them. ",
+        "bbox": [
+            174,
+            621,
+            825,
+            664
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "7.2 MODEL SELECTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            680,
+            352,
+            695
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "With a large number of hyperparameter combinations evaluated, the question of how much the tuner overfits arises. There are multiple sources of noise in play, ",
+        "bbox": [
+            174,
+            707,
+            823,
+            736
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "(a) non-deterministic ordering of floating-point operations in optimised linear algebra routines, (b) different initialisation seeds, (c) the validation and test sets being finite samples from a infinite population. ",
+        "bbox": [
+            204,
+            741,
+            823,
+            785
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To assess the severity of these issues, we conducted the following experiment: models with the best hyperparameter settings for Penn Treebank and Wikitext-2 were retrained from scratch with various initialisation seeds and the validation and test scores were recorded. If during tuning, a model just got a lucky run due to a combination of (a) and (b), then retraining with the same hyperparameters but with different seeds would fail to reproduce the same good results. ",
+        "bbox": [
+            174,
+            791,
+            825,
+            861
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "There are a few notable things about the results. First, in our environment (Tensorflow with a single GPU) even with the same seed as the one used by the tuner, the effect of (a) is almost as large as that of (a) and (b) combined. Second, the variance induced by (a) and (b) together is roughly equivalent to an absolute difference of 0.4 in perplexity on Penn Treebank and 0.5 on Wikitext-2. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/322d02964532e07888616d7b6b9dcd7d59c272da43824f2945c5f97e87d29136.jpg",
+        "table_caption": [
+            "Table 4: Validation and test set perplexities on Penn Treebank for variants of our best LSTM and RHN models of two sizes. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"3\">Size 10M</td><td colspan=\"3\">Size 24M</td></tr><tr><td>Model</td><td>Depth</td><td>Valid</td><td>Test</td><td>Depth</td><td>Valid</td><td>Test</td></tr><tr><td>LSTM</td><td>1</td><td>61.8</td><td>59.6</td><td>4</td><td>60.9</td><td>58.3</td></tr><tr><td>- Shared Embeddings</td><td>1</td><td>67.6</td><td>65.2</td><td>4</td><td>65.6</td><td>63.2</td></tr><tr><td>- Variational Dropout</td><td>1</td><td>62.9</td><td>61.2</td><td>4</td><td>66.3</td><td>64.5</td></tr><tr><td>+ Recurrent Dropout</td><td>1</td><td>62.8</td><td>60.6</td><td>4</td><td>65.2</td><td>62.9</td></tr><tr><td>+ Untied gates</td><td>1</td><td>61.4</td><td>58.9</td><td>4</td><td>64.0</td><td>61.3</td></tr><tr><td>+ Tied gates</td><td>1</td><td>61.7</td><td>59.6</td><td>4</td><td>60.4</td><td>58.0</td></tr><tr><td>RHN</td><td>5</td><td>66.0</td><td>63.5</td><td>5</td><td>64.8</td><td>62.2</td></tr><tr><td>- Shared Embeddings</td><td>5</td><td>72.3</td><td>69.5</td><td>5</td><td>67.4</td><td>64.6</td></tr><tr><td>- Variational Dropout</td><td>5</td><td>74.4</td><td>71.7</td><td>5</td><td>74.7</td><td>71.7</td></tr><tr><td>+ Recurrent Dropout</td><td>5</td><td>65.5</td><td>63.0</td><td>5</td><td>63.4</td><td>61.0</td></tr></table>",
+        "bbox": [
+            281,
+            99,
+            717,
+            299
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Third, the validation perplexities of the best checkpoints are about one standard deviation lower than the sample mean of the reruns, so the tuner could fit the noise only to a limited degree. ",
+        "bbox": [
+            173,
+            377,
+            821,
+            406
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Because we treat our corpora as a single sequence, test set contents are not i.i.d., and we cannot apply techniques such as the bootstrap to assess (c). Instead, we looked at the gap between validation and test scores as a proxy and observed that it is very stable, contributing variance of 0.12–0.3 perplexity to the final results on Penn Treebank and Wikitext-2, respectively. ",
+        "bbox": [
+            174,
+            412,
+            825,
+            468
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We have not explicitly dealt with the unknown uncertainty remaining in the Gaussian Process that may affect model comparisons, apart from running it until apparent convergence. All in all, our findings suggest that a gap in perplexity of 1.0 is a statistically robust difference between models trained in this way on these datasets. The distribution of results was approximately normal with roughly the same variance for all models, so we still report numbers in a tabular form instead of plotting the distribution of results, for example in a violin plot (Hintze & Nelson, 1998). ",
+        "bbox": [
+            174,
+            476,
+            825,
+            560
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "7.3 SENSITIVITY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            593,
+            303,
+            608
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To further verify that the best hyperparameter setting found by the tuner is not a fluke, we plotted the validation loss against the hyperparameter settings. Fig. 2 shows one such typical plot, for a 4-layer LSTM. We manually restricted the ranges around the best hyperparameter values to around $1 5 - 2 5 \\%$ of the entire tuneable range, and observed that the vast majority of settings in that neighbourhood produced perplexities within 3.0 of the best value. Widening the ranges further leads to quickly deteriorating results. ",
+        "bbox": [
+            174,
+            626,
+            825,
+            710
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Satisfied that the hyperparameter surface is well behaved, we considered whether the same results could have possibly been achieved with a simple grid search. Omitting input embedding ratio because the tuner found having a down-projection suboptimal almost non-conditionally for this 4-layer LSTM, there remain six hyperparameters to tune. If there were 5 possible values on the grid for each hyperparameter (with one value in every $20 \\%$ interval), then we would need $6 ^ { 5 }$ , nearly 8000 trials to get within 3.0 of the best perplexity achieved by the tuner in about 1500 trials. ",
+        "bbox": [
+            174,
+            717,
+            825,
+            801
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "7.4 TYING LSTM GATES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            834,
+            361,
+            849
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Normally, LSTMs have two independent gates controlling the retention of cell state and the admission of updates (Eq. 1). A minor variant which reduces the number of parameters at the loss of some flexibility is to tie the input and forget gates as in Eq. 2. A possible middle ground that keeps the number of parameters the same but ensures that values of the cell state $c$ remain in $[ - 1 , 1 ]$ is to cap ",
+        "bbox": [
+            174,
+            867,
+            823,
+            922
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/eb7379d157cdc01f200e679d713c2374479d6c1a24ea6a64991bd147e3141cc8.jpg",
+        "image_caption": [
+            "Figure 2: Average per-word negative log-likelihoods of hyperparameter combinations in the neighbourhood of the best solution for a 4-layer LSTM with 24M weights on the Penn Treebank dataset. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            101,
+            820,
+            279
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "the input gate as in Eq. 3. ",
+        "bbox": [
+            174,
+            344,
+            341,
+            359
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/40296253d9aad52534fd5a73ca9ac04bd6435ba547045accf5eeab30723da21a.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\mathbf { c } _ { t } = \\mathbf { f } _ { t } \\odot \\mathbf { c } _ { t - 1 } + \\mathbf { i } _ { t } \\odot \\mathbf { j } _ { t } } \\\\ & { \\mathbf { c } _ { t } = \\mathbf { f } _ { t } \\odot \\mathbf { c } _ { t - 1 } + \\left( 1 - \\mathbf { f } _ { t } \\right) \\odot \\mathbf { j } _ { t } } \\\\ & { \\mathbf { c } _ { t } = \\mathbf { f } _ { t } \\odot \\mathbf { c } _ { t - 1 } + \\operatorname* { m i n } ( 1 - \\mathbf { f } _ { t } , \\mathbf { i } _ { t } ) \\odot \\mathbf { j } _ { t } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            370,
+            367,
+            624,
+            424
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Where the equations are based on the formulation of Sak et al. (2014). All LSTM models in this paper use the third variant, except those titled “Untied gates” and “Tied gates” in Table 4 corresponding to Eq. 1 and 2, respectively. ",
+        "bbox": [
+            176,
+            429,
+            823,
+            472
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The results show that LSTMs are insensitive to these changes and the results vary only slightly even though more hidden units are allocated to the tied version to fill its parameter budget. Finally, the numbers suggest that deep LSTMs benefit from bounded cell states. ",
+        "bbox": [
+            174,
+            478,
+            823,
+            520
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "8 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            542,
+            318,
+            559
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "During the transitional period when deep neural language models began to supplant their shallower predecessors, effect sizes tended to be large, and robust conclusions about the value of the modelling innovations could be made, even in the presence of poorly controlled “hyperparameter noise.” However, now that the neural revolution is in full swing, researchers must often compare competing deep architectures. In this regime, effect sizes tend to be much smaller, and more methodological care is required to produce reliable results. Furthermore, with so much work carried out in parallel by a growing research community, the costs of faulty conclusions are increased. ",
+        "bbox": [
+            174,
+            575,
+            825,
+            674
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Although we can draw attention to this problem, this paper does not offer a practical methodological solution beyond establishing reliable baselines that can be the benchmarks for subsequent work. Still, we demonstrate how, with a huge amount of computation, noise levels of various origins can be carefully estimated and models meaningfully compared. This apparent tradeoff between the amount of computation and the reliability of results seems to lie at the heart of the matter. Solutions to the methodological challenges must therefore make model evaluation cheaper by, for instance, reducing the number of hyperparameters and the sensitivity of models to them, employing better hyperparameter optimisation strategies, or by defining “leagues” with predefined computational budgets for a single model representing different points on the tradeoff curve. ",
+        "bbox": [
+            174,
+            680,
+            825,
+            805
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            829,
+            285,
+            844
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Junyoung Chung, Sungjin Ahn, and Yoshua Bengio. Hierarchical multiscale recurrent neural networks. CoRR, abs/1609.01704, 2016. URL http://arxiv.org/abs/1609.01704. ",
+        "bbox": [
+            174,
+            853,
+            823,
+            882
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Jasmine Collins, Jascha Sohl-Dickstein, and David Sussillo. Capacity and trainability in recurrent neural networks. arXiv preprint arXiv:1611.09913, 2016. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Thomas Desautels, Andreas Krause, and Joel W. Burdick. Parallelizing exploration-exploitation tradeoffs in Gaussian process bandit optimization. Journal of Machine Learning Research, 15: 4053–4103, 2014. URL http://jmlr.org/papers/v15/desautels14a.html. ",
+        "bbox": [
+            176,
+            103,
+            823,
+            147
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yarin Gal and Zoubin Ghahramani. A theoretically grounded application of dropout in recurrent neural networks. In Advances in Neural Information Processing Systems, pp. 1019–1027, 2016. ",
+        "bbox": [
+            173,
+            155,
+            823,
+            185
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Daniel Golovin, Benjamin Solnik, Subhodeep Moitra, Greg Kochanski, John Karro, and D Sculley. Google vizier: A service for black-box optimization. In Proceedings of the 23rd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, pp. 1487–1495. ACM, 2017. ",
+        "bbox": [
+            173,
+            194,
+            825,
+            251
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Edouard Grave, Armand Joulin, and Nicolas Usunier. Improving neural language models with a continuous cache. CoRR, abs/1612.04426, 2016. URL http://arxiv.org/abs/1612. 04426. ",
+        "bbox": [
+            173,
+            261,
+            825,
+            303
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Alex Graves. Generating sequences with recurrent neural networks. CoRR, abs/1308.0850, 2013. URL http://arxiv.org/abs/1308.0850. ",
+        "bbox": [
+            173,
+            314,
+            823,
+            342
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Peter Henderson, Riashat Islam, Philip Bachman, Joelle Pineau, Doina Precup, and David Meger. Deep reinforcement learning that matters. arXiv preprint arXiv:1709.06560, 2017. ",
+        "bbox": [
+            171,
+            352,
+            823,
+            381
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jerry L Hintze and Ray D Nelson. Violin plots: a box plot-density trace synergism. The American Statistician, 52(2):181–184, 1998. ",
+        "bbox": [
+            171,
+            390,
+            823,
+            420
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sepp Hochreiter and Jurgen Schmidhuber. Long Short-Term Memory. ¨ Neural Computation, 9 (8):1735–1780, November 1997. ISSN 0899-7667. doi: 10.1162/neco.1997.9.8.1735. URL http://dx.doi.org/10.1162/neco.1997.9.8.1735. ",
+        "bbox": [
+            176,
+            429,
+            821,
+            472
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Marcus Hutter. The human knowledge compression contest. 2012. ",
+        "bbox": [
+            173,
+            481,
+            611,
+            497
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Hakan Inan, Khashayar Khosravi, and Richard Socher. Tying word vectors and word classifiers: A loss framework for language modeling. CoRR, abs/1611.01462, 2016. URL http://arxiv. org/abs/1611.01462. ",
+        "bbox": [
+            174,
+            506,
+            823,
+            549
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Nal Kalchbrenner, Ivo Danihelka, and Alex Graves. Grid long short-term memory. CoRR, abs/1507.01526, 2015. URL http://arxiv.org/abs/1507.01526. ",
+        "bbox": [
+            173,
+            559,
+            821,
+            588
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Nal Kalchbrenner, Lasse Espeholt, Karen Simonyan, Aaron van den Oord, Alex Graves, and Koray ¨ Kavukcuoglu. Neural machine translation in linear time. CoRR, abs/1610.10099, 2016. URL http://arxiv.org/abs/1610.10099. ",
+        "bbox": [
+            173,
+            597,
+            825,
+            640
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014. ",
+        "bbox": [
+            173,
+            650,
+            823,
+            679
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ben Krause, Emmanuel Kahembwe, Iain Murray, and Steve Renals. Dynamic evaluation of neural sequence models. arXiv preprint arXiv:1709.07432, 2017. ",
+        "bbox": [
+            173,
+            688,
+            825,
+            718
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Mitchell P Marcus, Mary Ann Marcinkiewicz, and Beatrice Santorini. Building a large annotated corpus of english: The Penn treebank. Computational linguistics, 19(2):313–330, 1993. ",
+        "bbox": [
+            171,
+            727,
+            823,
+            756
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Stephen Merity, Caiming Xiong, James Bradbury, and Richard Socher. Pointer sentinel mixture models. CoRR, abs/1609.07843, 2016. URL http://arxiv.org/abs/1609.07843. ",
+        "bbox": [
+            171,
+            765,
+            825,
+            795
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Stephen Merity, Nitish Shirish Keskar, and Richard Socher. Regularizing and optimizing LSTM language models. CoRR, abs/1708.02182, 2017. URL http://arxiv.org/abs/1708. 02182. ",
+        "bbox": [
+            174,
+            804,
+            823,
+            847
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Tomas Mikolov, Martin Karafiat, Lukas Burget, Jan Cernock ´ y, and Sanjeev Khudanpur. Recurrent\\` neural network based language model. In Interspeech, volume 2, pp. 3, 2010. ",
+        "bbox": [
+            173,
+            856,
+            820,
+            886
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ofir Press and Lior Wolf. Using the output embedding to improve language models. CoRR, abs/1608.05859, 2016. URL http://arxiv.org/abs/1608.05859. ",
+        "bbox": [
+            176,
+            895,
+            820,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Nils Reimers and Iryna Gurevych. Reporting score distributions makes a difference: Performance study of lstm-networks for sequence tagging. CoRR, abs/1707.09861, 2017. URL http:// arxiv.org/abs/1707.09861. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hasim Sak, Andrew W. Senior, and Franc¸oise Beaufays. Long short-term memory based recurrent neural network architectures for large vocabulary speech recognition. CoRR, abs/1402.1128, 2014. URL http://arxiv.org/abs/1402.1128. ",
+        "bbox": [
+            176,
+            155,
+            820,
+            198
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Stanislau Semeniuta, Aliaksei Severyn, and Erhardt Barth. Recurrent dropout without memory loss. CoRR, abs/1603.05118, 2016. URL http://arxiv.org/abs/1603.05118. ",
+        "bbox": [
+            174,
+            205,
+            821,
+            236
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yuhuai Wu, Saizheng Zhang, Ying Zhang, Yoshua Bengio, and Ruslan Salakhutdinov. On multiplicative integration with recurrent neural networks. CoRR, abs/1606.06630, 2016. URL http://arxiv.org/abs/1606.06630. ",
+        "bbox": [
+            174,
+            243,
+            820,
+            287
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Wojciech Zaremba, Ilya Sutskever, and Oriol Vinyals. Recurrent neural network regularization. CoRR, abs/1409.2329, 2014. URL http://arxiv.org/abs/1409.2329. ",
+        "bbox": [
+            174,
+            295,
+            820,
+            325
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Julian G. Zilly, Rupesh Kumar Srivastava, Jan Koutn´ık, and Jurgen Schmidhuber. Recurrent ¨ highway networks. CoRR, abs/1607.03474, 2016. URL http://arxiv.org/abs/1607. 03474. ",
+        "bbox": [
+            173,
+            333,
+            821,
+            376
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Barret Zoph and Quoc V Le. Neural architecture search with reinforcement learning. arXiv preprint arXiv:1611.01578, 2016. ",
+        "bbox": [
+            173,
+            385,
+            823,
+            414
+        ],
+        "page_idx": 9
+    }
+]

parse/train/HJx-3grYDB/HJx-3grYDB.md

@@ -0,0 +1,339 @@
+# LEARNING NEARLY DECOMPOSABLE VALUE FUNCTIONS VIA COMMUNICATION MINIMIZATION
+
+Tonghan Wang1∗, Jianhao Wang1∗, Chongyi Zheng2 & Chongjie Zhang1
+
+1Institute for Interdisciplinary Information Sciences, Tsinghua University, Beijing, China 2Turing AI Institute of Nanjing, Nanjing, China wangth18@mails.tsinghua.edu.cn, wjh720.eric@gmail.com chongyeezheng@gmail.com, chongjie@tsinghua.edu.cn
+
+# ABSTRACT
+
+Reinforcement learning encounters major challenges in multi-agent settings, such as scalability and non-stationarity. Recently, value function factorization learning emerges as a promising way to address these challenges in collaborative multiagent systems. However, existing methods have been focusing on learning fully decentralized value functions, which are not efficient for tasks requiring communication. To address this limitation, this paper presents a novel framework for learning nearly decomposable $Q$ -functions (NDQ) via communication minimization, with which agents act on their own most of the time but occasionally send messages to other agents in order for effective coordination. This framework hybridizes value function factorization learning and communication learning by introducing two information-theoretic regularizers. These regularizers are maximizing mutual information between agents’ action selection and communication messages while minimizing the entropy of messages between agents. We show how to optimize these regularizers in a way that is easily integrated with existing value function factorization methods such as QMIX. Finally, we demonstrate that, on the StarCraft unit micromanagement benchmark, our framework significantly outperforms baseline methods and allows us to cut off more than $8 0 \%$ of communication without sacrificing the performance. The videos of our experiments are available at https://sites.google.com/view/ndq.
+
+# 1 INTRODUCTION
+
+Cooperative multi-agent reinforcement learning (MARL) are finding applications in many realworld domains, such as autonomous vehicle teams (Cao et al., 2012), intelligent warehouse systems (Nowe et al., 2012), and sensor networks (Zhang & Lesser, 2011). To help address these ´ problems, recent years have made a great progress in MARL methods (Lowe et al., 2017; Foerster et al., 2018; Rashid et al., 2018; Jaques et al., 2019). Among these successes, the paradigm of centralized training with decentralized execution has attracted much attention for its scalability and ability to deal with non-stationarity.
+
+Value function decomposition methods provide a promising way to exploit such paradigm. They learn a decentralized Q function for each agent and use a mixing network to combine these local Q values into a global action value. In previous works, VDN (Sunehag et al., 2018), QMIX (Rashid et al., 2018), and QTRAN (Son et al., 2019) have progressively enlarged the family of functions that can be represented by the mixing network. Despite their increasing ability in terms of value factorization representation, existing methods have been focusing on learning full decomposition, where each agent acts upon its local observations. However, many multi-agent tasks in the real world are not fully decomposable – agents sometimes require information from other agents in order to effectively coordinate their behaviors. This is because partial observability and stochasticity in a multi-agent environment can exacerbate an agent’s uncertainty of other agents’ states and actions during decentralized execution, which may result in catastrophic miscoordination.
+
+To address this limitation, this paper presents a scalable multi-agent learning framework for learning nearly decomposable $Q$ -functions (NDQ) via communication minimization, with which agents act on their own most of the time but occasionally send messages to other agents in order for effective coordination. This framework hybridizes value function factorization learning and communication learning by introducing an information-theoretic regularizer for maximizing mutual information between agents’ action selection and communication messages. Messages are parameterized in a stochastic embedding space. To optimize communication, we introduce an additional informationtheoretic regularizer to minimize the entropy of messages between agents. With these two regularizers, our framework implicitly learn when, what, and with whom to communicate and also ensure communication to be both expressive (i.e., effectively reducing the uncertainty of agents’ actionvalue functions) and succinct (i.e., only sending useful and necessary information). To optimize these regularizers, we derive a variational lower bound objective, which is easily integrated with existing value function factorization methods such as QMIX.
+
+We demonstrate the effectiveness of our learning framework on StarCraft $\mathrm { I I } ^ { 1 }$ unit micromanagement benchmark used in Foerster et al. (2017; 2018); Rashid et al. (2018); Samvelyan et al. (2019). Empirical results show that NDQ significantly outperforms baseline methods and allows to cut off more than $8 0 \%$ communication without sacrificing the performance. We also observe that agents can effectively learn to coordinate their actions at the cost of sending one or two bits of messages even in complex StarCraft II tasks.
+
+# 2 BACKGROUND
+
+In our work, we consider a fully cooperative multi-agent task that can be modelled by a DecPOMDP (Oliehoek et al., 2016) $G = \bar { \langle I , S , A , P , R , \bar { \Omega } , O , n , \gamma \rangle }$ , where $I \equiv \{ 1 , 2 , . . . , \dot { n } \}$ is the finite set of agents. $s \in S$ is the true state of the environment from which each agent $i$ draws an individual partial observation $o _ { i } \in \Omega$ according to the observation function $O ( s , i )$ . Each agent has an action-observation history $\tau _ { i } \in \mathrm { T } \equiv ( \Omega \times \mathbf { \bar { \cal A } } ) ^ { * }$ . At each timestep, each agent $i$ selects an action $a _ { i } \in A$ , forming a joint action $\pmb { a } \in A ^ { n }$ , resulting in a shared reward $r = R ( s , { \pmb a } )$ for each agent and the next state $s ^ { \prime }$ according to the transition function $P ( s ^ { \prime } | s , a )$ . The joint policy $\pi$ induces a joint action-value function: $\begin{array} { r } { Q _ { t o t } ^ { \pi } ( \tau , a ) = \mathbb { E } _ { s _ { 0 : \infty } , a _ { 0 : \infty } } [ \sum _ { t = 0 } ^ { \infty } \gamma ^ { t } r _ { t } | s _ { 0 } { = } s , a _ { 0 } { = } a , \pi ] } \end{array}$ , where $\tau$ is the joint action-observation history and $\gamma \in [ 0 , 1 )$ is the discount factor.
+
+Learning the optimal action-value function encounters challenges in multi-agent settings. On the one hand, to properly coordinate actions of agents, learning a centralized action-value function $Q _ { t o t }$ seems a good choice. However, such a function is difficult to learn when the number of agents is large. On the other hand, directly learning decentralized action-value function $Q _ { i }$ for each agent alleviates the scalability problem (Tan, 1993; Tampuu et al., 2017). Nevertheless, such independent learning method largely neglects interactions among agents, which often results in miscoordination and inferior performance.
+
+In between, value function factorization method provides a promising way to attenuate such dilemma by representing $Q _ { t o t }$ as a mixing of decentralized $Q _ { i }$ conditioned on local information. Such method has shown their effectiveness on complex task (Samvelyan et al., 2019).
+
+However, current value function factorization methods have been mainly focusing on full decomposition. Such decomposition reduces the complexity of learning $Q _ { t o t }$ by first learning independent $Q _ { i }$ and putting the burden of coordinating actions on the mixing networks whose input is all $Q _ { i }$ ’s and output is $Q _ { t o t }$ . For many tasks with partial observability and stochastic dynamics, mixing networks are not sufficient to learn coordinated actions, regardless of how powerful its representation ability is. The reason is that full decomposition cuts off all dependencies among decentralized action-value functions and agents will be uncertain about states and actions of other agents. Such uncertainty will increase as time goes by and can result in severe miscoordination and arbitrarily worse performance during decentralized execution.
+
+![](images/832064caa78101e55f02e76ac2dd97ff9b48c0fbe27def3509fea316d8aeede0.jpg)  
+Figure 1: Schematics of our approach. The message encoder generates an embedding distribution that is sampled and concatenated with the current local history to serve as an input to the local action-value function. Local action values are fed into a mixing network to to get an estimation of the global action value.
+
+# 3 METHODOLOGY
+
+In this section, we propose to learn nearly decomposable $Q$ -functions (NDQ) via communication minimization, a new framework to overcome the miscoordination issue of full factorization methods.
+
+In our learning framework (Fig. 1), individual action-value functions condition on local actionobservation history and, at certain timesteps, messages received from a few other agents. Messages from agent $i$ to agent $j$ are drawn from a multivariate Gaussian distribution whose parameters are given by an encoder $f _ { m } ( \tau _ { i } , j ; \pmb { \theta } _ { c } )$ , where $\tau _ { i }$ is the local observation-action history of agent $i$ , and $\theta _ { c }$ are parameters of the encoder $f _ { m }$ . Formally, message $m _ { i j } \sim \mathcal { N } ( f _ { m } ( \tau _ { i } , j ; \pmb \theta _ { c } ) , I )$ , where $\pmb { I }$ is an identity matrix. Here we use an identity covariance matrix and the reasons will be discussed in the next section. $m _ { ( - i ) j }$ is used to denote the messages sent to $j$ from agents other than $i$ . We learn a nearly decomposable structure via learning minimized communication. We thus expect the communication to have the following properties:
+
+i) Expressiveness: The message passed to one agent should effectively reduce the uncertainty in its action-value function.
+
+ii) Succinctness: Agents are expected to send messages as short as possible to the agents who need it and only when necessary.
+
+To learn such a communicating strategy, we draw inspiration from variational inference for its proven ability in learning structure from data and endow a stochastic latent message space, which we also refer to as ”message embedding”. We impose constraints, which will be discussed in detail in the next section, on the latent message embedding to enable an agent to decide locally which bits in a message should be sent according to their utility in terms of helping other agents make decisions. Agent $j$ will receive an input message $m _ { j } ^ { i n }$ that has been selectively cut, on which it conditions the local action-value function $Q _ { j } ( \tau _ { j } , a _ { j } , m _ { j } ^ { i n } )$ . All the individual Q values are then fed into a mixing network such as that used by QMIX (Rashid et al., 2018).
+
+Apart from the constraints on the message embedding, all the components (the individual actionvalue functions, the message encoder, and the mixing network) are trained in an end-to-end manner by minimizing the TD loss. Thus, our overall objective is to minimize
+
+$$
+\begin{array} { r } { \mathcal { L } ( \pmb { \theta } ) = \mathcal { L } _ { T D } ( \pmb { \theta } ) + \lambda \mathcal { L } _ { c } ( \pmb { \theta } _ { c } ) , } \end{array}
+$$
+
+where $\begin{array} { r } { \mathcal { L } _ { T D } ( \pmb { \theta } ) = \left[ r + \gamma \operatorname* { m a x } _ { a ^ { \prime } } Q _ { t o t } ( \pmb { \tau } ^ { \prime } , \pmb { a } ^ { \prime } ; \pmb { \theta } ^ { - } ) - Q _ { t o t } ( \pmb { \tau } , \pmb { a } ; \pmb { \theta } ) \right] ^ { 2 } } \end{array}$ $\pmb { \theta } ^ { - }$ are the parameters of a periodically updated target network as in DQN) is the TD loss, $\pmb { \theta }$ are all parameters in the model,
+
+and $\lambda$ is a weighting term. We will discuss how to define and optimize $\mathcal { L } _ { c } ( \pmb { \theta } _ { c } )$ to regularize the message embedding in the next section.
+
+# 3.1 MINIMIZED COMMUNICATION OBJECTIVE AND VARIATIONAL BOUND
+
+Introducing latent variables facilitates the representation of the message, but it does not mean that the messages can reduce uncertainty in the action-value functions of other agents. To make message expressive, we maximize the mutual information between message and agent’s action selection. Formally, we maximize $I _ { \pmb { \theta } _ { c } } ( A _ { j } ; M _ { i j } | \mathrm { T } _ { j } , M _ { ( - i ) j } ) _ { . }$ where $A _ { j }$ is agent $j$ ’s action selection, $\mathrm { T } _ { j }$ is the random variable of the local action-observation history of agent $j$ , $M _ { i j }$ and $M _ { ( - i ) j }$ are random variables of $m _ { i j }$ and $m _ { ( - i ) j }$ . However, if this is the only objective, the encoder can easily learn to cheat by giving messages under different histories representations in different regions in the latent space, rendering cutting off useless messages difficult. A natural constraint to avoid such representations is to minimize the entropy of the messages. Therefore, our objective for optimizing communication of agent $i$ is to maximize:
+
+$$
+J _ { c } ( \pmb { \theta } _ { c } ) = \sum _ { j = 1 } ^ { n } \left[ I _ { \pmb { \theta } _ { c } } ( A _ { j } ; M _ { i j } | \mathrm { T } _ { j } , M _ { ( - i ) j } ) - \beta H _ { \pmb { \theta } _ { c } } ( M _ { i j } ) \right] ,
+$$
+
+where $\beta$ is a scaling factor trading expressiveness and succinctness.
+
+This objective is appealing because it agrees exactly with the desiderata that we impose on the message embedding. However, optimizing this objective needs extra efforts because computation involving mutual information is intractable. By introducing a variational approximator, a popular technique from variational toolkit (Alemi et al., 2017), we can derive a lower bound for the mutual information term in Eq. 2 (a detailed derivation can be found in Appendix A):
+
+$$
+\begin{array} { r l } & { I _ { \pmb { \theta } _ { c } } ( A _ { j } ; M _ { i j } | \mathrm { T } _ { j } , M _ { ( - i ) j } ) } \\ & { \quad \geq \ : \mathbb { E } _ { \mathbf { T } \sim \mathcal { D } , M _ { j } ^ { i n } \sim f _ { m } ( \mathbf { T } , j ; \pmb { \theta } _ { c } ) } \left[ - \mathcal { C } \mathcal { E } \left[ p ( A _ { j } | \mathbf { T } ) \| q _ { \xi } ( A _ { j } | \mathrm { T } _ { j } , M _ { j } ^ { i n } ) \right] \right] , } \end{array}
+$$
+
+where $\textbf { T } = \mathbf { \Omega } _ { , } \left. \mathrm { T } _ { 1 } , \mathrm { T } _ { 2 } , \ldots , \mathrm { T } _ { n } \right.$ is the joint local history sampled from the replay buffer $\mathcal { D }$ , $q _ { \xi } \big ( A _ { j } | \mathrm { T } _ { j } , M _ { j } ^ { i n } \big )$ is the variational posterior estimator with parameters $\xi$ , and $\mathcal { C } \mathcal { E }$ is the cross entropy operator. We share $\xi$ among agents to accelerate learning.
+
+Next we discuss how to minimize the term $H _ { \theta _ { c } } ( M _ { i j } )$ . Directly minimizing this can cause the variances of the Gaussian distributions to collapse to $_ 0$ . To deal with this numeric issue, we use the unit covariance matrix and try to minimize $H ( M _ { i j } ) - H ( M _ { i j } | \mathrm { T } _ { i } )$ instead. This is equivalent to minimizing $H ( M _ { i j } )$ because $H ( M _ { i j } | \mathrm { T } _ { i } )$ is the entropy of a multivariate Gaussian random variable and thus is a constant $\log ( \operatorname* { d e t } ( 2 \pi e \bar { \Sigma } ) ) / 2$ , where $\pmb { \Sigma }$ is a unit matrix in our formulation). Then we have:
+
+$$
+H ( M _ { i j } ) - H ( M _ { i j } | \mathrm { T } _ { i } ) = \int p ( m _ { i j } | \tau _ { i } ) p ( \tau _ { i } ) \log \frac { p ( m _ { i j } | \tau _ { i } ) } { p ( m _ { i j } ) } d m _ { i j } d \tau _ { i } .
+$$
+
+We use a similar technique as for the mutual information term by introducing an distribution $r ( m _ { i j } )$ to get a upper bound of Eq. 4:
+
+$$
+\begin{array} { r l } & { H ( M _ { i j } ) - H ( M _ { i j } | \mathrm { T } _ { i } ) \le \displaystyle \int p ( m _ { i j } | \tau _ { i } ) p ( \tau _ { i } ) \log \frac { p ( m _ { i j } | \tau _ { i } ) } { r ( m _ { i j } ) } d m _ { i j } d \tau _ { i } } \\ & { \quad \quad \quad \quad = \mathbb { E } _ { \mathrm { T } _ { i } \sim D } \left[ D _ { \mathrm { K L } } ( p ( M _ { i j } | \mathrm { T } _ { i } ) \| r ( M _ { i j } ) ) \right] . } \end{array}
+$$
+
+This bound holds for any distribution $r ( M _ { i j } )$ . To facilitate cutting off messages, we use unit Gaussian distribution $\mathcal { N } ( 0 , \pmb { I } )$ . Combining Eq. 3 and 5, we get a tractable variational lower bound of our objective in Eq. 2:
+
+$$
+\begin{array} { r l } { I _ { c } ( \pmb { \theta } _ { c } ) \geq } & { \mathbb { E } _ { \mathbf { T } \sim \mathcal { D } , M _ { j } ^ { i n } \sim f _ { m } ( \mathbf { T } , j ; \pmb { \theta } _ { c } ) } \left[ - \mathcal { C } \mathcal { E } \left[ p ( A _ { j } | \mathbf { T } ) \| q _ { \xi } ( A _ { j } | \mathbf { T } _ { j } , M _ { j } ^ { i n } ) \right] - \beta D _ { \mathrm { K L } } ( p ( M _ { i j } | \mathbf { T } _ { i } ) \| r ( M _ { i j } ) ) \right] } \end{array}
+$$
+
+We optimize this bound to generate an expressive and succinct message embedding. Specifically, we minimize:
+
+$$
+\dot { \ z } _ { c } ( \theta _ { c } ) = \mathbb { E } _ { \mathbf { T } \sim \mathcal { D } , M _ { j } ^ { i n } \sim f _ { m } ( \mathbf { T } , j ; \theta _ { c } ) } \left[ \mathcal { C } \mathcal { E } \left[ p ( A _ { j } | \mathbf { T } ) | q _ { \xi } ( A _ { j } | \mathrm { T } _ { j } , M _ { j } ^ { i n } ) \right] + \beta D _ { \mathrm { K L } } ( p ( M _ { i j } | \mathrm { T } _ { i } ) | | r ( M _ { i j } ) ) \right] .
+$$
+
+Intuitively, the first term, which we call the expressiveness loss, ensures that communication aims to reduce the uncertainty in action-value functions of other agents. The second term, called the succinctness loss, forces messages to get close to the unit Gaussian distribution. Since we set the covariances of the latent message variables to the unit matrix, this term actually pushes the means of the message distributions to the origin of the latent space. Using these two losses leads to an embedding space where useless messages distribute near the origin, while messages that contain important information for the decision-making processes of other agents occupy other spaces.
+
+Note that the loss shown in Eq. 7 is used to update the parameters in the message encoder. In the meantime, all components (the individual action-value functions, the message encoder, and the mixing network) are trained in an end-to-end manner. Thus, the message encoder is updated by two gradients: the gradient induced by $\mathcal { L } _ { c } ( \pmb { \theta } _ { c } )$ and the gradient associated with the TD loss $\mathcal { L } _ { T D } ( \dot { \pmb { \theta } } )$ .
+
+# 3.2 CUTTING OFF MESSAGES
+
+Our objective pushes messages which can not reduce the uncertainties in action-value functions of other agents close to the origin of the latent message space. This naturally gives us a hint on how to drop meaningless messages – we can order the message distributions according to their means and drop accordingly. Note that since we use a unit covariance matrix for the latent message distribution, bits in a message are independent. Thus, we can make decisions in a bit-by-bit fashion and send messages with various lengths. In this way, our method learns not only when and who (agent $i$ does not communicate with agent $j$ when all bits of $m _ { i j }$ are dropped) to communicate, but also what to communicate (how many bits are sent and their values). More details are discussed in Appendix B.
+
+Our framework adopts the centralized training with decentralized execution paradigm. During centralized training, we assume the learning algorithm has access to all agents’ individual observationaction histories and the global state $s$ . During execution, agents communicate and act in a decentralized fashion based on the learned message encoder and action-value functions.
+
+# 4 RELATED WORKS
+
+Deep multi-agent reinforcement learning has witnessed vigorous progress in recent years. COMA (Foerster et al., 2018), MADDPG (Lowe et al., 2017), and PR2 (Wen et al., 2019) explores multi-agent policy gradients and respectively address the problem of credit assignment, learning in mixed environments and recursive reasoning. Another line of research focuses on value-based multi-agent RL, among which value-function factorization is the most popular method. Three representative examples: VDN (Sunehag et al., 2018), QMIX (Rashid et al., 2018), and QTRAN (Son et al., 2019) gradually increase the representation ability of the mixing network. In particular, QMIX (Rashid et al., 2018) stands out as a scalable and robust algorithm and achieves state-ofthe-art results on StarCraft unit micromanagement benchmark (Samvelyan et al., 2019).
+
+Communication is a hot topic in multi-agent reinforcement learning. End-to-end learning with differentiable communication channel is a popular approach now. Sukhbaatar et al. (2016); Hoshen (2017); Jiang & Lu (2018); Singh et al. (2019); Das et al. (2019) focus on learning decentralized communication protocol and address the problem of when and who to communicate. Foerster et al. (2016); Das et al. (2017); Lazaridou et al. (2017); Mordatch & Abbeel (2018) study the emergence of natural language in the context of multi-agent learning. IC3Net (Singh et al., 2019) learns gate to control the agents to only communicate with their teammates in mixed multi-agent environment. Zhang & Lesser (2013); Kim et al. (2019) study action coordination under limited communication channel and thus are related to our works. The difference lies in that they do not explicitly minimize communication. Social influence (Jaques et al., 2019) and InfoBot (Goyal et al., 2019) penalize message that has no influence on policies of other agents.
+
+Work that is most related to this paper is TarMAC (Das et al., 2019), where attention mechanism is used to differentiate the importance of incoming messages. In comparison, we use variation inference to decide the content of messages and whether a message should be sent under the guidance of global reward signals. We compare our method with TarMAC and a baseline combining TarMAC and QMIX in our experiments. Related works on the task of StarCraft II unit micromanagement are discussed in Appendix C.2.
+
+![](images/697d563495f9bc44830ce69fbd63ac8f151af2361ff1a0400d421b2726c9f5a0.jpg)  
+Figure 2: (a) Task sensor; (b) Performance comparison on sensor; (c) Performance comparison when different percentages of messages are dropped. We measure the drop rate of our method in two ways: count by the number of messages (NDQ) or count by the number of bits (NDQ (bits)). QMIX (5M) is the performance of QMIX after training for 5 million time steps.
+
+![](images/0b9b6ea3ede8afe0b06ae9e3c78611b9aa688625417abc6dfd6eb277ecf15018.jpg)  
+Figure 3: Message distributions learned by our method on sensor under different values of $\beta$ . (Messages are cut by bit, if $\mu < 2 . 0 $ ). A mean of 0 means that the corresponding bit is below the cutting threshold and is not sent. When $\beta = 1 0 ^ { - 3 }$ , NDQ learns the minimized communication strategy that is effective.
+
+# 5 EXPERIMENTAL RESULTS
+
+In this section, we show our experiments to answer the following questions: (i) Is the miscoordination problem of full value function factorization methods widespread? (ii) Can our method learn the minimized communication protocol required by a task? (iii) Can the learned message distributions reduce uncertainties in value functions of other agents? (iv) How does our method differ from communication with attention mechanism? (v) How does $\beta$ influence the communication protocol? We will first show three simple examples to clarify our idea from different perspectives and then provide performance analysis on StarCraftII unit micromanagement benchmark. For evaluation, all experiments are carried out with 5 random seeds and results are shown with a $9 5 \%$ confidence interval. Details of the NDQ network architecture are given in Appendix B.2. Videos of our experiments on StarCraft II are available online2.
+
+![](images/c85a259dd622d9f8e76e0344646cbc0610a9d596d517aa5bd237c4b228e9b98d.jpg)  
+Figure 4: Results on hallway. (a, b) Task hallway and performance comparison. (c) Similar to Fig. 2(c), we show performance comparison when different percentages of messages are dropped.
+
+![](images/afba870d2a2086169d01038c92fb7cb153cbf0735ee52dc3947f1b0e193a81b7.jpg)  
+Figure 5: Message embedding representations learned by our method on hallway. A mean of 0 means that the corresponding bit is below the cutting threshold $( \mu { = } 3 )$ and is not sent.
+
+We compare NDQ with the following baselines: (i) QMIX (Rashid et al., 2018); (ii) TarMAC (Das et al., 2019). QMIX and TarMAC are state-of-the-art full value function factorization and attentional communication methods, respectively. (iii) QMIX $+$ TarMAC. We introduce the attentional communication mechanism into the value function factorization paradigm by integrating the communication component of TarMAC into QMIX.
+
+# 5.1 DIDACTIC EXAMPLES
+
+We first demonstrate our idea on three didactic examples: sensor, hallway, and independent search.
+
+Sensor network is a frequently used testbed in multi-agent learning field (Kumar et al., 2011; Zhang & Lesser, 2011). We use a 3-chain sensor configuration in the task sensor (Fig. 2(a)). Each sensor is controlled by one agent, and they are rewarded for successfully locating targets, which requires two sensors to scan the same area simultaneously when the target appears. At each timestep, target 1 appears in area 1 with possibility 1, and locating it induces a team reward of 20; target 2 appears with probability 0.5 in area 2, and agents are rewarded 30 for locating it. Agents can observe whether a target is present in nearby areas and need to choose one of the five actions: scanning north, east, south, west, and noop. Every scan induces a cost of -5.
+
+In the optimal policy, when target 2 appears, sensor 1 should turn itself off while sensors 2 and 3 are expected to scan area 2 to get the reward. And when target 2 is absent, sensors 1 and 2 need to cooperatively scan area 1 while sensor 3 takes noop.
+
+Sensor is representative of a class of tasks where the uncertainties about the true states cause policies learned by full value function factorization method to be sub-optimal – sensor 1 has to know whether the target is present in area 2 to make a decision. However, the mixing network of QMIX cannot provide such information. As a result, QMIX converges to a sub-optimal policy, which gets a team reward of 12.5 a step on average (see Fig. 2(b)).
+
+![](images/ce0c797741733d2e79c6c0370c0bb35f936cca8248e7c9807de9388b027eb6da.jpg)  
+Figure 6: Snapshots of the StarCraft II scenarios that we consider.
+
+We are particularly interested in whether our method can learn the minimized communication strategy. Fig. 3 shows the latent message space learned by NDQ. When $\beta = 1 0 ^ { - 3 }$ , agent 3 learns to send a bit to tell agent 1 whether target 2 appears. In the meantime, the latent message distribution between any other pair of agents is close to the standard Gaussian distribution and thus is dropped. This result indicates that NDQ has discovered the minimized conditional graph and can explain why our method can still perform optimally when $8 0 \%$ of the messages are cut off (Fig. 2(c)). When $\beta$ becomes too large (1.0), all the message bits are pushed below the cutting threshold (Fig. 3(a) and 3(d)). When $\beta$ is too small $( 1 0 ^ { - 5 } )$ , NDQ pays more attention on reducing uncertainties in Q-functions rather than compressing messages. Correspondingly, both agent 3 and agent 2 send a message to agent 1 (Fig. 3(c) and 3(f)), which is a redundant communication strategy.
+
+The second example, hallway (Fig. 4(a)), is a Dec-POMDP with two agents randomly starting at states $a _ { 1 }$ to $a _ { m }$ and $b _ { 1 }$ to $b _ { n }$ , respectively. Agents can observe their position and choose to move left, move right, or keep still at each timestep. Agents will win and get a reward of 10 if they arrive at state $g$ simultaneously. Otherwise, if any agent arrives at $g$ earlier than the other, the team will not be rewarded, and the next episode will begin. The horizon is set to $\operatorname* { m a x } ( m , n ) + 1 0$ to avoid an infinite loop.
+
+Hallway aims to show that the miscoordination problem of full factorization methods can be severe in multi-step scenarios. We set $m$ and $n$ to 4 and show comparison of performance in Fig. 4(b). The miscoordination problem causes QMIX to lose about half of the games. We are again particularly interested in the message embedding representations learned by NDQ. We show an episode in Fig. 5. Two agents begin at $a _ { 4 }$ and $b _ { 3 }$ , respectively. They first move left silently $\mathit { t } = 1$ and $t = 2$ ) until agent $\mathbf { B }$ arrives at $b _ { 1 }$ . On arriving $b _ { 1 }$ , it sends a bit whose value is 5.24 to A. After sending this bit, B stays at $b _ { 1 }$ and sends this message repeatedly until it receives a bit from A indicating that A has arrived at $a _ { 1 }$ . They then move left together and win. This is the minimized communication strategy. Taking advantage of this strategy, NDQ can still win in $100 \%$ of episodes when $80 \%$ of the communicating bits are dropped (Fig. 4(c)).
+
+The third task, independent search, aims to demonstrate that NDQ can learn not to communicate in scenarios where agents are independent. Task description and results analysis are deferred to Appendix C.1.
+
+# 5.2 MAXIMUM VALUE FUNCTION FACTORIZATION IN STARCRAFT II
+
+To demonstrate that the miscoordination problem of full decomposition methods is widespread in multi-agent learning, we apply our method and baselines to the StarCraft II micromanagement benchmark introduced by Samvelyan et al. (2019), which is described in detail in Appendix C.2. We further increase the difficulty of action coordination by i) reducing the sight range of agents from 9 to 2; ii) introducing challenging maps with complex terrain or highly random spawning positions for units. We test our method on the six maps shown in Fig. 6. Detailed descriptions of these scenarios are provided in Appendix C.2.
+
+![](images/27eefa79e24e86583e48b47c2fd00c9503591db86e7dba1590ef1f86876845cb.jpg)  
+Figure 7: Learning curves of our method and baselines when no message is cut for NDQ and QMIX $^ +$ TarMAC.
+
+![](images/7e11c38777d9f0fc6a2b9a94fea1422876b595a2c8fc8817dbf8bfb6df47da57.jpg)  
+Figure 8: Performance of our method and QMIX+TarMAC when $8 0 \%$ of messages are cut off. We also plot the learning curves of QMIX for comparison.
+
+We use the same hyper-parameter setting for NDQ on all maps: $\beta$ is set to $1 0 ^ { - 5 }$ , $\lambda$ is set to 0.1, and the length of message $m _ { i j }$ is set to 3. For evaluation, we pause training every $1 0 0 k$ environment steps and run 48 testing episodes. Other hyper-parameters for NDQ are described in Appendix B.2.
+
+# 5.2.1 PERFORMANCE COMPARISON
+
+We show the performance of our method and baselines when no message is cut in Fig. 7. The superior performance of NDQ against QMIX demonstrates that the miscoordination problem of full factorization methods is widespread, especially in scenarios with high stochasticity, such as 1o2r vs 4r, 3b vs 1h1m, and 1o10b vs 1r. Notably, our method also outperforms the attentional communication mechanism (QMIX $^ +$ TarMAC) by a large margin. Since agents communicate in both of these two methods and the same TD error is used, these results highlight the role of the constraints that we impose on our message embedding. TarMAC struggles in all the scenarios. We believe that this is because it does not deal with the issue of reward assignment.
+
+![](images/af28aa81ce813b3f5f9c978bf5b815f556e7f0ed15c799cfb5e93f787061147d.jpg)  
+Figure 9: Performance of our method and $\mathrm { Q M X ^ { + } }$ TarMAC when $1 0 0 \%$ messages are cut off. We also plot the learning curves of QMIX for comparison.
+
+# 5.2.2 MESSAGE CUT OFF
+
+To demonstrate that our method can learn nearly decomposable Q-functions in complex tasks, we cut off $8 0 \%$ of messages according to the means of distributions when testing and show the results in Fig. 8. The results indicate that we can omit more than $8 0 \%$ of communication without significantly affecting performance. For comparison, we cut off messages in QMIX $+$ TarMAC whose weights are $8 0 \%$ smallest and find that its performance drops significantly (Fig. 8). These results indicate that our method is more robust in terms of message cutting off compared to the attentional communication methods.
+
+We further drop all the messages and show the developments of testing performance in Fig. 9. As expected, the win rates of NDQ decrease dramatically, proving that the superiority of our method when $8 0 \%$ of messages are dropped comes from expressive and succinct communication protocols.
+
+# 6 CLOSING REMARKS
+
+In this paper, we presented a novel multi-agent learning framework within the paradigm of centralized training with decentralized execution. This framework fuses value function factorization learning and communication learning and efficiently learns nearly decomposable value functions for agents to act most of the time independently and communicate when it is necessary for coordination. We introduce two information-theoretical regularizers to minimize overall communication while maximizing the message information for coordination. Empirical results in challenging StarCraft II tasks show that our method significantly outperforms baseline methods and allows us to reduce communication by more than $8 0 \%$ without sacrificing the performance. We also observe that nearly minimal messages (e.g., with one or two bits) are learned to communicate between agents in order to ensure effective coordination.
+
+# REFERENCES
+
+Alexander A Alemi, Ian Fischer, Joshua V Dillon, and Kevin Murphy. Deep variational information bottleneck. In Proceedings of the International Conference on Learning Representations (ICLR), 2017.
+
+Yongcan Cao, Wenwu Yu, Wei Ren, and Guanrong Chen. An overview of recent progress in the study of distributed multi-agent coordination. IEEE Transactions on Industrial informatics, 9(1): 427–438, 2012.
+
+Abhishek Das, Satwik Kottur, Jose MF Moura, Stefan Lee, and Dhruv Batra. Learning cooperative ´ visual dialog agents with deep reinforcement learning. In Proceedings of the IEEE International Conference on Computer Vision, pp. 2951–2960, 2017.
+
+Abhishek Das, Theophile Gervet, Joshua Romoff, Dhruv Batra, Devi Parikh, Mike Rabbat, and ´ Joelle Pineau. Tarmac: Targeted multi-agent communication. In International Conference on Machine Learning, pp. 1538–1546, 2019.
+
+Jakob Foerster, Ioannis Alexandros Assael, Nando de Freitas, and Shimon Whiteson. Learning to communicate with deep multi-agent reinforcement learning. In Advances in Neural Information Processing Systems, pp. 2137–2145, 2016.
+
+Jakob Foerster, Nantas Nardelli, Gregory Farquhar, Triantafyllos Afouras, Philip HS Torr, Pushmeet Kohli, and Shimon Whiteson. Stabilising experience replay for deep multi-agent reinforcement learning. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pp. 1146–1155. JMLR. org, 2017.
+
+Jakob N Foerster, Gregory Farquhar, Triantafyllos Afouras, Nantas Nardelli, and Shimon Whiteson. Counterfactual multi-agent policy gradients. In Thirty-Second AAAI Conference on Artificial Intelligence, 2018.
+
+Anirudh Goyal, Riashat Islam, Daniel Strouse, Zafarali Ahmed, Matthew Botvinick, Hugo Larochelle, Sergey Levine, and Yoshua Bengio. Infobot: Transfer and exploration via the information bottleneck. In Proceedings of the International Conference on Learning Representations (ICLR), 2019.
+
+Yedid Hoshen. Vain: Attentional multi-agent predictive modeling. In Advances in Neural Information Processing Systems, pp. 2701–2711, 2017.
+
+Natasha Jaques, Angeliki Lazaridou, Edward Hughes, Caglar Gulcehre, Pedro Ortega, Dj Strouse, Joel Z Leibo, and Nando De Freitas. Social influence as intrinsic motivation for multi-agent deep reinforcement learning. In International Conference on Machine Learning, pp. 3040–3049, 2019.
+
+Jiechuan Jiang and Zongqing Lu. Learning attentional communication for multi-agent cooperation. In Advances in Neural Information Processing Systems, pp. 7254–7264, 2018.
+
+Daewoo Kim, Sangwoo Moon, David Hostallero, Wan Ju Kang, Taeyoung Lee, Kyunghwan Son, and Yung Yi. Learning to schedule communication in multi-agent reinforcement learning. In Proceedings of the International Conference on Learning Representations (ICLR), 2019.
+
+Akshat Kumar, Shlomo Zilberstein, and Marc Toussaint. Scalable multiagent planning using probabilistic inference. In Twenty-Second International Joint Conference on Artificial Intelligence, 2011.
+
+Angeliki Lazaridou, Alexander Peysakhovich, and Marco Baroni. Multi-agent cooperation and the emergence of (natural) language. In Proceedings of the International Conference on Learning Representations (ICLR), 2017.
+
+Ryan Lowe, Yi Wu, Aviv Tamar, Jean Harb, OpenAI Pieter Abbeel, and Igor Mordatch. Multi-agent actor-critic for mixed cooperative-competitive environments. In Advances in Neural Information Processing Systems, pp. 6379–6390, 2017.
+
+Igor Mordatch and Pieter Abbeel. Emergence of grounded compositional language in multi-agent populations. In Thirty-Second AAAI Conference on Artificial Intelligence, 2018.
+
+Ann Nowe, Peter Vrancx, and Yann-Micha ´ el De Hauwere. Game theory and multi-agent reinforce- ¨ ment learning. In Reinforcement Learning, pp. 441–470. Springer, 2012.
+
+Frans A Oliehoek, Christopher Amato, et al. A concise introduction to decentralized POMDPs, volume 1. Springer, 2016.
+
+Peng Peng, Ying Wen, Yaodong Yang, Quan Yuan, Zhenkun Tang, Haitao Long, and Jun Wang. Multiagent bidirectionally-coordinated nets: Emergence of human-level coordination in learning to play starcraft combat games. arXiv preprint arXiv:1703.10069, 2017.
+
+Tabish Rashid, Mikayel Samvelyan, Christian Schroeder Witt, Gregory Farquhar, Jakob Foerster, and Shimon Whiteson. Qmix: Monotonic value function factorisation for deep multi-agent reinforcement learning. In International Conference on Machine Learning, pp. 4292–4301, 2018.
+
+Mikayel Samvelyan, Tabish Rashid, Christian Schroeder de Witt, Gregory Farquhar, Nantas Nardelli, Tim GJ Rudner, Chia-Man Hung, Philip HS Torr, Jakob Foerster, and Shimon Whiteson. The starcraft multi-agent challenge. arXiv preprint arXiv:1902.04043, 2019.
+
+Amanpreet Singh, Tushar Jain, and Sainbayar Sukhbaatar. Learning when to communicate at scale in multiagent cooperative and competitive tasks. In Proceedings of the International Conference on Learning Representations (ICLR), 2019.
+
+Kyunghwan Son, Daewoo Kim, Wan Ju Kang, David Earl Hostallero, and Yung Yi. Qtran: Learning to factorize with transformation for cooperative multi-agent reinforcement learning. In International Conference on Machine Learning, pp. 5887–5896, 2019.
+
+Sainbayar Sukhbaatar, Rob Fergus, et al. Learning multiagent communication with backpropagation. In Advances in Neural Information Processing Systems, pp. 2244–2252, 2016.
+
+Peter Sunehag, Guy Lever, Audrunas Gruslys, Wojciech Marian Czarnecki, Vinicius Zambaldi, Max Jaderberg, Marc Lanctot, Nicolas Sonnerat, Joel Z Leibo, Karl Tuyls, et al. Value-decomposition networks for cooperative multi-agent learning based on team reward. In Proceedings of the 17th International Conference on Autonomous Agents and MultiAgent Systems, pp. 2085–2087. International Foundation for Autonomous Agents and Multiagent Systems, 2018.
+
+Ardi Tampuu, Tambet Matiisen, Dorian Kodelja, Ilya Kuzovkin, Kristjan Korjus, Juhan Aru, Jaan Aru, and Raul Vicente. Multiagent cooperation and competition with deep reinforcement learning. PloS one, 12(4):e0172395, 2017.
+
+Ming Tan. Multi-agent reinforcement learning: Independent vs. cooperative agents. In Proceedings of the tenth international conference on machine learning, pp. 330–337, 1993.
+
+Nicolas Usunier, Gabriel Synnaeve, Zeming Lin, and Soumith Chintala. Episodic exploration for deep deterministic policies: An application to starcraft micromanagement tasks. In Proceedings of the International Conference on Learning Representations (ICLR), 2017.
+
+Ying Wen, Yaodong Yang, Rui Luo, Jun Wang, and Wei Pan. Probabilistic recursive reasoning for multi-agent reinforcement learning. In Proceedings of the International Conference on Learning Representations (ICLR), 2019.
+
+Chongjie Zhang and Victor Lesser. Coordinated multi-agent reinforcement learning in networked distributed pomdps. In Twenty-Fifth AAAI Conference on Artificial Intelligence, 2011.
+
+Chongjie Zhang and Victor Lesser. Coordinating multi-agent reinforcement learning with limited communication. In Proceedings of the 2013 international conference on Autonomous agents and multi-agent systems, pp. 1101–1108. International Foundation for Autonomous Agents and Multiagent Systems, 2013.
+
+# APPENDIX
+
+# A VARIATIONAL BOUND ON MUTUAL INFORMATION
+
+In order to enable messages to effectively reduce the uncertainties in action-value functions of other agents, we propose to maximize the mutual information between $A _ { j }$ and $M _ { i j }$ . We borrow ideas from the variational inference literature and derive a lower bound of this mutual information regularizer.
+
+Theorem 1. A lower bound of mutual information $I _ { \pmb { \theta } _ { c } } ( A _ { j } ; M _ { i j } | \mathrm { T } _ { j } , M _ { ( - i ) j } )$ is
+
+$$
+\mathbb { E } _ { \mathbf { T } \sim \mathcal { D } , M _ { j } ^ { i n } \sim f _ { m } ( \mathbf { T } , j ; \theta _ { c } ) } \left[ - \mathcal { C } \mathcal { E } \left[ p ( A _ { j } | \mathbf { T } ) \| q _ { \xi } ( A _ { j } | \mathrm { T } _ { j } , M _ { j } ^ { i n } ) \right] \right] ,
+$$
+
+where $\mathrm { T } _ { j }$ is the local action-observation history of agent $j$ , and $\mathbf { T } = \langle \mathrm { T } _ { 1 } , \mathrm { T } _ { 2 } , \dots , \mathrm { T } _ { n } \rangle$ is the joint local history sampled from the replay buffer $\mathcal { D }$ , $q _ { \xi } ( A _ { j } | \mathrm { T } _ { j } , M _ { j } ^ { i n } )$ is the variational posterior estimator with parameters $\xi$ .
+
+Proof.
+
+$$
+\begin{array} { r l } & { \quad { \cal I } _ { \theta _ { c } } ( A _ { j } ; M _ { i j } | T _ { j } , M _ { ( - i ) j } ) } \\ & { = \displaystyle \int p ( a _ { j } , \tau _ { j } , m _ { j } ^ { i n } ) \log \frac { p ( a _ { j } , m _ { i j } | \tau _ { j } , m _ { ( - i ) j } ) } { p ( a _ { j } | \tau _ { j } , m _ { ( - i ) j } ) p ( m _ { i j } | \tau _ { j } , m _ { ( - i ) j } ) } d a _ { j } d \tau _ { j } d m _ { j } ^ { i n } } \\ & { = \displaystyle \int p ( a _ { j } , \tau _ { j } , m _ { j } ^ { i n } ) \log \frac { p ( a _ { j } | \tau _ { j } , m _ { j } ^ { i n } ) } { p ( a _ { j } | \tau _ { j } , m _ { ( - i ) j } ) } d a _ { j } d \tau _ { j } d m _ { j } ^ { i n } , } \end{array}
+$$
+
+where $p ( a _ { j } | \tau _ { j } , m _ { j } ^ { i n } )$ is determined by the message encoder $f _ { m }$ and Markov Chain:
+
+$$
+\begin{array} { l } { { \displaystyle p ( a _ { j } | \tau _ { j } , m _ { j } ^ { i n } ) } } \\ { { \displaystyle = \int p ( \tau _ { - j } , a _ { j } | \tau _ { j } , m _ { j } ^ { i n } ) d \tau _ { - j } } } \\ { { \displaystyle = \int p ( \tau _ { - j } | \tau _ { j } , m _ { j } ^ { i n } ) p ( a _ { j } | \tau ) d \tau _ { - j } \quad \mathrm { ( A c c o r d i n g ~ t o ~ \Gamma  { [ a _ j ~ \bot ~ } m _ { j } ^ { i n } | \tau ] ) } } } \\ { { \displaystyle = \int \frac { p ( \tau ) p ( m _ { j } ^ { i n } | \tau ) p ( a _ { j } | \tau ) } { p ( \tau _ { j } , m _ { j } ^ { i n } ) } d \tau _ { - j } . } } \end{array}
+$$
+
+We introduce $q _ { \xi } ( a _ { j } | \tau _ { j } , m _ { j } ^ { i n } )$ as a variational approximation to $p ( a _ { j } | \tau _ { j } , m _ { j } ^ { i n } )$ . Since
+
+$$
+D _ { \mathrm { K L } } ( p ( a _ { j } | \tau _ { j } , m _ { j } ^ { i n } ) \Vert q _ { \xi } ( a _ { j } | \tau _ { j } , m _ { j } ^ { i n } ) \geq 0 ,
+$$
+
+we have
+
+$$
+\begin{array} { r l } {  { \int p ( a _ { j } | \tau _ { j } , m _ { j } ^ { i n } ) \log p ( a _ { j } | \tau _ { j } , m _ { j } ^ { i n } ) d a _ { j } } } \\ & { \geq \int p ( a _ { j } | \tau _ { j } , m _ { j } ^ { i n } ) \log q _ { \xi } ( a _ { j } | \tau _ { j } , m _ { j } ^ { i n } ) d a _ { j } . } \end{array}
+$$
+
+Thus, for the mutual information term:
+
+$$
+\begin{array} { r l } & { \quad I _ { \theta _ { c } } ( A _ { j } ; M _ { i j } | T _ { j } , \mathcal { M } _ { ( - i ) j } ) } \\ & { \geq \displaystyle \int p ( a _ { j } , \tau _ { j } , m _ { j } ^ { i n } ) \log \frac { q _ { \xi } ( a _ { j } | \tau _ { j } , m _ { j } ^ { i n } ) } { p ( a _ { j } | \tau _ { j } , m _ { ( - i ) j } ) } d a _ { j } d \tau _ { j } d m _ { j } ^ { i n } } \\ & { = \displaystyle \int p ( a _ { j } , \tau _ { j } , m _ { j } ^ { i n } ) \log q _ { \xi } ( a _ { j } | \tau _ { j } , m _ { j } ^ { i n } ) d a _ { j } d \tau _ { j } d m _ { j } ^ { i n } } \\ & { \quad - \displaystyle \int p ( a _ { j } , \tau _ { j } , m _ { j } ^ { i n } ) \log p ( a _ { j } | \tau _ { j } , m _ { ( - i ) j } ) d a _ { j } d \tau _ { j } d m _ { j } ^ { i n } } \\ & { = \displaystyle \int p ( \tau ) p ( m _ { j } ^ { i n } | \tau ) p ( a _ { j } | \tau , m _ { j } ^ { i n } ) \log q _ { \xi } ( a _ { j } | \tau _ { j } , m _ { j } ^ { i n } ) d a _ { j } d \tau d m _ { j } ^ { i n } } \end{array}
+$$
+
+$$
+\begin{array} { l } { { \displaystyle \quad - \int p ( a _ { j } , \tau _ { j } , m _ { ( - \cdot ) j _ { j } } ) \log p ( a _ { j } | \tau _ { j } , m _ { ( - \cdot ) j } ) d a _ { j } d \tau _ { j } d m _ { ( - \cdot ) j } } } \\ { { \displaystyle = \int p ( \tau ) p ( m _ { j } ^ { i n } | \tau ) p ( a _ { j } | \tau ) \log q _ { \xi } ( a _ { j } | \tau _ { j } , m _ { j } ^ { i n } ) d a _ { j } d \tau d m _ { j } ^ { i n } \quad \mathrm { ( A c c o r f i n g ~ t o ~ } \big [ a _ { j } \perp m _ { j } ^ { i n } | \tau \big ] ) } } \\ { { \displaystyle \quad + H _ { \theta _ { \alpha } } ( A _ { j } | \Gamma _ { j } , M _ { ( - \cdot \cdot ) j } ) } } \\ { { \displaystyle = \mathbb { E } _ { \mathbf { T } \sim \mathcal { P } , M _ { j } ^ { i n } \sim f _ { m } ( \mathbf { T } , j _ { \cdot } | \theta _ { c } ) } \left[ \int p ( a _ { j } | \mathbf { T } ) \log q _ { \xi } ( a _ { j } | \Gamma _ { j } , M _ { j } ^ { i n } ) d a _ { j } \right] } } \\ { { \displaystyle \quad + H _ { \theta _ { \alpha } } ( A _ { j } | \Gamma _ { j } , M _ { ( - \cdot ) j } ) } } \\ { { \displaystyle = \mathbb { E } _ { \mathbf { T } \sim \mathcal { P } , M _ { j } ^ { i n } \sim f _ { m } ( \mathbf { T } , j _ { \cdot } | \theta _ { c } ) } \left[ - \mathcal { C } \mathcal { E } \left[ p ( A _ { j } | \mathbf { T } ) \| q _ { \xi } ( A _ { j } | \Gamma _ { j } , M _ { j } ^ { i n } ) \right] \right] } } \\ { { \displaystyle \quad + H _ { \theta _ { \alpha } } ( A _ { j } | \Gamma _ { j } , M _ { ( - \cdot ) j } ) } } \\ { { \displaystyle \quad + H _ { \theta _ { \alpha } } ( A _ { j } | \Gamma _ { j } , M _ { ( - \cdot ) j _ { \cdot } } ) . } } \end{array}
+$$
+
+Because $H _ { \pmb \theta _ { c } } ( A _ { j } | \mathrm { T } _ { j } , M _ { ( - i ) j } ) \geq 0$ , we get the lower bound in Theorem 1.
+
+# B IMPLEMENTATION DETAILS
+
+# B.1 DETAILS OF MESSAGE DROPPING
+
+In our methods, not only the number of messages but also the length of messages are minimized. In other words, we send messages with varying lengths. However, messages are feed into an actionvalue function approximator at the recipient side, which requires inputs to have the same length. To solve this problem, we send masks indicating which bits are dropped along with the messages. To save channel bandwidth, masks are regarded as binary numbers, so each of them only consumes a negligible log-scale space compared to the length of messages. For the unsent bits, we fill in 0s before feeding the messages into the local utility functions.
+
+# B.2 NETWORK ARCHITECTURE, HYPERPARAMETERS, AND INFRASTRUCTURE
+
+We base our implementation on the PyMARL framework (Samvelyan et al., 2019) and use its default network structure and hyper-parameter setting for QMIX. For the message encoder, we use a fully connected network with one 64-dimensional hidden layer and ReLU activation. For the posterior estimator $q _ { \xi }$ , we adopt a fully connected network with two 20-dimensional hidden layers with ReLU activation. We train our models on NVIDIA RTX 2080Ti GPUs using experience sampled from 16 parallel environments. To benchmark NDQ, we train all algorithms for 20 million time steps on each StarCraft II unit micromanagement task and use the default hyper-parameter settings for baselines.
+
+# C EXPERIMENTAL RESULTS
+
+# C.1 DIDACTIC EXAMPLE: INDEPENDENT SEARCH
+
+In independent search, two agents are finding landmarks in two independent $5 \times 5$ rooms for 100 time steps (see Fig. 10). An agent is rewarded 1 when it is on the landmark in its room.
+
+Independent search is an example where agents are totally independent. This task aims to demonstrate that our method can learn not to communicate in independent scenarios. We show team performance in Table 1. NDQ can achieve the optimal performance when agents do not communicate with each other.
+
+Table 1: The average team reward gained in an episode on the task independent-search.   
+
+<table><tr><td></td><td>Ours</td><td>QMIX TarMAC</td><td>TarMAC+QMIX</td></tr><tr><td>No message is cut</td><td>96.0 96.0</td><td>96.0</td><td>96.0</td></tr><tr><td>100% messages are cut</td><td>96.0</td><td></td><td>96.0</td></tr></table>
+
+![](images/6bf3d6a764a3b180862d2f7ab36e26a25e81698603806678b3d4aa76ef03ab68.jpg)  
+Figure 10: Task Independent-search. Two agents are both reward- and transition-independent.
+
+# C.2 STARCRAFT II
+
+StarCraft unit micromanagement has attracted lots of research interests for its high degree of control complexity and environmental stochasticity. Usunier et al. (2017) and Peng et al. (2017) study this problem from a centralized perspective. In order to facilitate decentralized control, we use the setup introduced by Samvelyan et al. (2019).
+
+We first describe the scenarios that we consider in detail. We consider combat scenarios where the enemy units are controlled by StarCraft II built-in AI (difficulty level is set to medium), and each of the ally units is controlled by a learning agent. The units of the two groups can be asymmetric, and the initial placement is random. At each time step, each agent chooses one action from the discrete action space consisting of the following actions: noop, move[direction], attack[enemy id], and stop. Under the control of these actions, agents move and attack in a continuous map. A global reward that is equal to the total damage dealt on the enemy units is given at each timestep. Killing each enemy unit and winning a combat induce extra bonuses of 10 and 200, respectively.
+
+3b vs 1h1m: 3 Banelings try to kill a Hydralisk assisted by a Medivac. 3 Banelings together can just blow up the Hydralisk. Therefore, they should not give the Hydralisk rest time during which the Medivac can restore its health. Banelings have to attack at the same time to get the winning reward. This scenario is designed to test whether our method can learn a communication protocol to coordinate actions.
+
+3s vs 5z: 3 Stalkers encounter 5 Zealots on a map. Zealots can cause high damage but are much slower so that Stalkers have to take advantage of a technique called kiting – Stalkers should alternatively attack the Zealots and flee for a distance.
+
+1o2r vs 4r: An Overseer has found 4 Reapers. Its ally units, 2 Roaches, need to get there and kill the Reapers to win. At the beginning of an episode, the Overseer and Reapers spawn at a random point on the map while the Roaches are initialized at another random point. Given that only the Overseer knows the position of the enemy, a learning algorithm has to learn to deliver this message to the Roaches to effectively win the combat.
+
+5z vs 1ul: 5 Zealots try to kill a powerful Ultralisk. A sophisticated micro-trick demanding right positioning and attack timing has to be learned to win.
+
+MMM: Symmetric teams consisting of 7 Marines, 2 Marauders, and 1 Medivac spawn at two fixed points, and the enemy team is tasked to attack the ally team. To win the battle, agents have to learn to communicate their health to the Medivac.
+
+1o10b vs 1r: In a map full of cliffs, an Overseer detects a Roach. The teammates of the Overseer, 10 Banelings, need to kill this Roach to get the winning reward. The Overseer and the Roach spawn at a random point while the Banelings spawn randomly on the map. In the minimized communication strategy, the Banelings can keep silent, and the Overseer needs to encode its position and send it to the Banelings. We use this task to test the performance of our method in complex scenarios.

parse/train/HJx-3grYDB/HJx-3grYDB_content_list.json

@@ -0,0 +1,1770 @@
+[
+    {
+        "type": "text",
+        "text": "LEARNING NEARLY DECOMPOSABLE VALUE FUNCTIONS VIA COMMUNICATION MINIMIZATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            820,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Tonghan Wang1∗, Jianhao Wang1∗, Chongyi Zheng2 & Chongjie Zhang1 ",
+        "bbox": [
+            184,
+            167,
+            681,
+            185
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1Institute for Interdisciplinary Information Sciences, Tsinghua University, Beijing, China 2Turing AI Institute of Nanjing, Nanjing, China wangth18@mails.tsinghua.edu.cn, wjh720.eric@gmail.com chongyeezheng@gmail.com, chongjie@tsinghua.edu.cn ",
+        "bbox": [
+            184,
+            185,
+            766,
+            242
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            279,
+            544,
+            292
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Reinforcement learning encounters major challenges in multi-agent settings, such as scalability and non-stationarity. Recently, value function factorization learning emerges as a promising way to address these challenges in collaborative multiagent systems. However, existing methods have been focusing on learning fully decentralized value functions, which are not efficient for tasks requiring communication. To address this limitation, this paper presents a novel framework for learning nearly decomposable $Q$ -functions (NDQ) via communication minimization, with which agents act on their own most of the time but occasionally send messages to other agents in order for effective coordination. This framework hybridizes value function factorization learning and communication learning by introducing two information-theoretic regularizers. These regularizers are maximizing mutual information between agents’ action selection and communication messages while minimizing the entropy of messages between agents. We show how to optimize these regularizers in a way that is easily integrated with existing value function factorization methods such as QMIX. Finally, we demonstrate that, on the StarCraft unit micromanagement benchmark, our framework significantly outperforms baseline methods and allows us to cut off more than $8 0 \\%$ of communication without sacrificing the performance. The videos of our experiments are available at https://sites.google.com/view/ndq. ",
+        "bbox": [
+            233,
+            310,
+            764,
+            575
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            606,
+            336,
+            622
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Cooperative multi-agent reinforcement learning (MARL) are finding applications in many realworld domains, such as autonomous vehicle teams (Cao et al., 2012), intelligent warehouse systems (Nowe et al., 2012), and sensor networks (Zhang & Lesser, 2011). To help address these ´ problems, recent years have made a great progress in MARL methods (Lowe et al., 2017; Foerster et al., 2018; Rashid et al., 2018; Jaques et al., 2019). Among these successes, the paradigm of centralized training with decentralized execution has attracted much attention for its scalability and ability to deal with non-stationarity. ",
+        "bbox": [
+            174,
+            638,
+            823,
+            737
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Value function decomposition methods provide a promising way to exploit such paradigm. They learn a decentralized Q function for each agent and use a mixing network to combine these local Q values into a global action value. In previous works, VDN (Sunehag et al., 2018), QMIX (Rashid et al., 2018), and QTRAN (Son et al., 2019) have progressively enlarged the family of functions that can be represented by the mixing network. Despite their increasing ability in terms of value factorization representation, existing methods have been focusing on learning full decomposition, where each agent acts upon its local observations. However, many multi-agent tasks in the real world are not fully decomposable – agents sometimes require information from other agents in order to effectively coordinate their behaviors. This is because partial observability and stochasticity in a multi-agent environment can exacerbate an agent’s uncertainty of other agents’ states and actions during decentralized execution, which may result in catastrophic miscoordination. ",
+        "bbox": [
+            174,
+            743,
+            825,
+            897
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "To address this limitation, this paper presents a scalable multi-agent learning framework for learning nearly decomposable $Q$ -functions (NDQ) via communication minimization, with which agents act on their own most of the time but occasionally send messages to other agents in order for effective coordination. This framework hybridizes value function factorization learning and communication learning by introducing an information-theoretic regularizer for maximizing mutual information between agents’ action selection and communication messages. Messages are parameterized in a stochastic embedding space. To optimize communication, we introduce an additional informationtheoretic regularizer to minimize the entropy of messages between agents. With these two regularizers, our framework implicitly learn when, what, and with whom to communicate and also ensure communication to be both expressive (i.e., effectively reducing the uncertainty of agents’ actionvalue functions) and succinct (i.e., only sending useful and necessary information). To optimize these regularizers, we derive a variational lower bound objective, which is easily integrated with existing value function factorization methods such as QMIX. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            284
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We demonstrate the effectiveness of our learning framework on StarCraft $\\mathrm { I I } ^ { 1 }$ unit micromanagement benchmark used in Foerster et al. (2017; 2018); Rashid et al. (2018); Samvelyan et al. (2019). Empirical results show that NDQ significantly outperforms baseline methods and allows to cut off more than $8 0 \\%$ communication without sacrificing the performance. We also observe that agents can effectively learn to coordinate their actions at the cost of sending one or two bits of messages even in complex StarCraft II tasks. ",
+        "bbox": [
+            174,
+            291,
+            825,
+            375
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 BACKGROUND ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            414,
+            326,
+            430
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In our work, we consider a fully cooperative multi-agent task that can be modelled by a DecPOMDP (Oliehoek et al., 2016) $G = \\bar { \\langle I , S , A , P , R , \\bar { \\Omega } , O , n , \\gamma \\rangle }$ , where $I \\equiv \\{ 1 , 2 , . . . , \\dot { n } \\}$ is the finite set of agents. $s \\in S$ is the true state of the environment from which each agent $i$ draws an individual partial observation $o _ { i } \\in \\Omega$ according to the observation function $O ( s , i )$ . Each agent has an action-observation history $\\tau _ { i } \\in \\mathrm { T } \\equiv ( \\Omega \\times \\mathbf { \\bar { \\cal A } } ) ^ { * }$ . At each timestep, each agent $i$ selects an action $a _ { i } \\in A$ , forming a joint action $\\pmb { a } \\in A ^ { n }$ , resulting in a shared reward $r = R ( s , { \\pmb a } )$ for each agent and the next state $s ^ { \\prime }$ according to the transition function $P ( s ^ { \\prime } | s , a )$ . The joint policy $\\pi$ induces a joint action-value function: $\\begin{array} { r } { Q _ { t o t } ^ { \\pi } ( \\tau , a ) = \\mathbb { E } _ { s _ { 0 : \\infty } , a _ { 0 : \\infty } } [ \\sum _ { t = 0 } ^ { \\infty } \\gamma ^ { t } r _ { t } | s _ { 0 } { = } s , a _ { 0 } { = } a , \\pi ] } \\end{array}$ , where $\\tau$ is the joint action-observation history and $\\gamma \\in [ 0 , 1 )$ is the discount factor. ",
+        "bbox": [
+            174,
+            455,
+            825,
+            582
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Learning the optimal action-value function encounters challenges in multi-agent settings. On the one hand, to properly coordinate actions of agents, learning a centralized action-value function $Q _ { t o t }$ seems a good choice. However, such a function is difficult to learn when the number of agents is large. On the other hand, directly learning decentralized action-value function $Q _ { i }$ for each agent alleviates the scalability problem (Tan, 1993; Tampuu et al., 2017). Nevertheless, such independent learning method largely neglects interactions among agents, which often results in miscoordination and inferior performance. ",
+        "bbox": [
+            174,
+            588,
+            825,
+            685
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In between, value function factorization method provides a promising way to attenuate such dilemma by representing $Q _ { t o t }$ as a mixing of decentralized $Q _ { i }$ conditioned on local information. Such method has shown their effectiveness on complex task (Samvelyan et al., 2019). ",
+        "bbox": [
+            176,
+            693,
+            823,
+            734
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "However, current value function factorization methods have been mainly focusing on full decomposition. Such decomposition reduces the complexity of learning $Q _ { t o t }$ by first learning independent $Q _ { i }$ and putting the burden of coordinating actions on the mixing networks whose input is all $Q _ { i }$ ’s and output is $Q _ { t o t }$ . For many tasks with partial observability and stochastic dynamics, mixing networks are not sufficient to learn coordinated actions, regardless of how powerful its representation ability is. The reason is that full decomposition cuts off all dependencies among decentralized action-value functions and agents will be uncertain about states and actions of other agents. Such uncertainty will increase as time goes by and can result in severe miscoordination and arbitrarily worse performance during decentralized execution. ",
+        "bbox": [
+            173,
+            741,
+            825,
+            866
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/832064caa78101e55f02e76ac2dd97ff9b48c0fbe27def3509fea316d8aeede0.jpg",
+        "image_caption": [
+            "Figure 1: Schematics of our approach. The message encoder generates an embedding distribution that is sampled and concatenated with the current local history to serve as an input to the local action-value function. Local action values are fed into a mixing network to to get an estimation of the global action value. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            205,
+            103,
+            789,
+            304
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 METHODOLOGY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            405,
+            341,
+            421
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section, we propose to learn nearly decomposable $Q$ -functions (NDQ) via communication minimization, a new framework to overcome the miscoordination issue of full factorization methods. ",
+        "bbox": [
+            174,
+            439,
+            823,
+            468
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In our learning framework (Fig. 1), individual action-value functions condition on local actionobservation history and, at certain timesteps, messages received from a few other agents. Messages from agent $i$ to agent $j$ are drawn from a multivariate Gaussian distribution whose parameters are given by an encoder $f _ { m } ( \\tau _ { i } , j ; \\pmb { \\theta } _ { c } )$ , where $\\tau _ { i }$ is the local observation-action history of agent $i$ , and $\\theta _ { c }$ are parameters of the encoder $f _ { m }$ . Formally, message $m _ { i j } \\sim \\mathcal { N } ( f _ { m } ( \\tau _ { i } , j ; \\pmb \\theta _ { c } ) , I )$ , where $\\pmb { I }$ is an identity matrix. Here we use an identity covariance matrix and the reasons will be discussed in the next section. $m _ { ( - i ) j }$ is used to denote the messages sent to $j$ from agents other than $i$ . We learn a nearly decomposable structure via learning minimized communication. We thus expect the communication to have the following properties: ",
+        "bbox": [
+            174,
+            488,
+            825,
+            614
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "i) Expressiveness: The message passed to one agent should effectively reduce the uncertainty in its action-value function. ",
+        "bbox": [
+            176,
+            621,
+            821,
+            648
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "ii) Succinctness: Agents are expected to send messages as short as possible to the agents who need it and only when necessary. ",
+        "bbox": [
+            174,
+            656,
+            821,
+            684
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To learn such a communicating strategy, we draw inspiration from variational inference for its proven ability in learning structure from data and endow a stochastic latent message space, which we also refer to as ”message embedding”. We impose constraints, which will be discussed in detail in the next section, on the latent message embedding to enable an agent to decide locally which bits in a message should be sent according to their utility in terms of helping other agents make decisions. Agent $j$ will receive an input message $m _ { j } ^ { i n }$ that has been selectively cut, on which it conditions the local action-value function $Q _ { j } ( \\tau _ { j } , a _ { j } , m _ { j } ^ { i n } )$ . All the individual Q values are then fed into a mixing network such as that used by QMIX (Rashid et al., 2018). ",
+        "bbox": [
+            173,
+            690,
+            825,
+            806
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Apart from the constraints on the message embedding, all the components (the individual actionvalue functions, the message encoder, and the mixing network) are trained in an end-to-end manner by minimizing the TD loss. Thus, our overall objective is to minimize ",
+        "bbox": [
+            174,
+            811,
+            825,
+            854
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ea732d9e1b084543bf820030dd3c165fbccff08e937d6f14a97a6a8a4ed3921b.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathcal { L } ( \\pmb { \\theta } ) = \\mathcal { L } _ { T D } ( \\pmb { \\theta } ) + \\lambda \\mathcal { L } _ { c } ( \\pmb { \\theta } _ { c } ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            401,
+            864,
+            596,
+            882
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\begin{array} { r } { \\mathcal { L } _ { T D } ( \\pmb { \\theta } ) = \\left[ r + \\gamma \\operatorname* { m a x } _ { a ^ { \\prime } } Q _ { t o t } ( \\pmb { \\tau } ^ { \\prime } , \\pmb { a } ^ { \\prime } ; \\pmb { \\theta } ^ { - } ) - Q _ { t o t } ( \\pmb { \\tau } , \\pmb { a } ; \\pmb { \\theta } ) \\right] ^ { 2 } } \\end{array}$ $\\pmb { \\theta } ^ { - }$ are the parameters of a periodically updated target network as in DQN) is the TD loss, $\\pmb { \\theta }$ are all parameters in the model, ",
+        "bbox": [
+            173,
+            893,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "and $\\lambda$ is a weighting term. We will discuss how to define and optimize $\\mathcal { L } _ { c } ( \\pmb { \\theta } _ { c } )$ to regularize the message embedding in the next section. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 MINIMIZED COMMUNICATION OBJECTIVE AND VARIATIONAL BOUND ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            147,
+            700,
+            162
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Introducing latent variables facilitates the representation of the message, but it does not mean that the messages can reduce uncertainty in the action-value functions of other agents. To make message expressive, we maximize the mutual information between message and agent’s action selection. Formally, we maximize $I _ { \\pmb { \\theta } _ { c } } ( A _ { j } ; M _ { i j } | \\mathrm { T } _ { j } , M _ { ( - i ) j } ) _ { . }$ where $A _ { j }$ is agent $j$ ’s action selection, $\\mathrm { T } _ { j }$ is the random variable of the local action-observation history of agent $j$ , $M _ { i j }$ and $M _ { ( - i ) j }$ are random variables of $m _ { i j }$ and $m _ { ( - i ) j }$ . However, if this is the only objective, the encoder can easily learn to cheat by giving messages under different histories representations in different regions in the latent space, rendering cutting off useless messages difficult. A natural constraint to avoid such representations is to minimize the entropy of the messages. Therefore, our objective for optimizing communication of agent $i$ is to maximize: ",
+        "bbox": [
+            173,
+            174,
+            825,
+            314
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8405f5e7b2629947c5d278544b323e5f1a9128168043701266922530e4e5066d.jpg",
+        "text": "$$\nJ _ { c } ( \\pmb { \\theta } _ { c } ) = \\sum _ { j = 1 } ^ { n } \\left[ I _ { \\pmb { \\theta } _ { c } } ( A _ { j } ; M _ { i j } | \\mathrm { T } _ { j } , M _ { ( - i ) j } ) - \\beta H _ { \\pmb { \\theta } _ { c } } ( M _ { i j } ) \\right] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            310,
+            318,
+            686,
+            361
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\beta$ is a scaling factor trading expressiveness and succinctness. ",
+        "bbox": [
+            174,
+            372,
+            614,
+            388
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "This objective is appealing because it agrees exactly with the desiderata that we impose on the message embedding. However, optimizing this objective needs extra efforts because computation involving mutual information is intractable. By introducing a variational approximator, a popular technique from variational toolkit (Alemi et al., 2017), we can derive a lower bound for the mutual information term in Eq. 2 (a detailed derivation can be found in Appendix A): ",
+        "bbox": [
+            174,
+            393,
+            825,
+            465
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5f45e6d47598e7d75f3b0adab1c9a58070c4aa7539cc2d45f456d4e7cbac2868.jpg",
+        "text": "$$\n\\begin{array} { r l } & { I _ { \\pmb { \\theta } _ { c } } ( A _ { j } ; M _ { i j } | \\mathrm { T } _ { j } , M _ { ( - i ) j } ) } \\\\ & { \\quad \\geq \\ : \\mathbb { E } _ { \\mathbf { T } \\sim \\mathcal { D } , M _ { j } ^ { i n } \\sim f _ { m } ( \\mathbf { T } , j ; \\pmb { \\theta } _ { c } ) } \\left[ - \\mathcal { C } \\mathcal { E } \\left[ p ( A _ { j } | \\mathbf { T } ) \\| q _ { \\xi } ( A _ { j } | \\mathrm { T } _ { j } , M _ { j } ^ { i n } ) \\right] \\right] , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            284,
+            468,
+            712,
+            512
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\textbf { T } = \\mathbf { \\Omega } _ { , } \\left. \\mathrm { T } _ { 1 } , \\mathrm { T } _ { 2 } , \\ldots , \\mathrm { T } _ { n } \\right.$ is the joint local history sampled from the replay buffer $\\mathcal { D }$ , $q _ { \\xi } \\big ( A _ { j } | \\mathrm { T } _ { j } , M _ { j } ^ { i n } \\big )$ is the variational posterior estimator with parameters $\\xi$ , and $\\mathcal { C } \\mathcal { E }$ is the cross entropy operator. We share $\\xi$ among agents to accelerate learning. ",
+        "bbox": [
+            174,
+            522,
+            825,
+            565
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Next we discuss how to minimize the term $H _ { \\theta _ { c } } ( M _ { i j } )$ . Directly minimizing this can cause the variances of the Gaussian distributions to collapse to $_ 0$ . To deal with this numeric issue, we use the unit covariance matrix and try to minimize $H ( M _ { i j } ) - H ( M _ { i j } | \\mathrm { T } _ { i } )$ instead. This is equivalent to minimizing $H ( M _ { i j } )$ because $H ( M _ { i j } | \\mathrm { T } _ { i } )$ is the entropy of a multivariate Gaussian random variable and thus is a constant $\\log ( \\operatorname* { d e t } ( 2 \\pi e \\bar { \\Sigma } ) ) / 2$ , where $\\pmb { \\Sigma }$ is a unit matrix in our formulation). Then we have: ",
+        "bbox": [
+            174,
+            571,
+            825,
+            654
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/305b423577106f0b92d9a6846040400900dc73e9a18cf543d21da825454279e8.jpg",
+        "text": "$$\nH ( M _ { i j } ) - H ( M _ { i j } | \\mathrm { T } _ { i } ) = \\int p ( m _ { i j } | \\tau _ { i } ) p ( \\tau _ { i } ) \\log \\frac { p ( m _ { i j } | \\tau _ { i } ) } { p ( m _ { i j } ) } d m _ { i j } d \\tau _ { i } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            276,
+            651,
+            722,
+            685
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We use a similar technique as for the mutual information term by introducing an distribution $r ( m _ { i j } )$ to get a upper bound of Eq. 4: ",
+        "bbox": [
+            176,
+            688,
+            825,
+            717
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/17fff200f9d3de5633cd253c5fa7ded2978e5a4c5ab127e2d1ec0c37e69ee15b.jpg",
+        "text": "$$\n\\begin{array} { r l } & { H ( M _ { i j } ) - H ( M _ { i j } | \\mathrm { T } _ { i } ) \\le \\displaystyle \\int p ( m _ { i j } | \\tau _ { i } ) p ( \\tau _ { i } ) \\log \\frac { p ( m _ { i j } | \\tau _ { i } ) } { r ( m _ { i j } ) } d m _ { i j } d \\tau _ { i } } \\\\ & { \\quad \\quad \\quad \\quad = \\mathbb { E } _ { \\mathrm { T } _ { i } \\sim D } \\left[ D _ { \\mathrm { K L } } ( p ( M _ { i j } | \\mathrm { T } _ { i } ) \\| r ( M _ { i j } ) ) \\right] . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            276,
+            720,
+            720,
+            775
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "This bound holds for any distribution $r ( M _ { i j } )$ . To facilitate cutting off messages, we use unit Gaussian distribution $\\mathcal { N } ( 0 , \\pmb { I } )$ . Combining Eq. 3 and 5, we get a tractable variational lower bound of our objective in Eq. 2: ",
+        "bbox": [
+            176,
+            777,
+            825,
+            821
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a7268b36e6c263c29570cbdf990e701d3acd5f4843059f301acaf97d42e80666.jpg",
+        "text": "$$\n\\begin{array} { r l } { I _ { c } ( \\pmb { \\theta } _ { c } ) \\geq } & { \\mathbb { E } _ { \\mathbf { T } \\sim \\mathcal { D } , M _ { j } ^ { i n } \\sim f _ { m } ( \\mathbf { T } , j ; \\pmb { \\theta } _ { c } ) } \\left[ - \\mathcal { C } \\mathcal { E } \\left[ p ( A _ { j } | \\mathbf { T } ) \\| q _ { \\xi } ( A _ { j } | \\mathbf { T } _ { j } , M _ { j } ^ { i n } ) \\right] - \\beta D _ { \\mathrm { K L } } ( p ( M _ { i j } | \\mathbf { T } _ { i } ) \\| r ( M _ { i j } ) ) \\right] } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            181,
+            825,
+            839,
+            848
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We optimize this bound to generate an expressive and succinct message embedding. Specifically, we minimize: ",
+        "bbox": [
+            173,
+            858,
+            825,
+            887
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/39990c92a2b6014799dcd5d911e5ae31de4f79d5e40ab81f0f6e249bc9299d03.jpg",
+        "text": "$$\n\\dot { \\ z } _ { c } ( \\theta _ { c } ) = \\mathbb { E } _ { \\mathbf { T } \\sim \\mathcal { D } , M _ { j } ^ { i n } \\sim f _ { m } ( \\mathbf { T } , j ; \\theta _ { c } ) } \\left[ \\mathcal { C } \\mathcal { E } \\left[ p ( A _ { j } | \\mathbf { T } ) | q _ { \\xi } ( A _ { j } | \\mathrm { T } _ { j } , M _ { j } ^ { i n } ) \\right] + \\beta D _ { \\mathrm { K L } } ( p ( M _ { i j } | \\mathrm { T } _ { i } ) | | r ( M _ { i j } ) ) \\right] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            181,
+            888,
+            828,
+            911
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Intuitively, the first term, which we call the expressiveness loss, ensures that communication aims to reduce the uncertainty in action-value functions of other agents. The second term, called the succinctness loss, forces messages to get close to the unit Gaussian distribution. Since we set the covariances of the latent message variables to the unit matrix, this term actually pushes the means of the message distributions to the origin of the latent space. Using these two losses leads to an embedding space where useless messages distribute near the origin, while messages that contain important information for the decision-making processes of other agents occupy other spaces. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            202
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Note that the loss shown in Eq. 7 is used to update the parameters in the message encoder. In the meantime, all components (the individual action-value functions, the message encoder, and the mixing network) are trained in an end-to-end manner. Thus, the message encoder is updated by two gradients: the gradient induced by $\\mathcal { L } _ { c } ( \\pmb { \\theta } _ { c } )$ and the gradient associated with the TD loss $\\mathcal { L } _ { T D } ( \\dot { \\pmb { \\theta } } )$ . ",
+        "bbox": [
+            176,
+            208,
+            825,
+            263
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 CUTTING OFF MESSAGES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            286,
+            392,
+            300
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Our objective pushes messages which can not reduce the uncertainties in action-value functions of other agents close to the origin of the latent message space. This naturally gives us a hint on how to drop meaningless messages – we can order the message distributions according to their means and drop accordingly. Note that since we use a unit covariance matrix for the latent message distribution, bits in a message are independent. Thus, we can make decisions in a bit-by-bit fashion and send messages with various lengths. In this way, our method learns not only when and who (agent $i$ does not communicate with agent $j$ when all bits of $m _ { i j }$ are dropped) to communicate, but also what to communicate (how many bits are sent and their values). More details are discussed in Appendix B. ",
+        "bbox": [
+            174,
+            314,
+            825,
+            425
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Our framework adopts the centralized training with decentralized execution paradigm. During centralized training, we assume the learning algorithm has access to all agents’ individual observationaction histories and the global state $s$ . During execution, agents communicate and act in a decentralized fashion based on the learned message encoder and action-value functions. ",
+        "bbox": [
+            176,
+            433,
+            823,
+            488
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 RELATED WORKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            513,
+            352,
+            530
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Deep multi-agent reinforcement learning has witnessed vigorous progress in recent years. COMA (Foerster et al., 2018), MADDPG (Lowe et al., 2017), and PR2 (Wen et al., 2019) explores multi-agent policy gradients and respectively address the problem of credit assignment, learning in mixed environments and recursive reasoning. Another line of research focuses on value-based multi-agent RL, among which value-function factorization is the most popular method. Three representative examples: VDN (Sunehag et al., 2018), QMIX (Rashid et al., 2018), and QTRAN (Son et al., 2019) gradually increase the representation ability of the mixing network. In particular, QMIX (Rashid et al., 2018) stands out as a scalable and robust algorithm and achieves state-ofthe-art results on StarCraft unit micromanagement benchmark (Samvelyan et al., 2019). ",
+        "bbox": [
+            173,
+            547,
+            825,
+            674
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Communication is a hot topic in multi-agent reinforcement learning. End-to-end learning with differentiable communication channel is a popular approach now. Sukhbaatar et al. (2016); Hoshen (2017); Jiang & Lu (2018); Singh et al. (2019); Das et al. (2019) focus on learning decentralized communication protocol and address the problem of when and who to communicate. Foerster et al. (2016); Das et al. (2017); Lazaridou et al. (2017); Mordatch & Abbeel (2018) study the emergence of natural language in the context of multi-agent learning. IC3Net (Singh et al., 2019) learns gate to control the agents to only communicate with their teammates in mixed multi-agent environment. Zhang & Lesser (2013); Kim et al. (2019) study action coordination under limited communication channel and thus are related to our works. The difference lies in that they do not explicitly minimize communication. Social influence (Jaques et al., 2019) and InfoBot (Goyal et al., 2019) penalize message that has no influence on policies of other agents. ",
+        "bbox": [
+            173,
+            680,
+            825,
+            833
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Work that is most related to this paper is TarMAC (Das et al., 2019), where attention mechanism is used to differentiate the importance of incoming messages. In comparison, we use variation inference to decide the content of messages and whether a message should be sent under the guidance of global reward signals. We compare our method with TarMAC and a baseline combining TarMAC and QMIX in our experiments. Related works on the task of StarCraft II unit micromanagement are discussed in Appendix C.2. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/697d563495f9bc44830ce69fbd63ac8f151af2361ff1a0400d421b2726c9f5a0.jpg",
+        "image_caption": [
+            "Figure 2: (a) Task sensor; (b) Performance comparison on sensor; (c) Performance comparison when different percentages of messages are dropped. We measure the drop rate of our method in two ways: count by the number of messages (NDQ) or count by the number of bits (NDQ (bits)). QMIX (5M) is the performance of QMIX after training for 5 million time steps. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            109,
+            823,
+            247
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/0b9b6ea3ede8afe0b06ae9e3c78611b9aa688625417abc6dfd6eb277ecf15018.jpg",
+        "image_caption": [
+            "Figure 3: Message distributions learned by our method on sensor under different values of $\\beta$ . (Messages are cut by bit, if $\\mu < 2 . 0 $ ). A mean of 0 means that the corresponding bit is below the cutting threshold and is not sent. When $\\beta = 1 0 ^ { - 3 }$ , NDQ learns the minimized communication strategy that is effective. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            349,
+            818,
+            626
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 EXPERIMENTAL RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            722,
+            418,
+            738
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In this section, we show our experiments to answer the following questions: (i) Is the miscoordination problem of full value function factorization methods widespread? (ii) Can our method learn the minimized communication protocol required by a task? (iii) Can the learned message distributions reduce uncertainties in value functions of other agents? (iv) How does our method differ from communication with attention mechanism? (v) How does $\\beta$ influence the communication protocol? We will first show three simple examples to clarify our idea from different perspectives and then provide performance analysis on StarCraftII unit micromanagement benchmark. For evaluation, all experiments are carried out with 5 random seeds and results are shown with a $9 5 \\%$ confidence interval. Details of the NDQ network architecture are given in Appendix B.2. Videos of our experiments on StarCraft II are available online2. ",
+        "bbox": [
+            174,
+            756,
+            825,
+            895
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/c85a259dd622d9f8e76e0344646cbc0610a9d596d517aa5bd237c4b228e9b98d.jpg",
+        "image_caption": [
+            "Figure 4: Results on hallway. (a, b) Task hallway and performance comparison. (c) Similar to Fig. 2(c), we show performance comparison when different percentages of messages are dropped. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            108,
+            821,
+            247
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/afba870d2a2086169d01038c92fb7cb153cbf0735ee52dc3947f1b0e193a81b7.jpg",
+        "image_caption": [
+            "Figure 5: Message embedding representations learned by our method on hallway. A mean of 0 means that the corresponding bit is below the cutting threshold $( \\mu { = } 3 )$ and is not sent. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            301,
+            820,
+            469
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We compare NDQ with the following baselines: (i) QMIX (Rashid et al., 2018); (ii) TarMAC (Das et al., 2019). QMIX and TarMAC are state-of-the-art full value function factorization and attentional communication methods, respectively. (iii) QMIX $+$ TarMAC. We introduce the attentional communication mechanism into the value function factorization paradigm by integrating the communication component of TarMAC into QMIX. ",
+        "bbox": [
+            174,
+            537,
+            825,
+            608
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.1 DIDACTIC EXAMPLES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            625,
+            366,
+            640
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We first demonstrate our idea on three didactic examples: sensor, hallway, and independent search. ",
+        "bbox": [
+            174,
+            651,
+            821,
+            666
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Sensor network is a frequently used testbed in multi-agent learning field (Kumar et al., 2011; Zhang & Lesser, 2011). We use a 3-chain sensor configuration in the task sensor (Fig. 2(a)). Each sensor is controlled by one agent, and they are rewarded for successfully locating targets, which requires two sensors to scan the same area simultaneously when the target appears. At each timestep, target 1 appears in area 1 with possibility 1, and locating it induces a team reward of 20; target 2 appears with probability 0.5 in area 2, and agents are rewarded 30 for locating it. Agents can observe whether a target is present in nearby areas and need to choose one of the five actions: scanning north, east, south, west, and noop. Every scan induces a cost of -5. ",
+        "bbox": [
+            174,
+            686,
+            825,
+            797
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In the optimal policy, when target 2 appears, sensor 1 should turn itself off while sensors 2 and 3 are expected to scan area 2 to get the reward. And when target 2 is absent, sensors 1 and 2 need to cooperatively scan area 1 while sensor 3 takes noop. ",
+        "bbox": [
+            176,
+            805,
+            820,
+            847
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Sensor is representative of a class of tasks where the uncertainties about the true states cause policies learned by full value function factorization method to be sub-optimal – sensor 1 has to know whether the target is present in area 2 to make a decision. However, the mixing network of QMIX cannot provide such information. As a result, QMIX converges to a sub-optimal policy, which gets a team reward of 12.5 a step on average (see Fig. 2(b)). ",
+        "bbox": [
+            174,
+            854,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/ce0c797741733d2e79c6c0370c0bb35f936cca8248e7c9807de9388b027eb6da.jpg",
+        "image_caption": [
+            "Figure 6: Snapshots of the StarCraft II scenarios that we consider. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            107,
+            823,
+            319
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We are particularly interested in whether our method can learn the minimized communication strategy. Fig. 3 shows the latent message space learned by NDQ. When $\\beta = 1 0 ^ { - 3 }$ , agent 3 learns to send a bit to tell agent 1 whether target 2 appears. In the meantime, the latent message distribution between any other pair of agents is close to the standard Gaussian distribution and thus is dropped. This result indicates that NDQ has discovered the minimized conditional graph and can explain why our method can still perform optimally when $8 0 \\%$ of the messages are cut off (Fig. 2(c)). When $\\beta$ becomes too large (1.0), all the message bits are pushed below the cutting threshold (Fig. 3(a) and 3(d)). When $\\beta$ is too small $( 1 0 ^ { - 5 } )$ , NDQ pays more attention on reducing uncertainties in Q-functions rather than compressing messages. Correspondingly, both agent 3 and agent 2 send a message to agent 1 (Fig. 3(c) and 3(f)), which is a redundant communication strategy. ",
+        "bbox": [
+            173,
+            380,
+            825,
+            518
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The second example, hallway (Fig. 4(a)), is a Dec-POMDP with two agents randomly starting at states $a _ { 1 }$ to $a _ { m }$ and $b _ { 1 }$ to $b _ { n }$ , respectively. Agents can observe their position and choose to move left, move right, or keep still at each timestep. Agents will win and get a reward of 10 if they arrive at state $g$ simultaneously. Otherwise, if any agent arrives at $g$ earlier than the other, the team will not be rewarded, and the next episode will begin. The horizon is set to $\\operatorname* { m a x } ( m , n ) + 1 0$ to avoid an infinite loop. ",
+        "bbox": [
+            174,
+            526,
+            825,
+            609
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Hallway aims to show that the miscoordination problem of full factorization methods can be severe in multi-step scenarios. We set $m$ and $n$ to 4 and show comparison of performance in Fig. 4(b). The miscoordination problem causes QMIX to lose about half of the games. We are again particularly interested in the message embedding representations learned by NDQ. We show an episode in Fig. 5. Two agents begin at $a _ { 4 }$ and $b _ { 3 }$ , respectively. They first move left silently $\\mathit { t } = 1$ and $t = 2$ ) until agent $\\mathbf { B }$ arrives at $b _ { 1 }$ . On arriving $b _ { 1 }$ , it sends a bit whose value is 5.24 to A. After sending this bit, B stays at $b _ { 1 }$ and sends this message repeatedly until it receives a bit from A indicating that A has arrived at $a _ { 1 }$ . They then move left together and win. This is the minimized communication strategy. Taking advantage of this strategy, NDQ can still win in $100 \\%$ of episodes when $80 \\%$ of the communicating bits are dropped (Fig. 4(c)). ",
+        "bbox": [
+            173,
+            616,
+            825,
+            756
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The third task, independent search, aims to demonstrate that NDQ can learn not to communicate in scenarios where agents are independent. Task description and results analysis are deferred to Appendix C.1. ",
+        "bbox": [
+            174,
+            762,
+            825,
+            804
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.2 MAXIMUM VALUE FUNCTION FACTORIZATION IN STARCRAFT II ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            827,
+            663,
+            840
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "To demonstrate that the miscoordination problem of full decomposition methods is widespread in multi-agent learning, we apply our method and baselines to the StarCraft II micromanagement benchmark introduced by Samvelyan et al. (2019), which is described in detail in Appendix C.2. We further increase the difficulty of action coordination by i) reducing the sight range of agents from 9 to 2; ii) introducing challenging maps with complex terrain or highly random spawning positions for units. We test our method on the six maps shown in Fig. 6. Detailed descriptions of these scenarios are provided in Appendix C.2. ",
+        "bbox": [
+            176,
+            853,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/27eefa79e24e86583e48b47c2fd00c9503591db86e7dba1590ef1f86876845cb.jpg",
+        "image_caption": [
+            "Figure 7: Learning curves of our method and baselines when no message is cut for NDQ and QMIX $^ +$ TarMAC. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            102,
+            825,
+            359
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/7e11c38777d9f0fc6a2b9a94fea1422876b595a2c8fc8817dbf8bfb6df47da57.jpg",
+        "image_caption": [
+            "Figure 8: Performance of our method and QMIX+TarMAC when $8 0 \\%$ of messages are cut off. We also plot the learning curves of QMIX for comparison. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            419,
+            825,
+            676
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            748,
+            821,
+            776
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We use the same hyper-parameter setting for NDQ on all maps: $\\beta$ is set to $1 0 ^ { - 5 }$ , $\\lambda$ is set to 0.1, and the length of message $m _ { i j }$ is set to 3. For evaluation, we pause training every $1 0 0 k$ environment steps and run 48 testing episodes. Other hyper-parameters for NDQ are described in Appendix B.2. ",
+        "bbox": [
+            174,
+            784,
+            825,
+            827
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.2.1 PERFORMANCE COMPARISON ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            842,
+            433,
+            857
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We show the performance of our method and baselines when no message is cut in Fig. 7. The superior performance of NDQ against QMIX demonstrates that the miscoordination problem of full factorization methods is widespread, especially in scenarios with high stochasticity, such as 1o2r vs 4r, 3b vs 1h1m, and 1o10b vs 1r. Notably, our method also outperforms the attentional communication mechanism (QMIX $^ +$ TarMAC) by a large margin. Since agents communicate in both of these two methods and the same TD error is used, these results highlight the role of the constraints that we impose on our message embedding. TarMAC struggles in all the scenarios. We believe that this is because it does not deal with the issue of reward assignment. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/af28aa81ce813b3f5f9c978bf5b815f556e7f0ed15c799cfb5e93f787061147d.jpg",
+        "image_caption": [
+            "Figure 9: Performance of our method and $\\mathrm { Q M X ^ { + } }$ TarMAC when $1 0 0 \\%$ messages are cut off. We also plot the learning curves of QMIX for comparison. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            102,
+            823,
+            359
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            444,
+            825,
+            500
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5.2.2 MESSAGE CUT OFF ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            530,
+            364,
+            545
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "To demonstrate that our method can learn nearly decomposable Q-functions in complex tasks, we cut off $8 0 \\%$ of messages according to the means of distributions when testing and show the results in Fig. 8. The results indicate that we can omit more than $8 0 \\%$ of communication without significantly affecting performance. For comparison, we cut off messages in QMIX $+$ TarMAC whose weights are $8 0 \\%$ smallest and find that its performance drops significantly (Fig. 8). These results indicate that our method is more robust in terms of message cutting off compared to the attentional communication methods. ",
+        "bbox": [
+            174,
+            561,
+            825,
+            659
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We further drop all the messages and show the developments of testing performance in Fig. 9. As expected, the win rates of NDQ decrease dramatically, proving that the superiority of our method when $8 0 \\%$ of messages are dropped comes from expressive and succinct communication protocols. ",
+        "bbox": [
+            174,
+            666,
+            823,
+            708
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 CLOSING REMARKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            743,
+            372,
+            760
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we presented a novel multi-agent learning framework within the paradigm of centralized training with decentralized execution. This framework fuses value function factorization learning and communication learning and efficiently learns nearly decomposable value functions for agents to act most of the time independently and communicate when it is necessary for coordination. We introduce two information-theoretical regularizers to minimize overall communication while maximizing the message information for coordination. Empirical results in challenging StarCraft II tasks show that our method significantly outperforms baseline methods and allows us to reduce communication by more than $8 0 \\%$ without sacrificing the performance. We also observe that nearly minimal messages (e.g., with one or two bits) are learned to communicate between agents in order to ensure effective coordination. ",
+        "bbox": [
+            174,
+            784,
+            825,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            287,
+            117
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alexander A Alemi, Ian Fischer, Joshua V Dillon, and Kevin Murphy. Deep variational information bottleneck. In Proceedings of the International Conference on Learning Representations (ICLR), 2017. ",
+        "bbox": [
+            174,
+            126,
+            823,
+            167
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yongcan Cao, Wenwu Yu, Wei Ren, and Guanrong Chen. An overview of recent progress in the study of distributed multi-agent coordination. IEEE Transactions on Industrial informatics, 9(1): 427–438, 2012. ",
+        "bbox": [
+            171,
+            176,
+            821,
+            219
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Abhishek Das, Satwik Kottur, Jose MF Moura, Stefan Lee, and Dhruv Batra. Learning cooperative ´ visual dialog agents with deep reinforcement learning. In Proceedings of the IEEE International Conference on Computer Vision, pp. 2951–2960, 2017. ",
+        "bbox": [
+            173,
+            228,
+            823,
+            271
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Abhishek Das, Theophile Gervet, Joshua Romoff, Dhruv Batra, Devi Parikh, Mike Rabbat, and ´ Joelle Pineau. Tarmac: Targeted multi-agent communication. In International Conference on Machine Learning, pp. 1538–1546, 2019. ",
+        "bbox": [
+            174,
+            279,
+            823,
+            321
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jakob Foerster, Ioannis Alexandros Assael, Nando de Freitas, and Shimon Whiteson. Learning to communicate with deep multi-agent reinforcement learning. In Advances in Neural Information Processing Systems, pp. 2137–2145, 2016. ",
+        "bbox": [
+            176,
+            330,
+            825,
+            373
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jakob Foerster, Nantas Nardelli, Gregory Farquhar, Triantafyllos Afouras, Philip HS Torr, Pushmeet Kohli, and Shimon Whiteson. Stabilising experience replay for deep multi-agent reinforcement learning. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pp. 1146–1155. JMLR. org, 2017. ",
+        "bbox": [
+            173,
+            381,
+            826,
+            439
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jakob N Foerster, Gregory Farquhar, Triantafyllos Afouras, Nantas Nardelli, and Shimon Whiteson. Counterfactual multi-agent policy gradients. In Thirty-Second AAAI Conference on Artificial Intelligence, 2018. ",
+        "bbox": [
+            173,
+            446,
+            825,
+            489
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Anirudh Goyal, Riashat Islam, Daniel Strouse, Zafarali Ahmed, Matthew Botvinick, Hugo Larochelle, Sergey Levine, and Yoshua Bengio. Infobot: Transfer and exploration via the information bottleneck. In Proceedings of the International Conference on Learning Representations (ICLR), 2019. ",
+        "bbox": [
+            173,
+            497,
+            825,
+            555
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yedid Hoshen. Vain: Attentional multi-agent predictive modeling. In Advances in Neural Information Processing Systems, pp. 2701–2711, 2017. ",
+        "bbox": [
+            169,
+            563,
+            823,
+            593
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Natasha Jaques, Angeliki Lazaridou, Edward Hughes, Caglar Gulcehre, Pedro Ortega, Dj Strouse, Joel Z Leibo, and Nando De Freitas. Social influence as intrinsic motivation for multi-agent deep reinforcement learning. In International Conference on Machine Learning, pp. 3040–3049, 2019. ",
+        "bbox": [
+            173,
+            601,
+            823,
+            645
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jiechuan Jiang and Zongqing Lu. Learning attentional communication for multi-agent cooperation. In Advances in Neural Information Processing Systems, pp. 7254–7264, 2018. ",
+        "bbox": [
+            168,
+            652,
+            821,
+            683
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Daewoo Kim, Sangwoo Moon, David Hostallero, Wan Ju Kang, Taeyoung Lee, Kyunghwan Son, and Yung Yi. Learning to schedule communication in multi-agent reinforcement learning. In Proceedings of the International Conference on Learning Representations (ICLR), 2019. ",
+        "bbox": [
+            174,
+            689,
+            825,
+            733
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Akshat Kumar, Shlomo Zilberstein, and Marc Toussaint. Scalable multiagent planning using probabilistic inference. In Twenty-Second International Joint Conference on Artificial Intelligence, 2011. ",
+        "bbox": [
+            173,
+            741,
+            825,
+            784
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Angeliki Lazaridou, Alexander Peysakhovich, and Marco Baroni. Multi-agent cooperation and the emergence of (natural) language. In Proceedings of the International Conference on Learning Representations (ICLR), 2017. ",
+        "bbox": [
+            173,
+            791,
+            823,
+            835
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ryan Lowe, Yi Wu, Aviv Tamar, Jean Harb, OpenAI Pieter Abbeel, and Igor Mordatch. Multi-agent actor-critic for mixed cooperative-competitive environments. In Advances in Neural Information Processing Systems, pp. 6379–6390, 2017. ",
+        "bbox": [
+            174,
+            843,
+            823,
+            887
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Igor Mordatch and Pieter Abbeel. Emergence of grounded compositional language in multi-agent populations. In Thirty-Second AAAI Conference on Artificial Intelligence, 2018. ",
+        "bbox": [
+            173,
+            895,
+            820,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ann Nowe, Peter Vrancx, and Yann-Micha ´ el De Hauwere. Game theory and multi-agent reinforce- ¨ ment learning. In Reinforcement Learning, pp. 441–470. Springer, 2012. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            133
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Frans A Oliehoek, Christopher Amato, et al. A concise introduction to decentralized POMDPs, volume 1. Springer, 2016. ",
+        "bbox": [
+            171,
+            141,
+            823,
+            170
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Peng Peng, Ying Wen, Yaodong Yang, Quan Yuan, Zhenkun Tang, Haitao Long, and Jun Wang. Multiagent bidirectionally-coordinated nets: Emergence of human-level coordination in learning to play starcraft combat games. arXiv preprint arXiv:1703.10069, 2017. ",
+        "bbox": [
+            176,
+            178,
+            823,
+            222
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Tabish Rashid, Mikayel Samvelyan, Christian Schroeder Witt, Gregory Farquhar, Jakob Foerster, and Shimon Whiteson. Qmix: Monotonic value function factorisation for deep multi-agent reinforcement learning. In International Conference on Machine Learning, pp. 4292–4301, 2018. ",
+        "bbox": [
+            176,
+            229,
+            823,
+            273
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Mikayel Samvelyan, Tabish Rashid, Christian Schroeder de Witt, Gregory Farquhar, Nantas Nardelli, Tim GJ Rudner, Chia-Man Hung, Philip HS Torr, Jakob Foerster, and Shimon Whiteson. The starcraft multi-agent challenge. arXiv preprint arXiv:1902.04043, 2019. ",
+        "bbox": [
+            173,
+            281,
+            825,
+            325
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Amanpreet Singh, Tushar Jain, and Sainbayar Sukhbaatar. Learning when to communicate at scale in multiagent cooperative and competitive tasks. In Proceedings of the International Conference on Learning Representations (ICLR), 2019. ",
+        "bbox": [
+            174,
+            333,
+            825,
+            376
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Kyunghwan Son, Daewoo Kim, Wan Ju Kang, David Earl Hostallero, and Yung Yi. Qtran: Learning to factorize with transformation for cooperative multi-agent reinforcement learning. In International Conference on Machine Learning, pp. 5887–5896, 2019. ",
+        "bbox": [
+            174,
+            385,
+            825,
+            428
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Sainbayar Sukhbaatar, Rob Fergus, et al. Learning multiagent communication with backpropagation. In Advances in Neural Information Processing Systems, pp. 2244–2252, 2016. ",
+        "bbox": [
+            174,
+            436,
+            823,
+            467
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Peter Sunehag, Guy Lever, Audrunas Gruslys, Wojciech Marian Czarnecki, Vinicius Zambaldi, Max Jaderberg, Marc Lanctot, Nicolas Sonnerat, Joel Z Leibo, Karl Tuyls, et al. Value-decomposition networks for cooperative multi-agent learning based on team reward. In Proceedings of the 17th International Conference on Autonomous Agents and MultiAgent Systems, pp. 2085–2087. International Foundation for Autonomous Agents and Multiagent Systems, 2018. ",
+        "bbox": [
+            173,
+            473,
+            825,
+            545
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ardi Tampuu, Tambet Matiisen, Dorian Kodelja, Ilya Kuzovkin, Kristjan Korjus, Juhan Aru, Jaan Aru, and Raul Vicente. Multiagent cooperation and competition with deep reinforcement learning. PloS one, 12(4):e0172395, 2017. ",
+        "bbox": [
+            174,
+            553,
+            821,
+            597
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ming Tan. Multi-agent reinforcement learning: Independent vs. cooperative agents. In Proceedings of the tenth international conference on machine learning, pp. 330–337, 1993. ",
+        "bbox": [
+            171,
+            604,
+            823,
+            635
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Nicolas Usunier, Gabriel Synnaeve, Zeming Lin, and Soumith Chintala. Episodic exploration for deep deterministic policies: An application to starcraft micromanagement tasks. In Proceedings of the International Conference on Learning Representations (ICLR), 2017. ",
+        "bbox": [
+            173,
+            642,
+            823,
+            685
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ying Wen, Yaodong Yang, Rui Luo, Jun Wang, and Wei Pan. Probabilistic recursive reasoning for multi-agent reinforcement learning. In Proceedings of the International Conference on Learning Representations (ICLR), 2019. ",
+        "bbox": [
+            174,
+            694,
+            825,
+            737
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Chongjie Zhang and Victor Lesser. Coordinated multi-agent reinforcement learning in networked distributed pomdps. In Twenty-Fifth AAAI Conference on Artificial Intelligence, 2011. ",
+        "bbox": [
+            173,
+            746,
+            823,
+            775
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Chongjie Zhang and Victor Lesser. Coordinating multi-agent reinforcement learning with limited communication. In Proceedings of the 2013 international conference on Autonomous agents and multi-agent systems, pp. 1101–1108. International Foundation for Autonomous Agents and Multiagent Systems, 2013. ",
+        "bbox": [
+            174,
+            784,
+            825,
+            840
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            264,
+            118
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A VARIATIONAL BOUND ON MUTUAL INFORMATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            135,
+            630,
+            152
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In order to enable messages to effectively reduce the uncertainties in action-value functions of other agents, we propose to maximize the mutual information between $A _ { j }$ and $M _ { i j }$ . We borrow ideas from the variational inference literature and derive a lower bound of this mutual information regularizer. ",
+        "bbox": [
+            173,
+            166,
+            825,
+            209
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Theorem 1. A lower bound of mutual information $I _ { \\pmb { \\theta } _ { c } } ( A _ { j } ; M _ { i j } | \\mathrm { T } _ { j } , M _ { ( - i ) j } )$ is ",
+        "bbox": [
+            174,
+            213,
+            691,
+            229
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/33af5199e5c3df15e2db82b60c02e23ec355cdb8567afa2f8b778965a83ca7b6.jpg",
+        "text": "$$\n\\mathbb { E } _ { \\mathbf { T } \\sim \\mathcal { D } , M _ { j } ^ { i n } \\sim f _ { m } ( \\mathbf { T } , j ; \\theta _ { c } ) } \\left[ - \\mathcal { C } \\mathcal { E } \\left[ p ( A _ { j } | \\mathbf { T } ) \\| q _ { \\xi } ( A _ { j } | \\mathrm { T } _ { j } , M _ { j } ^ { i n } ) \\right] \\right] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            300,
+            237,
+            696,
+            258
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathrm { T } _ { j }$ is the local action-observation history of agent $j$ , and $\\mathbf { T } = \\langle \\mathrm { T } _ { 1 } , \\mathrm { T } _ { 2 } , \\dots , \\mathrm { T } _ { n } \\rangle$ is the joint local history sampled from the replay buffer $\\mathcal { D }$ , $q _ { \\xi } ( A _ { j } | \\mathrm { T } _ { j } , M _ { j } ^ { i n } )$ is the variational posterior estimator with parameters $\\xi$ . ",
+        "bbox": [
+            173,
+            265,
+            825,
+            310
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Proof. ",
+        "bbox": [
+            173,
+            325,
+            217,
+            339
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4c377d1905e2b0ffb6acd283284e267da218fd4ac3cfd8cf119e3429e1d8cb21.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\quad { \\cal I } _ { \\theta _ { c } } ( A _ { j } ; M _ { i j } | T _ { j } , M _ { ( - i ) j } ) } \\\\ & { = \\displaystyle \\int p ( a _ { j } , \\tau _ { j } , m _ { j } ^ { i n } ) \\log \\frac { p ( a _ { j } , m _ { i j } | \\tau _ { j } , m _ { ( - i ) j } ) } { p ( a _ { j } | \\tau _ { j } , m _ { ( - i ) j } ) p ( m _ { i j } | \\tau _ { j } , m _ { ( - i ) j } ) } d a _ { j } d \\tau _ { j } d m _ { j } ^ { i n } } \\\\ & { = \\displaystyle \\int p ( a _ { j } , \\tau _ { j } , m _ { j } ^ { i n } ) \\log \\frac { p ( a _ { j } | \\tau _ { j } , m _ { j } ^ { i n } ) } { p ( a _ { j } | \\tau _ { j } , m _ { ( - i ) j } ) } d a _ { j } d \\tau _ { j } d m _ { j } ^ { i n } , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            264,
+            344,
+            730,
+            441
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "where $p ( a _ { j } | \\tau _ { j } , m _ { j } ^ { i n } )$ is determined by the message encoder $f _ { m }$ and Markov Chain: ",
+        "bbox": [
+            173,
+            448,
+            715,
+            463
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/014a831f89971af1d4b38ee009f53ad6b978c56e6e75402d02acf54f674a4c8d.jpg",
+        "text": "$$\n\\begin{array} { l } { { \\displaystyle p ( a _ { j } | \\tau _ { j } , m _ { j } ^ { i n } ) } } \\\\ { { \\displaystyle = \\int p ( \\tau _ { - j } , a _ { j } | \\tau _ { j } , m _ { j } ^ { i n } ) d \\tau _ { - j } } } \\\\ { { \\displaystyle = \\int p ( \\tau _ { - j } | \\tau _ { j } , m _ { j } ^ { i n } ) p ( a _ { j } | \\tau ) d \\tau _ { - j } \\quad \\mathrm { ( A c c o r d i n g ~ t o ~ \\Gamma  { [ a _ j ~ \\bot ~ } m _ { j } ^ { i n } | \\tau ] ) } } } \\\\ { { \\displaystyle = \\int \\frac { p ( \\tau ) p ( m _ { j } ^ { i n } | \\tau ) p ( a _ { j } | \\tau ) } { p ( \\tau _ { j } , m _ { j } ^ { i n } ) } d \\tau _ { - j } . } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            276,
+            470,
+            720,
+            598
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We introduce $q _ { \\xi } ( a _ { j } | \\tau _ { j } , m _ { j } ^ { i n } )$ as a variational approximation to $p ( a _ { j } | \\tau _ { j } , m _ { j } ^ { i n } )$ . Since ",
+        "bbox": [
+            173,
+            611,
+            722,
+            628
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/46df6cad5f37d6aa53ac7b020727ca2f6d1a0ed1fe189527100a0485207df2c5.jpg",
+        "text": "$$\nD _ { \\mathrm { K L } } ( p ( a _ { j } | \\tau _ { j } , m _ { j } ^ { i n } ) \\Vert q _ { \\xi } ( a _ { j } | \\tau _ { j } , m _ { j } ^ { i n } ) \\geq 0 ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            362,
+            636,
+            633,
+            656
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "we have ",
+        "bbox": [
+            173,
+            661,
+            230,
+            675
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/054e832944b5fd50cc6886d4081af179c5519a9e0b24c6d909210976319c51ef.jpg",
+        "text": "$$\n\\begin{array} { r l } {  { \\int p ( a _ { j } | \\tau _ { j } , m _ { j } ^ { i n } ) \\log p ( a _ { j } | \\tau _ { j } , m _ { j } ^ { i n } ) d a _ { j } } } \\\\ & { \\geq \\int p ( a _ { j } | \\tau _ { j } , m _ { j } ^ { i n } ) \\log q _ { \\xi } ( a _ { j } | \\tau _ { j } , m _ { j } ^ { i n } ) d a _ { j } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            356,
+            680,
+            637,
+            747
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Thus, for the mutual information term: ",
+        "bbox": [
+            173,
+            751,
+            428,
+            766
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4e1ad3ca9c7f554550eec18375a059f0500163e00030a2afdd060a266ff3b266.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\quad I _ { \\theta _ { c } } ( A _ { j } ; M _ { i j } | T _ { j } , \\mathcal { M } _ { ( - i ) j } ) } \\\\ & { \\geq \\displaystyle \\int p ( a _ { j } , \\tau _ { j } , m _ { j } ^ { i n } ) \\log \\frac { q _ { \\xi } ( a _ { j } | \\tau _ { j } , m _ { j } ^ { i n } ) } { p ( a _ { j } | \\tau _ { j } , m _ { ( - i ) j } ) } d a _ { j } d \\tau _ { j } d m _ { j } ^ { i n } } \\\\ & { = \\displaystyle \\int p ( a _ { j } , \\tau _ { j } , m _ { j } ^ { i n } ) \\log q _ { \\xi } ( a _ { j } | \\tau _ { j } , m _ { j } ^ { i n } ) d a _ { j } d \\tau _ { j } d m _ { j } ^ { i n } } \\\\ & { \\quad - \\displaystyle \\int p ( a _ { j } , \\tau _ { j } , m _ { j } ^ { i n } ) \\log p ( a _ { j } | \\tau _ { j } , m _ { ( - i ) j } ) d a _ { j } d \\tau _ { j } d m _ { j } ^ { i n } } \\\\ & { = \\displaystyle \\int p ( \\tau ) p ( m _ { j } ^ { i n } | \\tau ) p ( a _ { j } | \\tau , m _ { j } ^ { i n } ) \\log q _ { \\xi } ( a _ { j } | \\tau _ { j } , m _ { j } ^ { i n } ) d a _ { j } d \\tau d m _ { j } ^ { i n } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            179,
+            771,
+            602,
+            930
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/00268ff314a537ae1a3fe0731b37738303ac2577fc81638b58fd531b90140442.jpg",
+        "text": "$$\n\\begin{array} { l } { { \\displaystyle \\quad - \\int p ( a _ { j } , \\tau _ { j } , m _ { ( - \\cdot ) j _ { j } } ) \\log p ( a _ { j } | \\tau _ { j } , m _ { ( - \\cdot ) j } ) d a _ { j } d \\tau _ { j } d m _ { ( - \\cdot ) j } } } \\\\ { { \\displaystyle = \\int p ( \\tau ) p ( m _ { j } ^ { i n } | \\tau ) p ( a _ { j } | \\tau ) \\log q _ { \\xi } ( a _ { j } | \\tau _ { j } , m _ { j } ^ { i n } ) d a _ { j } d \\tau d m _ { j } ^ { i n } \\quad \\mathrm { ( A c c o r f i n g ~ t o ~ } \\big [ a _ { j } \\perp m _ { j } ^ { i n } | \\tau \\big ] ) } } \\\\ { { \\displaystyle \\quad + H _ { \\theta _ { \\alpha } } ( A _ { j } | \\Gamma _ { j } , M _ { ( - \\cdot \\cdot ) j } ) } } \\\\ { { \\displaystyle = \\mathbb { E } _ { \\mathbf { T } \\sim \\mathcal { P } , M _ { j } ^ { i n } \\sim f _ { m } ( \\mathbf { T } , j _ { \\cdot } | \\theta _ { c } ) } \\left[ \\int p ( a _ { j } | \\mathbf { T } ) \\log q _ { \\xi } ( a _ { j } | \\Gamma _ { j } , M _ { j } ^ { i n } ) d a _ { j } \\right] } } \\\\ { { \\displaystyle \\quad + H _ { \\theta _ { \\alpha } } ( A _ { j } | \\Gamma _ { j } , M _ { ( - \\cdot ) j } ) } } \\\\ { { \\displaystyle = \\mathbb { E } _ { \\mathbf { T } \\sim \\mathcal { P } , M _ { j } ^ { i n } \\sim f _ { m } ( \\mathbf { T } , j _ { \\cdot } | \\theta _ { c } ) } \\left[ - \\mathcal { C } \\mathcal { E } \\left[ p ( A _ { j } | \\mathbf { T } ) \\| q _ { \\xi } ( A _ { j } | \\Gamma _ { j } , M _ { j } ^ { i n } ) \\right] \\right] } } \\\\ { { \\displaystyle \\quad + H _ { \\theta _ { \\alpha } } ( A _ { j } | \\Gamma _ { j } , M _ { ( - \\cdot ) j } ) } } \\\\ { { \\displaystyle \\quad + H _ { \\theta _ { \\alpha } } ( A _ { j } | \\Gamma _ { j } , M _ { ( - \\cdot ) j _ { \\cdot } } ) . } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            178,
+            99,
+            792,
+            282
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Because $H _ { \\pmb \\theta _ { c } } ( A _ { j } | \\mathrm { T } _ { j } , M _ { ( - i ) j } ) \\geq 0$ , we get the lower bound in Theorem 1. ",
+        "bbox": [
+            173,
+            287,
+            653,
+            305
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "B IMPLEMENTATION DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            347,
+            437,
+            363
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "B.1 DETAILS OF MESSAGE DROPPING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            380,
+            450,
+            395
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "In our methods, not only the number of messages but also the length of messages are minimized. In other words, we send messages with varying lengths. However, messages are feed into an actionvalue function approximator at the recipient side, which requires inputs to have the same length. To solve this problem, we send masks indicating which bits are dropped along with the messages. To save channel bandwidth, masks are regarded as binary numbers, so each of them only consumes a negligible log-scale space compared to the length of messages. For the unsent bits, we fill in 0s before feeding the messages into the local utility functions. ",
+        "bbox": [
+            174,
+            406,
+            825,
+            505
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "B.2 NETWORK ARCHITECTURE, HYPERPARAMETERS, AND INFRASTRUCTURE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            523,
+            725,
+            539
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We base our implementation on the PyMARL framework (Samvelyan et al., 2019) and use its default network structure and hyper-parameter setting for QMIX. For the message encoder, we use a fully connected network with one 64-dimensional hidden layer and ReLU activation. For the posterior estimator $q _ { \\xi }$ , we adopt a fully connected network with two 20-dimensional hidden layers with ReLU activation. We train our models on NVIDIA RTX 2080Ti GPUs using experience sampled from 16 parallel environments. To benchmark NDQ, we train all algorithms for 20 million time steps on each StarCraft II unit micromanagement task and use the default hyper-parameter settings for baselines. ",
+        "bbox": [
+            174,
+            550,
+            825,
+            648
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "C EXPERIMENTAL RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            670,
+            421,
+            686
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "C.1 DIDACTIC EXAMPLE: INDEPENDENT SEARCH ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            704,
+            526,
+            718
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "In independent search, two agents are finding landmarks in two independent $5 \\times 5$ rooms for 100 time steps (see Fig. 10). An agent is rewarded 1 when it is on the landmark in its room. ",
+        "bbox": [
+            171,
+            729,
+            823,
+            758
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Independent search is an example where agents are totally independent. This task aims to demonstrate that our method can learn not to communicate in independent scenarios. We show team performance in Table 1. NDQ can achieve the optimal performance when agents do not communicate with each other. ",
+        "bbox": [
+            176,
+            765,
+            825,
+            820
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/63d9ab945e9c02cabfa859366e454e7b3631713344aa910fd5984133e4e41ddd.jpg",
+        "table_caption": [
+            "Table 1: The average team reward gained in an episode on the task independent-search. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>Ours</td><td>QMIX TarMAC</td><td>TarMAC+QMIX</td></tr><tr><td>No message is cut</td><td>96.0 96.0</td><td>96.0</td><td>96.0</td></tr><tr><td>100% messages are cut</td><td>96.0</td><td></td><td>96.0</td></tr></table>",
+        "bbox": [
+            243,
+            859,
+            746,
+            904
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/6bf3d6a764a3b180862d2f7ab36e26a25e81698603806678b3d4aa76ef03ab68.jpg",
+        "image_caption": [
+            "Figure 10: Task Independent-search. Two agents are both reward- and transition-independent. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            336,
+            102,
+            661,
+            227
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "C.2 STARCRAFT II ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            284,
+            320,
+            297
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "StarCraft unit micromanagement has attracted lots of research interests for its high degree of control complexity and environmental stochasticity. Usunier et al. (2017) and Peng et al. (2017) study this problem from a centralized perspective. In order to facilitate decentralized control, we use the setup introduced by Samvelyan et al. (2019). ",
+        "bbox": [
+            174,
+            309,
+            825,
+            364
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "We first describe the scenarios that we consider in detail. We consider combat scenarios where the enemy units are controlled by StarCraft II built-in AI (difficulty level is set to medium), and each of the ally units is controlled by a learning agent. The units of the two groups can be asymmetric, and the initial placement is random. At each time step, each agent chooses one action from the discrete action space consisting of the following actions: noop, move[direction], attack[enemy id], and stop. Under the control of these actions, agents move and attack in a continuous map. A global reward that is equal to the total damage dealt on the enemy units is given at each timestep. Killing each enemy unit and winning a combat induce extra bonuses of 10 and 200, respectively. ",
+        "bbox": [
+            173,
+            372,
+            825,
+            483
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "3b vs 1h1m: 3 Banelings try to kill a Hydralisk assisted by a Medivac. 3 Banelings together can just blow up the Hydralisk. Therefore, they should not give the Hydralisk rest time during which the Medivac can restore its health. Banelings have to attack at the same time to get the winning reward. This scenario is designed to test whether our method can learn a communication protocol to coordinate actions. ",
+        "bbox": [
+            173,
+            489,
+            825,
+            560
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "3s vs 5z: 3 Stalkers encounter 5 Zealots on a map. Zealots can cause high damage but are much slower so that Stalkers have to take advantage of a technique called kiting – Stalkers should alternatively attack the Zealots and flee for a distance. ",
+        "bbox": [
+            174,
+            568,
+            821,
+            609
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "1o2r vs 4r: An Overseer has found 4 Reapers. Its ally units, 2 Roaches, need to get there and kill the Reapers to win. At the beginning of an episode, the Overseer and Reapers spawn at a random point on the map while the Roaches are initialized at another random point. Given that only the Overseer knows the position of the enemy, a learning algorithm has to learn to deliver this message to the Roaches to effectively win the combat. ",
+        "bbox": [
+            174,
+            616,
+            825,
+            686
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "5z vs 1ul: 5 Zealots try to kill a powerful Ultralisk. A sophisticated micro-trick demanding right positioning and attack timing has to be learned to win. ",
+        "bbox": [
+            171,
+            693,
+            823,
+            722
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "MMM: Symmetric teams consisting of 7 Marines, 2 Marauders, and 1 Medivac spawn at two fixed points, and the enemy team is tasked to attack the ally team. To win the battle, agents have to learn to communicate their health to the Medivac. ",
+        "bbox": [
+            173,
+            728,
+            821,
+            770
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "1o10b vs 1r: In a map full of cliffs, an Overseer detects a Roach. The teammates of the Overseer, 10 Banelings, need to kill this Roach to get the winning reward. The Overseer and the Roach spawn at a random point while the Banelings spawn randomly on the map. In the minimized communication strategy, the Banelings can keep silent, and the Overseer needs to encode its position and send it to the Banelings. We use this task to test the performance of our method in complex scenarios. ",
+        "bbox": [
+            173,
+            776,
+            825,
+            848
+        ],
+        "page_idx": 14
+    }
+]

parse/train/SyK00v5xx/SyK00v5xx.md

@@ -0,0 +1,374 @@
+# A SIMPLE BUT TOUGH-TO-BEAT BASELINE FOR SENTENCE EMBEDDINGS
+
+Sanjeev Arora, Yingyu Liang, Tengyu Ma Princeton University {arora,yingyul,tengyu}@cs.princeton.edu
+
+# ABSTRACT
+
+The success of neural network methods for computing word embeddings has motivated methods for generating semantic embeddings of longer pieces of text, such as sentences and paragraphs. Surprisingly, Wieting et al (ICLR’16) showed that such complicated methods are outperformed, especially in out-of-domain (transfer learning) settings, by simpler methods involving mild retraining of word embeddings and basic linear regression. The method of Wieting et al. requires retraining with a substantial labeled dataset such as Paraphrase Database (Ganitkevitch et al., 2013).
+
+The current paper goes further, showing that the following completely unsupervised sentence embedding is a formidable baseline: Use word embeddings computed using one of the popular methods on unlabeled corpus like Wikipedia, represent the sentence by a weighted average of the word vectors, and then modify them a bit using PCA/SVD. This weighting improves performance by about $1 0 \dot { \% }$ to $3 0 \%$ in textual similarity tasks, and beats sophisticated supervised methods including RNN’s and LSTM’s. It even improves Wieting et al.’s embeddings. This simple method should be used as the baseline to beat in future, especially when labeled training data is scarce or nonexistent.
+
+The paper also gives a theoretical explanation of the success of the above unsupervised method using a latent variable generative model for sentences, which is a simple extension of the model in Arora et al. (TACL’16) with new “smoothing” terms that allow for words occurring out of context, as well as high probabilities for words like and, not in all contexts.
+
+# 1 INTRODUCTION
+
+Word embeddings computed using diverse methods are basic building blocks for Natural Language Processing (NLP) and Information Retrieval (IR). They capture the similarities between words (e.g., (Bengio et al., 2003; Collobert & Weston, 2008; Mikolov et al., 2013a; Pennington et al., 2014)). Recent work has tried to compute embeddings that capture the semantics of word sequences (phrases, sentences, and paragraphs), with methods ranging from simple additional composition of the word vectors to sophisticated architectures such as convolutional neural networks and recurrent neural networks (e.g., (Iyyer et al., 2015; Le & Mikolov, 2014; Kiros et al., 2015; Socher et al., 2011; Blunsom et al., 2014; Tai et al., 2015; Wang et al., 2016)). Recently, (Wieting et al., 2016) learned general-purpose, paraphrastic sentence embeddings by starting with standard word embeddings and modifying them based on supervision from the Paraphrase pairs dataset (PPDB), and constructing sentence embeddings by training a simple word averaging model. This simple method leads to better performance on textual similarity tasks than a wide variety of methods and serves as a good initialization for textual classification tasks. However, supervision from the paraphrase dataset seems crucial, since they report that simple average of the initial word embeddings does not work very well.
+
+Here we give a new sentence embedding method that is embarrassingly simple: just compute the weighted average of the word vectors in the sentence and then remove the projections of the average vectors on their first singular vector (“common component removal”). Here the weight of a word $w$ is $a / ( a + p ( w ) )$ with $a$ being a parameter and $p ( w )$ the (estimated) word frequency; we call this smooth inverse frequency (SIF).1 This method achieves significantly better performance than the unweighted average on a variety of textual similarity tasks, and on most of these tasks even beats some sophisticated supervised methods tested in (Wieting et al., 2016), including some RNN and LSTM models. The method is well-suited for domain adaptation settings, i.e., word vectors trained on various kinds of corpora are used for computing the sentence embeddings in different testbeds. It is also fairly robust to the weighting scheme: using the word frequencies estimated from different corpora does not harm the performance; a wide range of the parameters $a$ can achieve close-to-best results, and an even wider range can achieve significant improvement over unweighted average.
+
+Of course, this SIF reweighting is highly reminiscent of TF-IDF reweighting from information retrieval (Sparck Jones, 1972; Robertson, 2004) if one treats a “sentence” as a “document” and make the reasonable assumption that the sentence doesn’t typically contain repeated words. Such reweightings (or related ideas like removing frequent words from the vocabulary) are a good rule of thumb but has not had theoretical justification in a word embedding setting.
+
+The current paper provides a theoretical justification for the reweighting using a generative model for sentences, which is a simple modification for the Random Walk on Discourses model for generating text in (Arora et al., 2016). In that paper, it was noted that the model theoretically implies a sentence embedding, namely, simple average of embeddings of all the words in it.
+
+We modify this theoretical model, motivated by the empirical observation that most word embedding methods, since they seek to capture word cooccurence probabilities using vector inner product, end up giving large vectors to frequent words, as well as giving unnecessarily large inner products to word pairs, simply to fit the empirical observation that words sometimes occur out of context in documents. These anomalies cause the average of word vectors to have huge components along semantically meaningless directions. Our modification to the generative model of (Arora et al., 2016) allows “smoothing” terms, and then a max likelihood calculation leads to our SIF reweighting.
+
+Interestingly, this theoretically derived SIF does better (by a few percent points) than traditional TFIDF in our setting. The method also improves the sentence embeddings of Wieting et al., as seen in Table 1. Finally, we discovered that —contrary to widespread belief—Word2Vec(CBOW) also does not use simple average of word vectors in the model, as misleadingly suggested by the usual expression $\begin{array} { r } { \operatorname* { P r } [ w | w _ { 1 } , w _ { 2 } , \dotsc , w _ { 5 } ] \propto \exp \bigl ( v _ { w } \cdot \big ( \frac { 1 } { 5 } \sum _ { i } v _ { w _ { i } } \big ) \bigr ) } \end{array}$ . A dig into the implementation shows it implicitly uses a weighted average of word vectors —again, different from TF-IDF— and this weighting turns out to be quite similar in effect to ours. (See Section 3.1.)
+
+# 2 RELATED WORK
+
+Word embeddings. Word embedding methods represent words as continuous vectors in a low dimensional space which capture lexical and semantic properties of words. They can be obtained from the internal representations from neural network models of text (Bengio et al., 2003; Collobert & Weston, 2008; Mikolov et al., 2013a) or by low rank approximation of co-occurrence statistics (Deerwester et al., 1990; Pennington et al., 2014). The two approaches are known to be closely related (Levy & Goldberg, 2014; Hashimoto et al., 2016; Arora et al., 2016).
+
+Our work is most directly related work to (Arora et al., 2016), which proposed a random walk model for generating words in the documents. Our sentence vector can be seen as approximate inference of the latent variables in their generative model.
+
+Phrase/Sentence/Paragraph embeddings. Previous works have computed phrase or sentence embeddings by composing word embeddings using operations on vectors and matrices e.g., (Mitchell & Lapata, 2008; 2010; Blacoe & Lapata, 2012). They found that coordinate-wise multiplication of the vectors performed very well among the binary operations studied. Unweighted averaging is also found to do well in representing short phrases (Mikolov et al., 2013a). Another approach is recursive neural networks (RNNs) defined on the parse tree, trained with supervision (Socher et al., 2011) or without (Socher et al., 2014). Simple RNNs can be viewed as a special case where the parse tree is replaced by a simple linear chain. For example, the skip-gram model (Mikolov et al., 2013b) is extended to incorporate a latent vector for the sequence, or to treat the sequences rather than the word as basic units. In (Le & Mikolov, 2014) each paragraph was assumed to have a latent paragraph vector, which influences the distribution of the words in the paragraph. Skip-thought of (Kiros et al., 2015) tries to reconstruct the surrounding sentences from surrounded one and treats the hidden parameters as their vector representations. RNNs using long short-term memory (LSTM) capture long-distance dependency and have also been used for modeling sentences (Tai et al., 2015). Other neural network structures include convolution neural networks, such as (Blunsom et al., 2014) that uses a dynamic pooling to handle input sentences of varying length and do well in sentiment prediction and classification tasks.
+
+The directed inspiration for our work is (Wieting et al., 2016) which learned paraphrastic sentence embeddings by using simple word averaging and also updating standard word embeddings based on supervision from paraphrase pairs; the supervision being used for both initialization and training.
+
+# 3 A SIMPLE METHOD FOR SENTENCE EMBEDDING
+
+We briefly recall the latent variable generative model for text in (Arora et al., 2016). The model treats corpus generation as a dynamic process, where the $t$ -th word is produced at step $t$ . The process is driven by the random walk of a discourse vector $c _ { t } \in \Re ^ { d }$ . Each word $w$ in the vocabulary has a vector in $\Re ^ { d }$ as well; these are latent variables of the model. The discourse vector represents “what is being talked about.” The inner product between the discourse vector $c _ { t }$ and the (time-invariant) word vector $v _ { w }$ for word $w$ captures the correlations between the discourse and the word. The probability of observing a word $w$ at time $t$ is given by a log-linear word production model from Mnih and Hinton:
+
+$$
+\operatorname* { P r } [ w \mathrm { e m i t t e d a t t i m e } t \mid c _ { t } ] \propto \exp \left( \left. c _ { t } , v _ { w } \right. \right) .
+$$
+
+The discourse vector $c _ { t }$ does a slow random walk (meaning that $c _ { t + 1 }$ is obtained from $c _ { t }$ by adding a small random displacement vector), so that nearby words are generated under similar discourses. It was shown in (Arora et al., 2016) that under some reasonable assumptions this model generates behavior –in terms of word-word cooccurrence probabilities—that fits empirical works like word2vec and Glove. The random walk model can be relaxed to allow occasional big jumps in $c _ { t }$ , since a simple calculation shows that they have negligible effect on cooccurrence probabilities of words. The word vectors computed using this model are reported to be similar to those from Glove and word2vec(CBOW).
+
+Our improved Random Walk model. Clearly, it is tempting to define the sentence embedding as follows: given a sentence $s$ , do a MAP estimate of the discourse vectors that govern this sentence. We note that we assume the discourse vector $c _ { t }$ doesn’t change much while the words in the sentence were emitted, and thus we can replace for simplicity all the $c _ { t }$ ’s in the sentence $s$ by a single discourse vector $c _ { s }$ . In the paper (Arora et al., 2016), it was shown that the MAP estimate of $c _ { s }$ is —up to multiplication by scalar—the average of the embeddings of the words in the sentence.
+
+In this paper, towards more realistic modeling, we change the model (1) as follows. This model has two types of “smoothing term”, which are meant to account for the fact that some words occur out of context, and that some frequent words (presumably “the”, “and ” etc.) appear often regardless of the discourse. We first introduce an additive term $\alpha p ( w )$ in the log-linear model, where $p ( w )$ is the unigram probability (in the entire corpus) of word and $\alpha$ is a scalar. This allows words to occur even if their vectors have very low inner products with $c _ { s }$ . Secondly, we introduce a common discourse vector $c _ { 0 } \in \Re ^ { d }$ which serves as a correction term for the most frequent discourse that is often related to syntax. (Other possible correction is left to future work.) It boosts the co-occurrence probability of words that have a high component along $c _ { 0 }$ .
+
+Concretely, given the discourse vector $c _ { s }$ , the probability of a word $w$ is emitted in the sentence $s$ is modeled by,
+
+where $\alpha$ and $\beta$ are scalar hyperparameters, and $\begin{array} { r } { Z _ { \tilde { c } _ { s } } ~ = ~ \sum _ { w \in \mathcal { V } } \exp \left( \langle \tilde { c } _ { s } , v _ { w } \rangle \right) } \end{array}$ is the normalizing constant (the partition function). We see that the model allows a word $w$ unrelated to the discourse
+
+# Algorithm 1 Sentence Embedding
+
+Input: Word embeddings $\{ v _ { w } : w \in \mathcal { V } \}$ , a set of sentences $s$ , parameter $a$ and estimated probabilities $\{ p ( w ) : w \in \mathcal { V } \}$ of the words.
+
+Output: Sentence embeddings $\{ v _ { s } : s \in S \}$
+
+$c _ { s }$ to be emitted for two reasons: a) by chance from the term $\alpha p ( w )$ ; b) if $w$ is correlated with the common discourse vector $c _ { 0 }$ .
+
+Computing the sentence embedding. The word embeddings yielded by our model are actually the same. 2 The sentence embedding will be defined as the max likelihood estimate for the vector $c _ { s }$ that generated it. ( In this case MLE is the same as MAP since the prior is uniform.) We borrow the key modeling assumption of (Arora et al., 2016), namely that the word $v _ { w }$ ’s are roughly uniformly dispersed, which implies that the partition function $Z _ { c }$ is roughly the same in all directions. So assume that $Z _ { \tilde { c } _ { s } }$ is roughly the same, say $Z$ for all $\tilde { c } _ { s }$ . By the model (2) the likelihood for the sentence is
+
+$$
+p [ s \mid c _ { s } ] = \prod _ { w \in s } p ( w \mid c _ { s } ) = \prod _ { w \in s } \left[ \alpha p ( w ) + ( 1 - \alpha ) \frac { \exp \left( \langle v _ { w } , \tilde { c } _ { s } \rangle \right) } { Z } \right] .
+$$
+
+Let
+
+$$
+f _ { w } ( \tilde { c } _ { s } ) = \log \left[ \alpha p ( w ) + ( 1 - \alpha ) \frac { \exp \left( \left. v _ { w } , \tilde { c } _ { s } \right. \right) } { Z } \right]
+$$
+
+denote the log likelihood of sentence $s$ . Then, by simple calculus we have,
+
+$$
+\nabla f _ { w } ( \tilde { c } _ { s } ) = \frac { 1 } { \alpha p ( w ) + ( 1 - \alpha ) \exp \left( \left. v _ { w } , \tilde { c } _ { s } \right. \right) / Z } \frac { 1 - \alpha } { Z } \exp \left( \left. v _ { w } , \tilde { c } _ { s } \right. \right) v _ { w } .
+$$
+
+Then by Taylor expansion, we have,
+
+$$
+\begin{array} { r l } & { f _ { w } ( \tilde { c } _ { s } ) \approx f _ { w } ( 0 ) + \nabla f _ { w } ( 0 ) ^ { \top } \tilde { c } _ { s } } \\ & { \qquad = \mathrm { c o n s t a n t } + \cfrac { ( 1 - \alpha ) / ( \alpha Z ) } { p ( w ) + ( 1 - \alpha ) / ( \alpha Z ) } \left. v _ { w } , \tilde { c } _ { s } \right. . } \end{array}
+$$
+
+Therefore, the maximum likelihood estimator for $\tilde { c } _ { s }$ on the unit sphere (ignoring normalization) is approximately,3
+
+$$
+\arg \operatorname* { m a x } \sum _ { w \in s } f _ { w } ( \tilde { c } _ { s } ) \propto \sum _ { w \in s } \frac { a } { p ( w ) + a } v _ { w } , \mathrm { w h e r e } a = \frac { 1 - \alpha } { \alpha Z } .
+$$
+
+That is, the MLE is approximately a weighted average of the vectors of the words in the sentence. Note that for more frequent words $w$ , the weight $a / ( \bar { p } ( w ) + a )$ is smaller, so this naturally leads to a down weighting of the frequent words.
+
+To estimate $c _ { s }$ , we estimate the direction $c _ { 0 }$ by computing the first principal component of $\tilde { c } _ { s }$ ’s for a set of sentences.4 In other words, the final sentence embedding is obtained by subtracting the projection of $\tilde { c } _ { s }$ ’s to their first principal component. This is summarized in Algorithm 1.
+
+![](images/b377a252afe1dc54e2ff1fbed76b65374de2d393f5f84a7ad3b1e1f1fb653510.jpg)  
+Figure 1: The subsampling probabilities in word2vec are similar to our weighting scheme.
+
+3.1 CONNECTION TO SUBSAMPLING PROBABILITIES IN WORD2VEC
+
+Word2vec (Mikolov et al., 2013b) uses a sub-sampling technique which downsamples word $w$ with probability proportional to $1 / \sqrt { p ( w ) }$ where $p ( w )$ is the marginal probability of the word $w$ . This heuristic not only speeds up the training but also learns more regular word representations. Here we explain that this corresponds to an implicit reweighting of the word vectors in the model and therefore the statistical benefit should be of no surprise.
+
+Recall the vanilla CBOW model of word2vec:
+
+$$
+\operatorname* { P r } [ w _ { t } \mid w _ { t - 1 } , \ldots , w _ { t - 5 } ] \propto \exp \left( \langle \bar { v } _ { t } , v _ { w } \rangle \right) , \mathrm { ~ w h e r e ~ } \bar { v } _ { t } = \frac { 1 } { 5 } \sum _ { i = 1 } ^ { 5 } v _ { w _ { t - i } } .
+$$
+
+It can be shown that the loss (MLE) for the single word vector $v _ { w }$ (from this occurrence) can be abstractly written in the form,
+
+$$
+g ( v _ { w } ) = \gamma ( \langle \bar { v } _ { t } , v _ { w } \rangle ) + \mathrm { n e g a t i v e ~ s a m p l i n g ~ t e r m s } ,
+$$
+
+where $\gamma ( x ) = \log ( 1 / ( 1 + e ^ { - x } ) )$ is the logistic function. Therefore, the gradient of $g ( v _ { w } )$ is
+
+$$
+\nabla g ( v _ { w } ) = \gamma ^ { \prime } ( \langle \bar { v } _ { t } , v _ { w } \rangle ) \bar { v } _ { t } = \alpha ( v _ { w _ { t - 5 } } + v _ { w _ { t - 4 } } + v _ { w _ { t - 3 } } + v _ { w _ { t - 2 } } + v _ { w _ { t - 1 } } ) ,
+$$
+
+where $\alpha$ is a scalar. That is, without the sub-sampling trick, the update direction is the average of the word vectors in the window.
+
+The sub-sampling trick in (Mikolov et al., 2013b) randomly selects the summands in equation (5) to “estimate” the gradient. Specifically, the sampled update direction is
+
+$$
+\tilde { \nabla } g ( v _ { w } ) = \alpha ( J _ { 5 } v _ { w _ { t - 5 } } + J _ { 4 } v _ { w _ { t - 4 } } + J _ { 3 } v _ { w _ { t - 3 } } + J _ { 2 } v _ { w _ { t - 2 } } + J _ { 1 } v _ { w _ { t - 1 } } )
+$$
+
+where Jk’s are Bernoulli random variables with Pr [Jk = 1] = q(wt−k) , min n1, q 10−5p(wt−k) o However, we note that $\tilde { \nabla } g ( v _ { w } )$ is (very) biased estimator! We have that the expectation of $\tilde { \nabla } g ( v _ { w } )$ is a weighted sum of the word vectors,
+
+$$
+\mathring { \mathbb { C } } \left[ \tilde { \nabla } g ( v _ { w } ) \right] = \alpha \big ( q ( w _ { t - 5 } ) v _ { w _ { t - 5 } } + q ( w _ { t - 4 } ) v _ { w _ { t - 4 } } + q ( w _ { t - 3 } ) v _ { w _ { t - 3 } } + q ( w _ { t - 2 } ) v _ { w _ { t - 2 } } + q ( w _ { t - 1 } ) v _ { w _ { t - 1 } } \big )
+$$
+
+In fact, the expectation $\mathbb { E } [ \tilde { \nabla } g ( v _ { w } ) ]$ corresponds to the gradient of a modified word2vec model with the average $\bar { v } _ { t }$ (in equation (4)) being replaced by the weighted average $\begin{array} { r } { \sum _ { k = 1 } ^ { 5 } q ( w _ { t - k } ) v _ { w _ { t - k } } } \end{array}$ . Such a weighted model can also share the same form of what we derive from our random walk model as in equation (3). Moreover, the weighting $q ( w _ { i } )$ closely tracks our weighting scheme $a / ( a +$ $p ( w ) )$ when using parameter $a = 1 0 ^ { - \overline { { 4 } } }$ ; see Figure 1 for an illustration. Therefore, the expected gradient here is approximately the estimated discourse vector in our model! Thus, word2vec with sub-sampling gradient heuristic corresponds to a stochastic gradient update method for using our weighting scheme.
+
+<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=11>Results collected from (Wieting et al.,2016) except tfidf-GloVe</td><td rowspan=1 colspan=2>Our approach</td></tr><tr><td rowspan=1 colspan=1>Supervisedor not</td><td rowspan=1 colspan=7>Su.</td><td rowspan=1 colspan=3>Un.</td><td rowspan=1 colspan=1>Se.</td><td rowspan=1 colspan=1>Un.</td><td rowspan=1 colspan=1>Se.</td></tr><tr><td rowspan=1 colspan=1>Tasks</td><td rowspan=1 colspan=1>PP</td><td rowspan=1 colspan=1>PP-proj.</td><td rowspan=1 colspan=1>DAN</td><td rowspan=1 colspan=1>RNN</td><td rowspan=1 colspan=1>iRNN</td><td rowspan=1 colspan=1>LSTM(no)</td><td rowspan=1 colspan=1>LSTM（0.g.）</td><td rowspan=1 colspan=1>ST</td><td rowspan=1 colspan=1>avg-GloVe</td><td rowspan=1 colspan=1>tfidf-GloVe</td><td rowspan=1 colspan=1>avg-PSL</td><td rowspan=1 colspan=1>GloVe+WR</td><td rowspan=1 colspan=1>PSL+WR</td></tr><tr><td rowspan=1 colspan=1>STS&#x27;12</td><td rowspan=1 colspan=1>58.7</td><td rowspan=1 colspan=1>60.0</td><td rowspan=1 colspan=1>56.0</td><td rowspan=1 colspan=1>48.1</td><td rowspan=1 colspan=1>58.4</td><td rowspan=1 colspan=1>51.0</td><td rowspan=1 colspan=1>46.4</td><td rowspan=1 colspan=1>30.8</td><td rowspan=1 colspan=1>52.5</td><td rowspan=1 colspan=1>58.7</td><td rowspan=1 colspan=1>52.8</td><td rowspan=1 colspan=1>56.2</td><td rowspan=1 colspan=1>59.5</td></tr><tr><td rowspan=1 colspan=1>STS&#x27;13</td><td rowspan=1 colspan=1>55.8</td><td rowspan=1 colspan=1>56.8</td><td rowspan=1 colspan=1>54.2</td><td rowspan=1 colspan=1>44.7</td><td rowspan=1 colspan=1>56.7</td><td rowspan=1 colspan=1>45.2</td><td rowspan=1 colspan=1>41.5</td><td rowspan=1 colspan=1>24.8</td><td rowspan=1 colspan=1>42.3</td><td rowspan=1 colspan=1>52.1</td><td rowspan=1 colspan=1>46.4</td><td rowspan=1 colspan=1>56.6</td><td rowspan=1 colspan=1>61.8</td></tr><tr><td rowspan=1 colspan=1>STS&#x27;14</td><td rowspan=1 colspan=1>70.9</td><td rowspan=1 colspan=1>71.3</td><td rowspan=1 colspan=1>69.5</td><td rowspan=1 colspan=1>57.7</td><td rowspan=1 colspan=1>70.9</td><td rowspan=1 colspan=1>59.8</td><td rowspan=1 colspan=1>51.5</td><td rowspan=1 colspan=1>31.4</td><td rowspan=1 colspan=1>54.2</td><td rowspan=1 colspan=1>63.8</td><td rowspan=1 colspan=1>59.5</td><td rowspan=1 colspan=1>68.5</td><td rowspan=1 colspan=1>73.5</td></tr><tr><td rowspan=1 colspan=1>STS&#x27;15</td><td rowspan=1 colspan=1>75.8</td><td rowspan=1 colspan=1>74.8</td><td rowspan=1 colspan=1>72.7</td><td rowspan=1 colspan=1>57.2</td><td rowspan=1 colspan=1>75.6</td><td rowspan=1 colspan=1>63.9</td><td rowspan=1 colspan=1>56.0</td><td rowspan=1 colspan=1>31.0</td><td rowspan=1 colspan=1>52.7</td><td rowspan=1 colspan=1>60.6</td><td rowspan=1 colspan=1>60.0</td><td rowspan=1 colspan=1>71.7</td><td rowspan=1 colspan=1>76.3</td></tr><tr><td rowspan=1 colspan=1>SICK&#x27;14</td><td rowspan=1 colspan=1>71.6</td><td rowspan=1 colspan=1>71.6</td><td rowspan=1 colspan=1>70.7</td><td rowspan=1 colspan=1>61.2</td><td rowspan=1 colspan=1>71.2</td><td rowspan=1 colspan=1>63.9</td><td rowspan=1 colspan=1>59.0</td><td rowspan=1 colspan=1>49.8</td><td rowspan=1 colspan=1>65.9</td><td rowspan=1 colspan=1>69.4</td><td rowspan=1 colspan=1>66.4</td><td rowspan=1 colspan=1>72.2</td><td rowspan=1 colspan=1>72.9</td></tr><tr><td rowspan=1 colspan=1>Twitter&#x27;15</td><td rowspan=1 colspan=1>52.9</td><td rowspan=1 colspan=1>52.8</td><td rowspan=1 colspan=1>53.7</td><td rowspan=1 colspan=1>45.1</td><td rowspan=1 colspan=1>52.9</td><td rowspan=1 colspan=1>47.6</td><td rowspan=1 colspan=1>36.1</td><td rowspan=1 colspan=1>24.7</td><td rowspan=1 colspan=1>30.3</td><td rowspan=1 colspan=1>33.8</td><td rowspan=1 colspan=1>36.3</td><td rowspan=1 colspan=1>48.0</td><td rowspan=1 colspan=1>49.0</td></tr></table>
+
+Table 1: Experimental results (Pearson’s $r \times 1 0 0 \AA$ ) on textual similarity tasks. The highest score in each row is in boldface. The methods can be supervised (denoted as Su.), semi-supervised (Se.), or unsupervised (Un.). $\mathrm { \bar { G } l o V e + W R ^ { 3 } }$ stands for the sentence embeddings obtained by applying our method to the GloVe word vectors; $\mathrm { ^ { * } P S L + W R ^ { , * } }$ is for PSL word vectors. See the main text for the description of the methods.
+
+# 4 EXPERIMENTS
+
+# 4.1 TEXTUAL SIMILARITY TASKS
+
+Datasets. We test our methods on the 22 textual similarity datasets including all the datasets from SemEval semantic textual similarity (STS) tasks (2012-2015) (Agirre et al., 2012; 2013; 2014; Agirrea et al., 2015), and the SemEval 2015 Twitter task (Xu et al., 2015) and the SemEval 2014 Semantic Relatedness task (Marelli et al., 2014). The objective of these tasks is to predict the similarity between two given sentences. The evaluation criterion is the Pearson’s coefficient between the predicted scores and the ground-truth scores.
+
+Experimental settings. We will compare our method with the following:
+
+1. Unsupervised: ST, avg-GloVe, tfidf-GloVe. ST denotes the skip-thought vectors (Kiros et al., 2015), avg-GloVe denotes the unweighted average of the GloVe vectors (Pennington et al., 2014),5 and tfidf-GloVe denotes the weighted average of GloVe vectors using TF-IDF weights.   
+2. Semi-supervised: avg-PSL. This method uses the unweighted average of the PARAGRAMSL999 (PSL) word vectors from (Wieting et al., 2015). The word vectors are trained using labeled data, but the sentence embedding are computed by unweighted average without training.   
+3. Supervised: PP, PP-proj., DAN, RNN, iRNN, LSTM (o.g.), LSTM (no). All these methods are initialized with PSL word vectors and then trained on the PPDB dataset. PP and PPproj. are proposed in (Wieting et al., 2016). The first is an average of the word vectors, and the second additionally adds a linear projection. The word vectors are updated during the training. DAN denotes the deep averaging network of (Iyyer et al., 2015). RNN denotes the classical recurrent neural network, and iRNN denotes a variant with the activation being the identity, and the weight matrices initialized to identity. The LSTM is the version from (Gers et al., 2002), either with output gates (denoted as LSTM(o.g.)) or without (denoted as LSTM (no)).
+
+Our method can be applied to any types of word embeddings. So we denote the sentence embeddings obtained by applying our method to word embeddings method “XXX” as $\mathrm { \partial \cdot \mathrm { \mathrm { \langle { X X X + W R } ^ { \prime } } } }$ .6 To get a completely unsupervised method, we apply it to the GloVe vectors, denoted as $\mathrm { G l o V e + W R }$ . The weighting parameter $a$ is fixed to $1 0 ^ { - \bar { 3 } }$ , and the word frequencies $p ( w )$ are estimated from the commoncrawl dataset.7 This is denoted by $\mathbf { \Delta G l o V e + W R }$ in Table 1. We also apply our method on the PSL vectors, denoted as $\mathrm { P S L + W R }$ , which is a semi-supervised method.
+
+![](images/e9ed55c9a76cf26b625bef184a4e3653c04e63f29caed16d87fd942772a72565.jpg)  
+Figure 2: Effect of weighting scheme in our method on the average performance on STS 2012 tasks. Best viewed in color. (a) Performance v.s. weighting parameter $a$ . Three types of word vectors (PSL, GloVe, SN) are tested using $p ( w )$ estimated on the enwiki dataset. The best performance is usually achieved at $a = 1 0 ^ { - 3 }$ to $a = 1 0 ^ { - 4 }$ . (b) Performance v.s. datasets used for estimating $p ( w )$ . Four datasets (enwiki, poliblogs, commoncrawl, text8) are used to estimate $p ( w )$ which is then used in our method. The parameter $a$ is fixed to be $1 0 ^ { - 3 }$ . The performance is almost the same for different settings.
+
+Results. The results are reported in Table 1. Each year there are 4 to 6 STS tasks. For clarity, we only report the average result for the STS tasks each year; the detailed results are in the appendix.
+
+The unsupervised method $\mathrm { G l o V e + W R }$ improves upon avg-GloVe significantly by $1 0 \%$ to $3 0 \%$ , and beats the baselines by large margins. It achieves better performance than LSTM and RNN and is comparable to DAN, even though the later three use supervision. This demonstrates the power of this simple method: it can be even stronger than highly-tuned supervisedly trained sophisticated models. Using TF-IDF weighting scheme also improves over the unweighted average, but not as much as our method.
+
+The semi-supervised method $\mathrm { P S L + W R }$ achieves the best results for four out of the six tasks and is comparable to the best in the rest of two tasks. Overall, it outperforms the avg-PSL baseline and all the supervised models initialized with the same PSL vectors. This demonstrates the advantage of our method over the training for those models.
+
+We also note that the top singular vectors $c _ { 0 }$ of the datasets seem to roughly correspond to the syntactic information or common words. For example, closest words (by cosine similarity) to $c _ { 0 }$ in the SICK dataset are “just”, “when”, “even”, “one”, “up”, “little”, “way”, “there”, “while”, and “but.”
+
+Finally, in the appendix, we showed that our two ideas all contribute to the improvement: for GloVe vectors, using smooth inverse frequency weighting alone improves over unweighted average by about $5 \%$ , using common component removal alone improves by $1 0 \%$ , and using both improves by $1 3 \%$ .
+
+# 4.1.1 EFFECT OF WEIGHTING PARAMETER ON PERFORMANCE
+
+We study the sensitivity of our method to the weighting parameter $a$ , the method for computing word vectors, and the estimated word probabilities $p ( w )$ . First, we test the performance of three
+
+<table><tr><td></td><td>PP</td><td>DAN</td><td>RNN</td><td>LSTM (no)</td><td>LSTM (o.g.)</td><td>skip-thought</td><td>Ours</td></tr><tr><td>similarity (SICK)</td><td>84.9</td><td>85.96</td><td>73.13</td><td>85.45</td><td>83.41</td><td>85.8</td><td>86.03</td></tr><tr><td>entailment (SICK)</td><td>83.1</td><td>84.5</td><td>76.4</td><td>83.2</td><td>82.0</td><td>-</td><td>84.6</td></tr><tr><td>sentiment (SST)</td><td>79.4</td><td>83.4</td><td>86.5</td><td>86.6</td><td>89.2</td><td>-</td><td>82.2</td></tr></table>
+
+Table 2: Results on similarity, entailment, and sentiment tasks. The sentence embeddings are computed unsupervisedly, and then used as features in downstream supervised tasks. The row for similarity (SICK) shows Pearson’s $r \times 1 0 0$ and the last two rows show accuracy. The highest score in each row is in boldface. Results in Column 2 to 6 are collected from (Wieting et al., 2016), and those in Column 7 for skip-thought are from (Lei Ba et al., 2016).
+
+types of word vectors (PSL, GloVe, and SN) on the STS 2012 tasks. SN vectors are trained on the enwiki dataset (Wikimedia, 2012) using the method in (Arora et al., 2016), while PSL and GloVe vectors are those used in Table 1. We enumerate $a \in \{ 1 0 ^ { - i } , 3 \times 1 0 ^ { - i } : 1 \leq i \leq 5 \}$ and use the $p ( w )$ estimated on the enwiki dataset. Figure 2a shows that for all three kinds of word vectors, a wide range of $a$ leads to significantly improved performance over the unweighted average. Best performance occurs from $a \overset { \_ } { = } 1 0 ^ { - 3 }$ to $a \overset { = } { = } 1 0 ^ { - 4 }$ .
+
+Next, we fix $a = 1 0 ^ { - 3 }$ and use four very different datasets to estimate $p ( w )$ : enwiki (wikipedia, 3 billion tokens), poliblogs (Yano et al., 2009) (political blogs, 5 million), commoncrawl (Buck et al., 2014) (Internet crawl, 800 billion), text8 (Mahoney, 2008) (wiki subset, 1 million). Figure 2b shows performance is almost the same for all four settings.
+
+The fact that our method can be applied on different types of word vectors trained on different corpora also suggests it should be useful across different domains. This is especially important for unsupervised methods, since the unlabeled data available may be collected in a different domain from the target application.
+
+# 4.2 SUPERVISED TASKS
+
+The sentence embeddings obtained by our method can be used as features for downstream supervised tasks. We consider three tasks: the SICK similarity task, the SICK entailment task, and the Stanford Sentiment Treebank (SST) binary classification task (Socher et al., 2013). To highlight the representation power of the sentence embeddings learned unsupervisedly, we fix the embeddings and only learn the classifier. Setup of supervised tasks mostly follow (Wieting et al., 2016) to allow fair comparison, i.e., the classifier a linear projection followed by the classifier in (Kiros et al., 2015). The linear projection maps the sentence embeddings into 2400 dimension (the same as the skip-thought vectors), and is learned during the training. We compare our method to PP, DAN, RNN, and LSTM, which are the methods used in Section 4.1. We also compare to the skip-thought vectors (with improved training in (Lei Ba et al., 2016)).
+
+Results. Our method gets better or comparable performance compared to the competitors. It gets the best results for two of the tasks. This demonstrates the power of our simple method. We emphasize that our embeddings are unsupervisedly learned, while DAN, RNN, LSTM are trained with supervision. Furthermore, skip-thought vectors are much higher dimensional than ours (though projected into higher dimension, the original 300 dimensional embeddings contain all the information).
+
+The advantage is not as significant as in the textual similarity tasks. This is possibly because similarity tasks rely directly upon cosine similarity, which favors our method’s approach of removing the common components (which can be viewed as a form of denoising), while in supervised tasks, with the cost of some label information, the classifier can pick out the useful components and ignore the common ones.
+
+Finally, we speculate that our method doesn’t outperform RNN’s and LSTM’s for sentiment tasks because (a) the word vectors —and more generally the distributional hypothesis of meaning —has known limitations for capturing sentiment due to the “antonym problem”, (b) also in our weighted average scheme, words like “not” that may be important for sentiment analysis are downweighted a lot. To address (a), there is existing work on learning better word embeddings for sentiment analysis (e.g., (Maas et al., 2011)). To address (b), it is possible to design weighting scheme (or learn weights) for this specific task.
+
+<table><tr><td colspan="2">Dataset</td><td>RNN</td><td>LSTM (no)</td><td>LSTM (o.g.)</td></tr><tr><td rowspan="2">similarity (SICK)</td><td rowspan="2">original random</td><td>73.13</td><td>85.45</td><td>83.41</td></tr><tr><td>54.50</td><td>77.24</td><td>79.39</td></tr><tr><td rowspan="2">entailment (SICK)</td><td rowspan="2">original random</td><td>76.4</td><td>83.2</td><td>82.0</td></tr><tr><td>61.7</td><td>78.2</td><td>81.0</td></tr><tr><td rowspan="2">sentiment (SST)</td><td rowspan="2">original random</td><td>86.5</td><td>86.6</td><td>89.2</td></tr><tr><td>84.2</td><td>82.9</td><td>84.1</td></tr></table>
+
+Table 3: Comparison of results on the original datasets and the ones with words randomly shuffled in sentences. The rows with label “original” are the results on the original datasets, and those with label “random” are the results on the randomly shuffled datasets. The row for similarity (SICK) shows Pearson’s $r \times 1 0 0$ and the other rows show accuracy.
+
+# 4.3 THE EFFECT OF THE ORDER OF WORDS IN SENTENCES
+
+A interesting feature of our method is that it ignores the word order. This is in contrast to that RNN’s and LSTM’s can potentially take advantage of the word order. The fact that our method achieves better or comparable performance on these benchmarks raise the following question: is word order not important in these benchmarks? We conducted an experiment suggesting that word order does play some role.
+
+We trained and tested RNN/LSTM on the supervised tasks where the words in each sentence are randomly shuffled, and the results are reported in Table 3.8 It can be observed that the performance drops noticeably. Thus our method —which ignores word order—must be much better at exploiting the semantics than RNN’s and LSTM’s. An interesting future direction is to explore if some ensemble idea can combine the advantages of both approaches.
+
+# 5 CONCLUSIONS
+
+This work provided a simple approach to sentence embedding, based on the discourse vectors in the random walk model for generating text (Arora et al., 2016). It is simple and unsupervised, but achieves significantly better performance than baselines on various textual similarity tasks, and can even beat sophisticated supervised methods such as some RNN and LSTM models. The sentence embeddings obtained can be used as features in downstream supervised tasks, which also leads to better or comparable results compared to the sophisticated methods.
+
+# 6 ACKNOWLEDGEMENTS
+
+We thank the reviewers for insightful comments. We also thank the authors of (Wieting et al., 2016;   
+Bowman et al., 2015) for sharing their code or the preprocessed datasets.
+
+This work was supported in part by NSF grants CCF-1527371, DMS-1317308, Simons Investigator Award, Simons Collaboration Grant, and ONRN00014- 16-1-2329. Tengyu Ma was supported in addition by Simons Award in Theoretical Computer Science and IBM PhD Fellowship.
+
+# REFERENCES
+
+Eneko Agirre, Mona Diab, Daniel Cer, and Aitor Gonzalez-Agirre. Semeval-2012 task 6: A pilot on semantic textual similarity. In Proceedings of the First Joint Conference on Lexical and Computational Semantics-Volume 1: Proceedings of the main conference and the shared task, and Volume 2: Proceedings of the Sixth International Workshop on Semantic Evaluation, pp. 385–393. Association for Computational Linguistics, 2012.
+
+Eneko Agirre, Daniel Cer, Mona Diab, Aitor Gonzalez-Agirre, and Weiwei Guo. Sem 2013 shared task: Semantic textual similarity. in second joint conference on lexical and computational semantics. In Proceedings of the Main Conference and the Shared Task: Semantic Textual Similarity, 2013.
+
+Eneko Agirre, Carmen Banea, Claire Cardie, Daniel Cer, Mona Diab, Aitor Gonzalez-Agirre, Weiwei Guo, Rada Mihalcea, German Rigau, and Janyce Wiebe. Semeval-2014 task 10: Multilingual semantic textual similarity. In Proceedings of the 8th international workshop on semantic evaluation (SemEval 2014), pp. 81–91, 2014.
+
+Eneko Agirrea, Carmen Baneab, Claire Cardiec, Daniel Cerd, Mona Diabe, Aitor Gonzalez-Agirrea, Weiwei Guof, Inigo Lopez-Gazpioa, Montse Maritxalara, Rada Mihalceab, et al. Semeval-2015 task 2: Semantic textual similarity, english, spanish and pilot on interpretability. In Proceedings of the 9th international workshop on semantic evaluation (SemEval 2015), pp. 252–263, 2015.
+
+Sanjeev Arora, Yuanzhi Li, Yingyu Liang, Tengyu Ma, and Andrej Risteski. A latent variable model approach to PMI-based word embeddings. Transaction of Association for Computational Linguistics, 2016.
+
+Yoshua Bengio, Rejean Ducharme, Pascal Vincent, and Christian Jauvin. A neural probabilistic ´ language model. Journal of Machine Learning Research, 2003.
+
+William Blacoe and Mirella Lapata. A comparison of vector-based representations for semantic composition. In Proceedings of the 2012 Joint Conference on Empirical Methods in Natural Language Processing and Computational Natural Language Learning, 2012.
+
+Phil Blunsom, Edward Grefenstette, and Nal Kalchbrenner. A convolutional neural network for modelling sentences. In Proceedings of the 52nd Annual Meeting of the Association for Computational Linguistics, 2014.
+
+Samuel R. Bowman, Gabor Angeli, Christopher Potts, and Christopher D. Manning. A large annotated corpus for learning natural language inference. In Proceedings of the 2015 Conference on Empirical Methods in Natural Language Processing (EMNLP). Association for Computational Linguistics, 2015.
+
+Christian Buck, Kenneth Heafield, and Bas van Ooyen. N-gram counts and language models from the common crawl. In Proceedings of the Language Resources and Evaluation Conference, 2014.
+
+Ronan Collobert and Jason Weston. A unified architecture for natural language processing: Deep neural networks with multitask learning. In Proceedings of the 25th International Conference on Machine Learning, 2008.
+
+Scott C. Deerwester, Susan T Dumais, Thomas K. Landauer, George W. Furnas, and Richard A. Harshman. Indexing by latent semantic analysis. Journal of the American Society for Information Science, 1990.
+
+Felix A Gers, Nicol N Schraudolph, and Jurgen Schmidhuber. Learning precise timing with lstm ¨ recurrent networks. Journal of machine learning research, 2002.
+
+Tatsunori B. Hashimoto, David Alvarez-Melis, and Tommi S. Jaakkola. Word embeddings as metric recovery in semantic spaces. Transactions of the Association for Computational Linguistics, 2016.
+
+Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural computation, 1997.
+
+Mohit Iyyer, Varun Manjunatha, Jordan Boyd-Graber, and Hal Daume III. Deep unordered com- ´ position rivals syntactic methods for text classification. In Proceedings of the Association for Computational Linguistics, 2015.
+
+Ryan Kiros, Yukun Zhu, Ruslan R Salakhutdinov, Richard Zemel, Raquel Urtasun, Antonio Torralba, and Sanja Fidler. Skip-thought vectors. In Advances in neural information processing systems, 2015.
+
+Quoc Le and Tomas Mikolov. Distributed representations of sentences and documents. In Proceedings of The 31st International Conference on Machine Learning, 2014.
+
+J. Lei Ba, J. R. Kiros, and G. E. Hinton. Layer Normalization. ArXiv e-prints, 2016.
+
+Omer Levy and Yoav Goldberg. Neural word embedding as implicit matrix factorization. In Advances in Neural Information Processing Systems, 2014.
+
+Andrew L Maas, Raymond E Daly, Peter T Pham, Dan Huang, Andrew $\mathrm { ~ Y ~ N ~ g ~ } _ { }$ , and Christopher Potts. Learning word vectors for sentiment analysis. In Proceedings of the 49th Annual Meeting of the Association for Computational Linguistics: Human Language Technologies-Volume $^ { l }$ , pp. 142–150. Association for Computational Linguistics, 2011.
+
+Matt Mahoney. Wikipedia text preprocess script. http://mattmahoney.net/dc/textdata.html, 2008. Accessed Mar-2015.
+
+Marco Marelli, Luisa Bentivogli, Marco Baroni, Raffaella Bernardi, Stefano Menini, and Roberto Zamparelli. Semeval-2014 task 1: Evaluation of compositional distributional semantic models on full sentences through semantic relatedness and textual entailment. SemEval-2014, 2014.
+
+Tomas Mikolov, Ilya Sutskever, Kai Chen, Greg S. Corrado, and Jeff Dean. Distributed representations of words and phrases and their compositionality. In Advances in Neural Information Processing Systems, 2013a.
+
+Tomas Mikolov, Wen-tau Yih, and Geoffrey Zweig. Linguistic regularities in continuous space word representations. In Proceedings of the Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, 2013b.
+
+Jeff Mitchell and Mirella Lapata. Vector-based models of semantic composition. In Association for Computational Linguistics, 2008.
+
+Jeff Mitchell and Mirella Lapata. Composition in distributional models of semantics. Cognitive science, 2010.
+
+Ellie Pavlick, Pushpendre Rastogi, Juri Ganitkevitch, Benjamin Van Durme2, and Chris CallisonBurch. Ppdb 2.0: Better paraphrase ranking, fine-grained entailment relations, word embeddings, and style classification. Proceedings of the Annual Meeting of the Association for Computational Linguistics, 2015.
+
+Jeffrey Pennington, Richard Socher, and Christopher D. Manning. Glove: Global vectors for word representation. Proceedings of the Empiricial Methods in Natural Language Processing, 2014.
+
+Stephen Robertson. Understanding inverse document frequency: on theoretical arguments for idf. Journal of documentation, 2004.
+
+Richard Socher, Eric H Huang, Jeffrey Pennin, Christopher D Manning, and Andrew Y Ng. Dynamic pooling and unfolding recursive autoencoders for paraphrase detection. In Advances in Neural Information Processing Systems, 2011.
+
+Richard Socher, Alex Perelygin, Jean Y Wu, Jason Chuang, Christopher D Manning, Andrew $\mathrm { \Delta Y N g }$ , and Christopher Potts. Recursive deep models for semantic compositionality over a sentiment treebank. In Proceedings of the conference on empirical methods in natural language processing (EMNLP), 2013.
+
+Richard Socher, Andrej Karpathy, Quoc V Le, Christopher D Manning, and Andrew $\textsf { Y } \mathrm { N g }$ . Grounded compositional semantics for finding and describing images with sentences. Transactions of the Association for Computational Linguistics, 2014.
+
+Karen Sparck Jones. A statistical interpretation of term specificity and its application in retrieval. Journal of documentation, 1972.
+
+Kai Sheng Tai, Richard Socher, and Christopher D Manning. Improved semantic representations from tree-structured long short-term memory networks. arXiv preprint arXiv:1503.00075, 2015.
+
+Sida Wang and Christopher D Manning. Baselines and bigrams: Simple, good sentiment and topic classification. In Proceedings of the 50th Annual Meeting of the Association for Computational Linguistics: Short Papers-Volume 2, pp. 90–94. Association for Computational Linguistics, 2012.
+
+Yashen Wang, Heyan Huang, Chong Feng, Qiang Zhou, Jiahui Gu, and Xiong Gao. Cse: Conceptual sentence embeddings based on attention model. In Proceedings of the 54th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), 2016.
+
+John Wieting, Mohit Bansal, Kevin Gimpel, Karen Livescu, and Dan Roth. From paraphrase database to compositional paraphrase model and back. Transactions of the Association for Computational Linguistics, 2015.
+
+John Wieting, Mohit Bansal, Kevin Gimpel, and Karen Livescu. Towards universal paraphrastic sentence embeddings. In International Conference on Learning Representations, 2016.
+
+Wikimedia. English Wikipedia dump. http://dumps.wikimedia.org/enwiki/latest/enwiki-latestpages-articles.xml.bz2, 2012. Accessed Mar-2015.
+
+Wei Xu, Chris Callison-Burch, and William B Dolan. Semeval-2015 task 1: Paraphrase and semantic similarity in twitter (pit). Proceedings of SemEval, 2015.
+
+Tae Yano, William W Cohen, and Noah A Smith. Predicting response to political blog posts with topic models. In Proceedings of Human Language Technologies: The 2009 Annual Conference of the North American Chapter of the Association for Computational Linguistics, 2009.
+
+# A DETAILS OF EXPERIMENTAL SETTING
+
+A.1 UNSUPERVISED TASK: TEXTUAL SIMILARITY
+
+The competitors. We give a brief overview of the competitors. RNN is the classical recurrent neural network:
+
+$$
+h _ { t } = f ( W _ { x } W _ { w } ^ { x _ { t } } + W _ { h } h _ { t - 1 } + b )
+$$
+
+where $f$ is the activation, $W _ { x } , W _ { h }$ and $b$ are parameters, and $x _ { t }$ is the $t$ -th token in the sentence. The sentence embedding of RNN is just the hidden vector of the last token. iRNN is a special RNN with the activation being the identity, the weight matrices initialized to identity, and $b$ initialized to zero. LSTM (Hochreiter & Schmidhuber, 1997) is a recurrent neural network architecture designed to capture long-distance dependencies. Here, the version from (Gers et al., 2002) is used.
+
+The supervised methods are initialized with PARAGRAM-SL999 (PSL) vectors, and trained using the approach of (Wieting et al., 2016) on the XL section of the PPDB data (Pavlick et al., 2015) which contains about 3 million unique phrase pairs. After training, the final models can be used to generate sentence embeddings on the test data. For hyperparameter tuning they used $1 0 0 \mathrm { k }$ examples sampled from PPDB XXL and trained for 5 epochs. Then after finding the hyperparameters that maximize Spearman’s coefficients on the Pavlick et al. PPDB task, they are trained on the entire XL section of PPDB for 10 epochs. See (Wieting et al., 2016) and related papers for more details about these methods.
+
+The tfidf-GloVe method is a weighted average of the GloVe vectors, where the weights are defined by the TF-IDF scheme. More precisely, the embedding of a sentence $s$ is
+
+$$
+v _ { s } = { \frac { 1 } { | s | } } \sum _ { w \in s } { \mathrm { I D F } } _ { w } v _ { w }
+$$
+
+where $\mathrm { I D F } _ { w }$ is the inverse document frequency of $w$ , and $| s |$ denotes the number of words in the sentence. Here, the TF part of the TF-IDF scheme is taken into account by the sum over $w \in s$ . Furthermore, when computing $\mathrm { I D F } _ { w }$ , each sentence is viewed as a “document”:
+
+$$
+\mathrm { I D F } _ { w } : = \log \frac { 1 + N } { 1 + N _ { w } }
+$$
+
+where $N$ is the total number of sentences and $N _ { w }$ is the number of sentences containing $w$ , and 1 is added to avoid division by 0. In the experiments, we use all the textual similarity datasets to compute $\mathrm { I D F } _ { w }$ .
+
+Detailed experimental results. In the main body we present the average results for STS tasks by year. Each year there are actually 4 to 6 STS tasks, as shown in Table 4. Note that tasks with the same name in different years are actually different tasks. Here we provide the results for each tasks in Table 5. $\mathrm { P S L + W R }$ achieves the best results on 12 out of 22 tasks, PP and PP-proj. achieves on 3, tfidf-GloVe achieves on 2, and DAN, iRNN, and $\mathbf { \mathrm { G l o V e } } \mathbf { + } \mathbf { \mathrm { W R } }$ achieves on 1. In general, our method improves the performance significantly compared to the unweighted average, though on rare cases such as MSRpar it can decrease the performance.
+
+<table><tr><td>STS&#x27;12</td><td>STS&#x27;13</td><td>STS&#x27;14</td><td>STS&#x27;15</td></tr><tr><td>MSRpar</td><td>headline</td><td>deft forum</td><td>anwsers-forums</td></tr><tr><td>MSRvid</td><td>OnWN</td><td>deft news</td><td>answers-students</td></tr><tr><td>SMT-eur</td><td>FNWN</td><td>headline</td><td>belief</td></tr><tr><td>OnWN</td><td>SMT</td><td>images</td><td>headline</td></tr><tr><td>SMT-news</td><td></td><td>OnWN</td><td>images</td></tr><tr><td colspan="4">tweet news</td></tr></table>
+
+Table 4: The STS tasks by year. Note that tasks with the same name in different years are actually different tasks.
+
+<table><tr><td></td><td colspan="10">Results collected from (Wieting et al.,2016) except tfidf-GloVe</td><td colspan="3">Our approach</td></tr><tr><td>Supervised or not</td><td colspan="6">Su.</td><td colspan="3">Un.</td><td>Se.</td><td>Un.</td><td>Se.</td></tr><tr><td>Tasks</td><td>PP</td><td>PP -proj.</td><td>DAN</td><td>RNN</td><td>iRNN</td><td>LSTM (no）</td><td>LSTM （o.g）</td><td>ST</td><td>avg- GloVe</td><td>tfidf- GloVe</td><td>avg- GloVe PSL +WR</td><td>PSL +WR</td></tr><tr><td>MSRpar MSRvid</td><td>42.6 74.5</td><td>43.7 74.0</td><td>40.3 70.0 43.8</td><td>18.6 66.5 40.9</td><td>43.4 73.4 47.1</td><td>16.1 71.3 41.8</td><td>9.3 71.3 44.3</td><td>16.8 47.7 41.7 63.9</td><td>50.3 77.9</td><td>41.6 60.0</td><td>35.6 83.8</td><td>43.3 84.1</td></tr><tr><td>SMT-eur OnWN SMT-news</td><td>47.3 70.6 58.4</td><td>49.4 70.1 62.8</td><td>65.9 60.0</td><td>63.1 51.3</td><td>70.1 58.1</td><td>65.2 60.8</td><td>35.2 56.4 29.7 51.0 30.8</td><td>46.0 55.1 49.6</td><td>54.7 64.7 45.7</td><td>42.4 63.0 57.0</td><td>49.9 66.2 45.6</td><td>44.8 71.8</td></tr><tr><td>STS&#x27;12 headline</td><td>58.7 72.4</td><td>60.0 72.6</td><td>56.0 71.2 64.1</td><td>48.1 59.5 54.6</td><td>58.4 72.8 69.4</td><td>51.0 46.4 57.4 48.5 68.5 50.4</td><td>30.8 34.6 10.0</td><td>52.5 63.8 49.0</td><td>58.7 69.2 72.9</td><td>52.8 68.8</td><td>56.2 69.2</td><td>53.6 59.5 74.1</td></tr><tr><td>OnWN FNWN SMT</td><td>67.7 43.9 39.2</td><td>68.0 46.8 39.8</td><td>43.1 38.3 54.2</td><td>30.9 33.8 44.7</td><td>45.3 39.4 56.7</td><td>24.7 30.1</td><td>38.4 30.4 28.8 24.3 24.8</td><td>34.2 22.3 42.3</td><td>36.6 29.6 52.1</td><td>48.0 37.9 31.0 46.4</td><td>82.8 39.4 37.9</td><td>82.0 52.4 38.5</td></tr><tr><td>STS&#x27;13 deft forum deft news headline</td><td>55.8 48.7 73.1 69.7</td><td>56.8 51.1 72.2 70.8</td><td>49.0 71.7 69.2</td><td>41.5 53.7 57.5</td><td>49.0 72.4 70.2</td><td>45.2 44.2 52.8 57.5</td><td>41.5 46.1 39.1 50.9</td><td>12.9 27.1 23.5 68.0 37.8 59.5</td><td>37.5 68.7 63.7</td><td>37.2 67.0</td><td>56.6 41.2 69.4 64.7</td><td>61.8 51.4 72.6 70.1</td></tr><tr><td>images OnWN tweet news STS&#x27;14</td><td>78.5 78.8 76.4 70.9</td><td>78.1 79.5 75.8 71.3</td><td>76.9 75.7 74.2 69.5</td><td>67.6 67.7 58.0 57.7</td><td>78.2 78.8 76.9 70.9</td><td>68.5 76.9 58.7 59.8</td><td>62.9 51.2 61.7 23.3 48.2 39.9 51.5 31.4</td><td>61.0 58.4 51.2 54.2</td><td>72.5 75.2 65.1 63.8</td><td>65.3 62.0 61.1 64.7 59.5</td><td>82.6 82.8 70.1 68.5</td><td>84.8 84.5 77.5 73.5</td></tr><tr><td>answers-forum answers-student belief</td><td>68.3 78.2 76.2</td><td>65.1 77.8 75.4</td><td>62.6 78.1</td><td>32.8 64.7</td><td>67.4 78.2</td><td>51.9 71.5</td><td>50.7 36.1 55.7</td><td>30.5 63.0</td><td>45.6 63.9</td><td>38.8 69.2</td><td>63.9 70.4 71.8</td><td>70.1 75.9</td></tr><tr><td>images</td><td>81.4</td><td>80.3</td><td>77.5</td><td>71.4</td><td>81.1 75.6</td><td>70.4 63.9</td><td>64.2</td><td>17.7</td><td>67.5</td><td>72.9</td><td>69.9</td><td></td></tr><tr><td>SICK&#x27;14</td><td></td><td></td><td>70.7</td><td>61.2</td><td>71.2</td><td>63.9</td><td>59.0</td><td>49.8</td><td>65.9</td><td></td><td>71.7</td><td></td></tr><tr><td></td><td></td><td></td><td>72.7</td><td>57.2</td><td></td><td></td><td>56.0</td><td></td><td></td><td></td><td>60.0</td><td></td></tr><tr><td></td><td></td><td></td><td>73.5</td><td>65.3</td><td></td><td></td><td>52.6</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>headline</td><td></td><td></td><td>72.0</td><td>51.9</td><td>75.9</td><td>61.7</td><td></td><td>33.0 24.6 43.6</td><td>40.5</td><td>49.5</td><td>53.2 69.0</td><td></td></tr><tr><td></td><td>74.8</td><td>75.2</td><td></td><td></td><td></td><td>64.0</td><td>56.6</td><td></td><td>61.8</td><td>70.9</td><td></td><td>75.3</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td>75.1</td><td></td><td></td><td></td><td></td><td></td><td>70.7 81.5</td><td>75.9 84.1</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td>31.0</td><td>52.7</td><td></td><td></td><td></td></tr><tr><td>STS&#x27;15</td><td>75.8</td><td>74.8</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td>60.6</td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td>76.3</td></tr><tr><td></td><td>71.6</td><td>71.6</td><td>53.7</td><td>45.1</td><td></td><td></td><td></td><td></td><td></td><td></td><td>72.2</td><td>72.9</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td>66.4</td><td></td></tr><tr><td>Twitter&#x27;15</td><td>52.9</td><td>52.8</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td>69.4</td><td>36.3</td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td><td>52.9</td><td>47.6</td><td>36.1</td><td>24.7</td><td>30.3</td><td>33.8</td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td>48.0</td><td>49.0</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr></table>
+
+Table 5: Experimental results (Pearson’s $r \times 1 0 0 \AA$ ) on textual similarity tasks. The highest score in each row is in boldface. The methods can be supervised (denoted as Su.), semi-supervised (Se.), or unsupervised (Un.). $\mathrm { \bar { G } l o V e + W R ^ { 3 } }$ stands for the sentence embeddings obtained by applying our method to the GloVe word vectors; $\mathrm { \ddot { \ P S L } + W R ^ { \prime \prime } }$ is for PSL word vectors. See the main text for the description of the methods.
+
+Effects of smooth inverse frequency and common component removal. There are two key ideas in our methods: smooth inverse frequency weighting (W) and common component removal (R). It is instructive to see their effects separately. Let $\mathrm { G l o V e { + } W }$ denote the embeddings using only smooth inverse frequency, and $\mathrm { G l o V e { + } R }$ denote that using only common component removal. Similarly define $\mathrm { P S L + W }$ and $\mathrm { P S L + R }$ . The results for these methods are shown in Table 6. When using GloVe vectors, W alone improves the performance of the unweighted average baseline by about $5 \%$ , R alone improves by $1 \bar { 0 } \%$ , W and $\mathbf { R }$ together improves by $\mathrm { { 1 3 \% } }$ . When using PSL vectors, W gets $1 0 \%$ , R gets $1 0 \%$ , W and R together gets $1 3 \%$ . In summary, both techniques are important for obtaining significant advantage over the unweighted average.
+
+# A.2 SUPERVISED TASKS
+
+Setup of supervised tasks mostly follow (Wieting et al., 2016) to allow fair comparison: the sentence embeddings are fixed and fed into some classifier which are trained. For the SICK similarity task, given a pair of sentences with embeddings $v _ { L }$ and $v _ { R }$ , first do a linear projection:
+
+$$
+h _ { L } = W _ { p } v _ { L } , h _ { R } = W _ { p } v _ { R }
+$$
+
+where $W _ { p }$ is of size $3 0 0 \times d _ { p }$ and is learned during training. $d _ { p } = 2 4 0 0$ matches the dimension of the skip-thought vectors. Then $h _ { L }$ and $h _ { R }$ are used in the objective function from (Tai et al., 2015). Almost the same approach is used for the entailment task.For the sentiment task, the classifier has a fully-connected layer with a sigmoid activation followed by a softmax layer.
+
+Recall that our method has two steps: smooth inverse frequency weighting and common component removal. For the experiments here, we do not perform the common component removal, since it can be absorbed into the projection step. For the weighted average, the hyperparameter $a$ is enumerated in $\{ 1 0 ^ { - i } , 3 \times 1 0 ^ { - i } : ^ { 2 } \stackrel { . } { \leq } i \leq 3 \}$ . The other hyperparameters are enumerated as in (Wieting et al., 2016), and the same validation approach is used to select the final values.
+
+Table 6: Experimental results (Pearson’s $r \times 1 0 0 ^ { \cdot }$ ) on textual similarity tasks using only smooth inverse frequency, using only common component removal, or using both.   
+
+<table><tr><td></td><td colspan="4">Unsupervised</td><td colspan="4">Semi-supervised</td></tr><tr><td>Tasks</td><td>avg-GloVe</td><td>GloVe+W</td><td>GloVe+R</td><td>GloVe+WR</td><td>avg-PSL</td><td>PSL+W</td><td>PSL+R</td><td>PSL+WR</td></tr><tr><td>MSRpar</td><td>47.7</td><td>43.6</td><td>36.4</td><td>35.6</td><td>41.6</td><td>40.9</td><td>42.5</td><td>43.3</td></tr><tr><td>MSRvid</td><td>63.9</td><td>78.7</td><td>79.4</td><td>83.8</td><td>60.0</td><td>80.4</td><td>76.4</td><td>84.1</td></tr><tr><td>SMT-eur</td><td>46.0</td><td>51.1</td><td>48.5</td><td>49.9</td><td>42.4</td><td>45.0</td><td>45.1</td><td>44.8</td></tr><tr><td>OnWN</td><td>55.1</td><td>54.3</td><td>68.3</td><td>66.2</td><td>63.0</td><td>67.8</td><td>71.0</td><td>71.8</td></tr><tr><td>SMT-news</td><td>49.6</td><td>42.2</td><td>45.6</td><td>45.6</td><td>57.0</td><td>56.2</td><td>50.7</td><td>53.6</td></tr><tr><td>STS&#x27;12</td><td>52.5</td><td>54.0</td><td>55.6</td><td>56.2</td><td>52.8</td><td>58.1</td><td>57.2</td><td>59.5</td></tr><tr><td>headline</td><td>63.8</td><td>63.8</td><td>68.9</td><td>69.2</td><td>68.8</td><td>72.6</td><td>72.7</td><td>74.1</td></tr><tr><td>OnWN</td><td>49.0</td><td>68.0</td><td>75.4</td><td>82.8</td><td>48.0</td><td>69.8</td><td>73.5</td><td>82.0</td></tr><tr><td>FNWN</td><td>34.2</td><td>23.0</td><td>34.9</td><td>39.4</td><td>37.9</td><td>49.3</td><td>40.7</td><td>52.4</td></tr><tr><td>SMT</td><td>22.3</td><td>29.5</td><td>36.4</td><td>37.9</td><td>31.0</td><td>39.2</td><td>37.3</td><td>38.5</td></tr><tr><td>STS&#x27;13</td><td>42.3</td><td>44.0</td><td>53.9</td><td>56.6</td><td>46.4</td><td>57.7</td><td>56.0</td><td>61.8</td></tr><tr><td>deft forum</td><td>27.1</td><td>29.1</td><td>39.8</td><td>41.2</td><td>37.2</td><td>45.8</td><td>45.3</td><td>51.4</td></tr><tr><td>deft news</td><td>68.0</td><td>68.5</td><td>66.6</td><td>69.4</td><td>67.0</td><td>75.1</td><td>67.4</td><td>72.6</td></tr><tr><td>headline</td><td>59.5</td><td>59.3</td><td>64.6</td><td>64.7</td><td>65.3</td><td>68.9</td><td>68.5</td><td>70.1</td></tr><tr><td>images</td><td>61.0</td><td>74.1</td><td>78.4</td><td>82.6</td><td>62.0</td><td>82.9</td><td>80.2</td><td>84.8</td></tr><tr><td>OnWN</td><td>58.4</td><td>68.0</td><td>77.6</td><td>82.8</td><td>61.1</td><td>77.6</td><td>77.7</td><td>84.5</td></tr><tr><td>tweet news</td><td>51.2</td><td>57.3</td><td>73.2</td><td>70.1</td><td>64.7</td><td>73.6</td><td>77.9</td><td>77.5</td></tr><tr><td>STS&#x27;14</td><td>54.2</td><td>59.4</td><td>66.7</td><td>68.5</td><td>59.5</td><td>70.7</td><td>69.5</td><td>73.5</td></tr><tr><td>answers-forum</td><td>30.5</td><td>41.4</td><td>58.4</td><td>63.9</td><td>38.8</td><td>56.0</td><td>61.0</td><td>70.1</td></tr><tr><td>answers-student</td><td>63.0</td><td>61.5</td><td>73.2</td><td>70.4</td><td>69.2</td><td>73.3</td><td>76.8</td><td>75.9</td></tr><tr><td>belief</td><td>40.5</td><td>47.7</td><td>69.5</td><td>71.8</td><td>53.2</td><td>64.3</td><td>71.3</td><td>75.3</td></tr><tr><td>headline</td><td>61.8</td><td>64.0</td><td>70.1</td><td>70.7</td><td>69.0</td><td>74.5</td><td>74.6</td><td>75.9</td></tr><tr><td>images</td><td>67.5</td><td>75.4</td><td>77.9</td><td>81.5</td><td>69.9</td><td>83.4</td><td>79.9</td><td>84.1</td></tr><tr><td>STS&#x27;15</td><td>52.7</td><td>58.0</td><td>69.8</td><td>71.7</td><td>60.0</td><td>70.3</td><td>72.7</td><td>76.3</td></tr><tr><td>SICK&#x27;14</td><td>65.9</td><td>70.5</td><td>70.6</td><td>72.2</td><td>66.4</td><td>73.1</td><td>70.3</td><td>72.9</td></tr><tr><td>Twitter&#x27;15</td><td>30.3</td><td>33.8</td><td>50.6</td><td>48.0</td><td>36.3</td><td>45.7</td><td>51.9</td><td>49.0</td></tr></table>
+
+# A.3 ADDITIONAL SUPERVISED TASKS
+
+Here we report the experimental results on two more datasets, comparing to known results on them.
+
+SNLI. The first experiment is for the 3-class classification task on the SNLI dataset (Bowman et al., 2015). To compare to the results in (Bowman et al., 2015), we used their experimental setup. In particular, we applied our method to 300 dimensional GloVe vectors and used an additional tanh neural network layer to map these 300d embeddings into 300 dimensional space, then used the code provided by the authors of (Bowman et al., 2015), trained the classifier on our 100 dimensional sentence embedding for 120 passes over the data, using their default hyperparameters. The results are shown in Table 7. Our method indeed gets slightly better performance.
+
+Our test accuracy is worse than those using more sophisticated models (e.g., using attention mechanism), which are typically $8 3 \% - 8 8 \%$ ; see the website of the SNLI project9 for a summary. An interesting direction is to study whether our idea can be combined with these sophisticated models to get improved performance.
+
+<table><tr><td>Sentence model</td><td>Train</td><td>Test</td></tr><tr><td>100d Sum ofwords</td><td>79.3</td><td>75.3</td></tr><tr><td>100d RNN</td><td>73.1</td><td>72.2</td></tr><tr><td>100dLSTMRNN</td><td>84.8</td><td>77.6</td></tr><tr><td>Our method</td><td>83.9</td><td>78.2</td></tr></table>
+
+Table 7: Accuracy in 3-class classification on the SNLI dataset for each model. The results in the first three rows are collected from (Bowman et al., 2015). All methods used 100 dimensional sentence embeddings.
+
+IMDB. The second experiment is the sentiment analysis task on the IMDB dataset, studied in (Wang & Manning, 2012). Since the intended application is semi-supervised or transfer learning, we also compared performance with fewer labeled examples.
+
+<table><tr><td>#labeled examples NB-SVM</td><td>Our method</td></tr><tr><td>50k 0.91</td><td>0.85</td></tr><tr><td>1k 0.84</td><td>0.82</td></tr><tr><td>200 0.73</td><td>0.77</td></tr></table>
+
+Table 8: Accuracy in sentiment analysis on the IMDB dataset for NB-SVM (Wang & Manning, 2012) and our method.
+
+Our method gets worse performance on the full dataset, but its decrease in performance is better with less labeled examples, showing the benefit of using word embeddings. Note that our sentence embeddings are unsupervised, while that in the NB-SVM method takes advantage of the labels. Another comment is that sentiment analysis appears to be the best case for Bag-Of-Word methods, whereas it may be the worst case for word embedding methods (See Table 2) due to the well-known antonymy problem —distributional hypothesis fails for distinguishing “good” from “bad.”

parse/train/ry018WZAZ/ry018WZAZ.md

@@ -0,0 +1,368 @@
+# DEEP ACTIVE LEARNING FOR NAMED ENTITY RECOGNITION
+
+Yanyao Shen   
+UT Austin   
+Austin, TX 78712   
+shenyanyao@utexas.edu
+
+Hyokun Yun Amazon Web Services Seattle, WA 98101 yunhyoku@amazon.com
+
+Zachary C. Lipton Amazon Web Services Seattle, WA 98101 liptoz@amazon.com
+
+Yakov Kronrod Amazon Web Services Seattle, WA 98101 kronrod@amazon.com
+
+Animashree Anandkumar Amazon Web Services Seattle, WA 98101 anima@amazon.com
+
+# ABSTRACT
+
+Deep learning has yielded state-of-the-art performance on many natural language processing tasks including named entity recognition (NER). However, this typically requires large amounts of labeled data. In this work, we demonstrate that the amount of labeled training data can be drastically reduced when deep learning is combined with active learning. While active learning is sample-efficient, it can be computationally expensive since it requires iterative retraining. To speed this up, we introduce a lightweight architecture for NER, viz., the CNN-CNN-LSTM model consisting of convolutional character and word encoders and a long short term memory (LSTM) tag decoder. The model achieves nearly state-of-the-art performance on standard datasets for the task while being computationally much more efficient than best performing models. We carry out incremental active learning, during the training process, and are able to nearly match state-of-the-art performance with just $2 5 \%$ of the original training data.
+
+# 1 INTRODUCTION
+
+Over the past few years, papers applying deep neural networks (DNNs) to the task of named entity recognition (NER) have successively advanced the state-of-the-art (Collobert et al., 2011; Huang et al., 2015; Lample et al., 2016; Chiu & Nichols, 2016; Yang et al., 2016). However, under typical training procedures, the advantages of deep learning diminish when working with small datasets. For instance, on the OntoNotes-5.0 English dataset, whose training set contains 1,088,503 words, a DNN model outperforms the best shallow model by $2 . 2 4 \%$ as measured by F1 score (Chiu & Nichols, 2016). However, on the comparatively small CoNLL-2003 English dataset, whose training set contains 203,621 words, the best DNN model enjoys only a $0 . 4 \%$ advantage. To make deep learning more broadly useful, it is crucial to reduce its training data requirements.
+
+Generally, the annotation budget for labeling is far less than the total number of available (unlabeled) samples. For NER, getting unlabeled data is practically free, owing to the large amount of content that can be efficiently scraped off the web. On the other hand, it is especially expensive to obtain annotated data for NER since it requires multi-stage pipelines with sufficiently well-trained annotators (Kilicoglu et al., 2016; Bontcheva et al., 2017). In such cases, active learning offers a promising approach to efficiently select the set of samples for labeling. Unlike the supervised learning setting, in which examples are drawn and labeled at random, in the active learning setting, the algorithm can choose which examples to label.
+
+Active learning aims to select a more informative set of examples in contrast to supervised learning, which is trained on a set of randomly drawn examples. A central challenge in active learning is to determine what constitutes more informative and how the active learner can recognize this based on what it already knows. The most common approach is uncertainty sampling, in which the model preferentially selects examples for which it’s current prediction is least confident. Other approaches include representativeness-based sampling where the model selects a diverse set that represent the input space without adding too much redundancy.
+
+In this work, we investigate practical active learning algorithms on lightweight deep neural network architectures for the NER task. Training with active learning proceeds in multiple rounds. Traditional active learning schemes are expensive for deep learning since they require complete retraining of the classifier with newly annotated samples after each round. In our experiments, for example, the model must be retrained 54 times. Because retraining from scratch is not practical, we instead carry out incremental training with each batch of new labels: we mix newly annotated samples with the older ones, and update our neural network weights for a small number of epochs, before querying for labels in a new round. This modification drastically reduces the computational requirements of active learning methods and makes it practical to deploy them.
+
+We further reduce the computational complexity by selecting a lightweight architecture for NER. We propose a new CNN-CNN-LSTM architecture for NER consisting of a convolutional character-level encoder, convolutional word-level encoder, and long short term memory (LSTM) tag decoder. This model handles out-of-vocabulary words gracefully and, owing to the greater reliance on convolutions (vs recurrent layers), trains much faster than other deep models while performing competitively.
+
+We introduce a simple uncertainty-based heuristic for active learning with sequence tagging. Our model selects those sentences for which the length-normalized log probability of the current prediction is the lowest. Our experiments with the Onto-Notes 5.0 English and Chinese datasets demonstrate results comparable to the Bayesian active learning by disagreement method (Gal et al., 2017). Moreover our heuristic is faster to compute since it does not require multiple forward passes. On the OntoNotes-5.0 English dataset, our approach matches $9 9 \%$ of the F1 score achieved by the best deep models trained in a standard, supervised fashion despite using only a $2 4 . 9 \%$ of the data. On the OntoNotes-5.0 Chinese dataset, we match $9 9 \%$ performance with only $3 0 . 1 \%$ of the data. Thus, we are able to achieve state of art performance with drastically lower number of samples.
+
+# 2 RELATED WORK
+
+Deep learning for named entity recognition The use of DNNs for NER was pioneered by Collobert et al. (2011), who proposed an architecture based on temporal convolutional neural networks (CNNs) over the sequence of words. Since then, many papers have proposed improvements to this architecture. Huang et al. (2015) proposed to replace CNN encoder in Collobert et al. (2011) with bidirectional LSTM encoder, while Lample et al. (2016) and Chiu & Nichols (2016) introduced hierarchy in the architecture by replacing hand-engineered character-level features in prior works with additional bidirectional LSTM and CNN encoders respectively. In other related work, Mesnil et al. (2013) and Nguyen et al. (2016) pioneered the use of recurrent neural networks (RNNs) for decoding tags. However, most recent competitive approaches rely upon CRFs as decoder (Lample et al., 2016; Chiu & Nichols, 2016; Yang et al., 2016). In this work, we demonstrate that LSTM decoders outperform CRF decoders and are faster to train when the number of entity types is large.
+
+Active learning While learning-theoretic properties of active learning algorithms are wellstudied (Dasgupta et al., 2005; Balcan et al., 2009; Awasthi et al., 2014; Yan & Zhang, 2017; Beygelzimer et al., 2009), classic algorithms and guarantees cannot be generalized to DNNs, which are currently are the state-of-the-art techniques for NER. Owing to the limitations of current theoretical analysis, more practical active learning applications employ a range of heuristic procedures for selecting examples to query. For example, Tong & Koller (2001) suggests a margin-based selection criteria, while Settles & Craven (2008) while Shen et al. (2004) combines multiple criteria for NLP tasks. Culotta & McCallum (2005) explores the application of least confidence criterion for linear CRF models on sequence prediction tasks. For a more comprehensive review of the literature, we refer to Settles (2010) and Olsson (2009).
+
+Deep active learning While DNNs have achieved impressive empirical results across diverse applications (Krizhevsky et al., 2012; Hinton et al., 2012; Manning, 2016), active learning approaches for these models have yet to be well studied, and most current work addresses image classification. Wang et al. (2016) claims to be the first to study active learning for image classification with CNNs and proposes methods based on uncertainty-based sampling, while Gal et al. (2017) and Kendall & Gal (2017) show that sampling based on a Bayesian uncertainty measure can be more advantageous. In one related paper, Zhang et al. (2017) investigate active learning for sentence classification with
+
+<table><tr><td>Character-Level Encoder</td><td>Word-Level Encoder</td><td>Tag Decoder</td><td>Reference</td></tr><tr><td>None</td><td>CNN</td><td>CRF</td><td>Collobert et al. (2011)</td></tr><tr><td>None</td><td>RNN</td><td>RNN</td><td>Mesnil et al. (2013)</td></tr><tr><td>None</td><td>RNN</td><td>GRU</td><td>Nguyen et al. (2016)</td></tr><tr><td>None</td><td>LSTM</td><td>CRF</td><td>Huang et al. (2015)</td></tr><tr><td>LSTM</td><td>LSTM</td><td>CRF</td><td>Lample et al. (2016)</td></tr><tr><td>CNN</td><td>LSTM</td><td>CRF</td><td>Chiu &amp; Nichols (2016)</td></tr><tr><td>CNN</td><td>LSTM</td><td>LSTM,Pointer Networks</td><td>Zhai et al. (2017)</td></tr><tr><td>GRU</td><td>GRU</td><td>CRF</td><td>Yang et al. (2016)</td></tr><tr><td>None</td><td>Dilated CNN</td><td>Independent Softmax, CRF</td><td>Strubell et al. (2017)</td></tr><tr><td>CNN</td><td>CNN</td><td>LSTM</td><td>Ours</td></tr></table>
+
+Table 1: Prior works on neural architectures for sequence tagging, and their corresponding design choices.
+
+CNNs. However, to our knowledge, prior to this work, deep active learning for sequence tagging tasks, which often have structured output space and variable-length input, has not been studied.
+
+# 3 NER MODEL DESCRIPTION
+
+Most active learning methods require frequent retraining of the model as new labeled examples are acquired. Therefore, it is crucial that the model can be efficiently retrained. On the other hand, we would still like to reach the level of performance rivaling state-of-the-art DNNs.
+
+To accomplish this, we first identify that many DNN architectures for NER can be decomposed into three components: 1) the character-level encoder, which extracts features for each word from characters, 2) the word-level encoder which extracts features from the surrounding sequence of words, and 3) the tag decoder, which induces a probability distribution over any sequences of tags. This conceptual framework allows us to view a variety of DNNs in a unified perspective; see Table 1.
+
+Owing to the superior computational efficiency of CNNs over LSTMs, we propose a lightweight neural network architecture for NER, which we name CNN-CNN-LSTM and describe below.
+
+<table><tr><td>Formatted Sentence</td><td>[BOS]</td><td>Kate</td><td>lives</td><td>on</td><td>Mars</td><td>[EOS]</td><td>[PAD]</td></tr><tr><td>Tag</td><td>0</td><td>S-PER</td><td>0</td><td>0</td><td>S-LOC</td><td>0</td><td>0</td></tr></table>
+
+Table 2: Example formatted sentence. To avoid clutter, [BOW] and [EOW] symbols are not shown.
+
+Data Representation We represent each input sentence as follows; First, special [BOS] and [EOS] tokens are added at the beginning and the end of the sentence, respectively. In order to batch the computation of multiple sentences, sentences with similar length are grouped together into buckets, and [PAD] tokens are added at the end of sentences to make their lengths uniform inside of the bucket. We follow an analogous procedure to represent the characters in each word. For example, the sentence ‘Kate lives on Mars’ is formatted as shown in Table 2. The formatted sentence is denoted as $\{ { \bf { x } } _ { i j } \}$ , where $\mathbf { x } _ { i j }$ is the one-hot encoding of the $j$ -th character in the $i$ -th word.
+
+Character-Level Encoder For each word $i$ , we use CNNs (LeCun et al., 1995) to extract characterlevel features $\mathbf { w } _ { i } ^ { \mathrm { c h a r } }$ (Figure 1). While LSTM recurrent neural network (Hochreiter & Schmidhuber, 1997) slightly outperforms CNN as a character-level encoder, the improvement is not statistically significant and the computational cost of LSTM encoders is much higher than CNNs (see Section 5, also Reimers & Gurevych (2017) for detailed analysis).
+
+We apply ReLU nonlinearities (Nair & Hinton, 2010) and dropout (Srivastava et al., 2014) between CNN layers, and include a residual connection between input and output of each layer (He et al., 2016). So that our representation of the word is of fixed length, we apply max-pooling on the outputs of the topmost layer of the character-level encoder (Kim, 2014).
+
+![](images/6683af6a0971f14bb33b5c1dbf0b43f27e69577cf02b102ab048fd733e75c4f6.jpg)  
+Figure 1: Example CNN architecture for Character-level Encoder with two layers.
+
+Word-Level Encoder To complete our representation of each word, we concatenate its characterlevel features with $\mathbf { w } _ { i } ^ { \mathrm { e m b } }$ , a latent word embedding corresponding to that word:
+
+$$
+\mathbf { w } _ { i } ^ { \mathrm { f u l l } } : = \left( \mathbf { w } _ { i } ^ { \mathrm { c h a r } } , \mathbf { w } _ { i } ^ { \mathrm { e m b } } \right) .
+$$
+
+We initialize the latent word embeddings with with word2vec training Mikolov et al. (2013) and then update the embeddings over the course of training. In order to generalize to words unseen in the training data, we replace each word with a special [UNK] (unknown) token with $50 \%$ probability during training, an approach that resembles the word-drop method due to Lample et al. (2016).
+
+Given the sequence of word-level input features $\mathbf { w } _ { 1 } ^ { \mathrm { f u l l } } , \mathbf { w } _ { 2 } ^ { \mathrm { f u l l } } , \dots , \mathbf { w } _ { n } ^ { \mathrm { f u l l } }$ , we extract word-level representations $\mathbf { \bar { h } } _ { 1 } ^ { \mathrm { E n c } } , \mathbf { h } _ { 2 } ^ { \mathrm { E n c } } , \ldots , \mathbf { h } _ { n } ^ { \mathrm { E n c } }$ 1 2 nfor each word position in the sentence using a CNN. In Figure 2, we depict an instance of our architecture with two convolutional layers and kernels of width 3. We concatenate the representation at the $l$ -th convolutional layer $\mathbf { h } _ { i } ^ { ( l ) }$ , with the input features $\mathbf { w } _ { i } ^ { \mathrm { f u l l } }$ :
+
+$$
+\mathbf { h } _ { i } ^ { \mathrm { E n c } } = \left( \mathbf { h } _ { i } ^ { ( l ) } , \mathbf { w } _ { i } ^ { \mathrm { f u l l } } \right)
+$$
+
+![](images/d6d9baf18d15c02107109169ae934dcb7fc2ffe6f5cf38aaaadba38e5ebd6e3b.jpg)  
+Figure 2: Example CNN architecture for Word-level Encoder with two layers.
+
+LSTM RNNs can also perform word-level encoding Huang et al. (2015), and models with LSTM word-level encoding give a slight (but not significant) boost over CNN word-level encoders in terms of F1 score (see Section 5). However, CNN word-level encoders are considerably faster (Strubell et al., 2017), which is crucial for the iterative retraining in our active learning scheme.
+
+Tag Decoder The tag decoder induces a probability distribution over sequences of tags, conditioned on the word-level encoder features: $\mathbf { \bar { \mathbb { P } } } [ y _ { 2 } , y _ { 3 } , \ldots , y _ { n - 1 } \ | \ \middle \{ \mathbf { h } _ { i } ^ { \mathrm { E n c } } \} ] ^ { 1 }$ . Chain CRF (Lafferty et al., 2001) is a popular choice for tag decoder, adopted by most modern DNNs for NER:
+
+$$
+\mathbb { P } \left[ t _ { 2 } , t _ { 3 } , \dots , t _ { n - 1 } \middle \vert \left\{ \mathbf { h } _ { i } ^ { \mathrm { E n c } } \right\} \right] \propto \exp \left( \sum _ { i = 2 } ^ { n - 1 } \left\{ W \mathbf { h } _ { i } ^ { \mathrm { E n c } } + b \right\} _ { t _ { i } } + A _ { t _ { i - 1 } , t _ { i } } \right) ,
+$$
+
+where $W$ , A, b are learnable parameters, and $\{ \cdot \} _ { t _ { i } }$ refers to the $t _ { i }$ -th coordinate of the vector. To compute the partition function of (1), which is required for training, usually dynamic programming is employed, and its time complexity is $O ( n T ^ { 2 } )$ where $T$ is the number of entity types (Collobert et al., 2011).
+
+Alternatively, we use an LSTM RNN for the tag decoder, as depicted in Figure 3. At the first time step, the [GO]-symbol is provided as $y _ { 1 }$ to the decoder LSTM. At each time step $i$ , the LSTM decoder computes $\mathbf { h } _ { i + 1 } ^ { \mathrm { D e c } }$ , the hidden state for decoding word $i + 1$ , using the last tag $y _ { i }$ , the current decoder hidden state $\mathbf { h } _ { i } ^ { \mathrm { D e c } }$ , and the learned representation of next word $\mathbf { h } _ { i + 1 } ^ { \mathrm { E n c } }$ . Using a softmax loss function, $y _ { i + 1 }$ is decoded; this is further fed as an input to the next time step.
+
+![](images/10095e0f091becdfce4783f31f68cbd62538b19909d162e3149e44895062b50d.jpg)  
+Figure 3: LSTM architecture for Tag Decoder.
+
+Since this is a locally normalized model (Andor et al., 2016), it does not require the costly computation of partition function, and it allows us to significantly speed up training compared to using CRFs. Also, we observed that while it is computationally intractable to find the best sequence of tags with an LSTM decoder, greedily decoding tags from left to right yields the performance comparable to chain CRF decoder (see Appendix A). While the use of RNNs tag decoders has been explored (Mesnil et al., 2013; Nguyen et al., 2016; Zhai et al., 2017), we demonstrate for the first time that models using RNNs instead of CRFs for tag decoder can achieve state-of-the-art performance. See Section 5.
+
+# 4 ACTIVE LEARNING
+
+Labeling data for NER usually requires manual annotations by human experts, which are costly to acquire at scale. Active learning seeks to ameliorate this problem by strategically choosing which examples to annotate, in the hope of getting greater performance with fewer annotations. To this end, we consider the following setup for interactively acquiring annotations. The learning process consists of multiple rounds: At the beginning of each round, the active learning algorithm chooses sentences to be annotated up to the predefined budget. After receiving annotations, we update the model parameters by training on the augmented dataset, and proceeds to the next round. We assume that the cost of annotating a sentence is proportional to the number of words in the sentence and that every word in the selected sentence must be annotated at once, i.e. we do not allow or account for partially annotated sentences.
+
+While various existing active learning strategies suit this setup (Settles, 2010), we explore the uncertainty sampling strategy. With the uncertainty-based sampling strategy (Lewis & Gale, 1994), we rank the unlabeled examples according to the current model’s uncertainty in its prediction of the corresponding labels. We consider three ranking methods, each of which can be easily implemented in the CNN-CNN-LSTM model or most other deep neural approaches to NER.
+
+Least Confidence (LC): Culotta & McCallum (2005) proposed to sort examples in ascending order according to the probability assigned by the model to the most likely sequence of tags:
+
+$$
+1 - \operatorname* { m a x } _ { y _ { 1 } , \ldots , y _ { n } } \mathbb { P } \left[ y _ { 1 } , \ldots , y _ { n } \middle \vert \left\{ { \bf x } _ { i j } \right\} \right] .
+$$
+
+Exactly computing (2) requires identifying the most likely sequence of tags according to the LSTM decoder. Because determining the most likely sequence is intractable, we approximate the score by using the probability assigned to the greedily decoded sequence.
+
+Maximum Normalized Log-Probability (MNLP): Preliminary analysis revealed that the LC method disproportionately selects longer sentences. Note that sorting unlabeled examples in descending order by (2) is equivalent to sorting in ascending order by the following scores:
+
+$$
+\begin{array} { r l r } { \underset { y _ { 1 } , \ldots , y _ { n } } { \operatorname* { m a x } } } & { } & { \mathbb { P } \left[ y _ { 1 } , \ldots , y _ { n } \middle \vert \left\{ \mathbf { x } _ { i j } \right\} \right] \Leftrightarrow \underset { y _ { 1 } , \ldots , y _ { n } } { \operatorname* { m a x } } \underset { i = 1 } { \overset { n } { \prod } } \mathbb { P } \left[ y _ { i } \middle \vert y _ { 1 } , \ldots , y _ { n - 1 } , \left\{ \mathbf { x } _ { i j } \right\} \right] } \\ & { } & { \Leftrightarrow \underset { y _ { 1 } , \ldots , y _ { n } } { \operatorname* { m a x } } \underset { i = 1 } { \overset { n } { \sum } } \log \mathbb { P } \left[ y _ { i } \middle \vert y _ { 1 } , \ldots , y _ { n - 1 } , \left\{ \mathbf { x } _ { i j } \right\} \right] . } \end{array}
+$$
+
+Since (3) contains summation over words, LC method naturally favors longer sentences. Because longer sentences requires more labor for annotation, we find this undesirable, and propose to normalize (3) as follows, which we call Maximum Normalized Log-Probability method:
+
+$$
+\operatorname* { m a x } _ { y _ { 1 } , \ldots , y _ { n } } { \frac { 1 } { n } } \sum _ { i = 1 } ^ { n } \log \mathbb { P } \left[ y _ { i } \mid y _ { 1 } , \ldots , y _ { n - 1 } , \left\{ \mathbf { x } _ { i j } \right\} \right] .
+$$
+
+Bayesian Active Learning by Disagreement (BALD): We also consider sampling according to the measure of uncertainty proposed by Gal et al. (2017). Observing a correspondence between dropout (Srivastava et al., 2014) and deep Gaussian processes (Damianou & Lawrence, 2013), they propose that the variability of the predictions over successive forward passes due to dropout can be interpreted as a measure of the model’s uncertainty (Gal & Ghahramani, 2016). Denote $\mathbb { P } ^ { 1 ^ { \bullet } , \mathbb { P } ^ { 2 } , \dots . \mathbb { P } ^ { M } }$ as models resulting from applying $M$ independently sampled dropout masks. One measure of our uncertainty on the $i$ th word is $f _ { i }$ , the fraction of models which disagreed with the most popular choice:
+
+$$
+f _ { i } = 1 - \frac { \operatorname* { m a x } _ { y } \left| \left\{ m : \mathrm { a r g m a x } _ { y ^ { \prime } } \mathbb { P } ^ { m } \left[ y _ { i } = y ^ { \prime } \right] = y \right\} \right| } { M } ,
+$$
+
+where $\left. \cdot \right.$ denotes cardinality of a set. We normalize this by the number of words as $\textstyle { \frac { 1 } { n } } \sum _ { j = 1 } ^ { n } f _ { j }$ , In this paper, we draw $M = 1 0 0$ independent dropout masks.
+
+Other Sampling Strategies. Consider that the confidence of the model can help to distinguish between hard and easy samples. Thus, sampling examples where the model is uncertain might save us from sampling too heavily from regions where the model is already proficient. But intuitively, when we query a batch of examples in each round, we might want to guard against querying examples that are too similar to each other, thus collecting redundant information. We also might worry that a purely uncertainty-based approach would oversample outliers. Thus we explore techniques to guard against these problems by selecting a set of samples that is representative of the dataset. Following Wei et al. (2015), we express the problem of maximizing representativeness of a labeled set as a submodular optimization problem, and provide an efficient streaming algorithm adapted to use a constraint suitable to the NER task.
+
+Our approach to representativeness-based sampling proceeds as follows: Denote $\mathbb { X }$ as the set of all samples, and $\mathbb { X } ^ { L } , \mathring \mathbb { X } ^ { U }$ representing the set of labeled and unlabeled samples respectively. For an unlabeled set $\mathbb { S } \in \mathbb { X } ^ { U }$ , the utility $f _ { w }$ is defined as the summation of marginal utility gain over all unlabeled points, weighted by their uncertainty. More formally,
+
+$$
+f _ { w } ( \mathbb { S } ) = \sum _ { i \in \mathbb { X } ^ { U } } \mathbb { U } \mathbb { S } ( i ) \cdot \left[ \operatorname* { m a x } _ { j \in \mathbb { S } \cup \mathbb { X } ^ { \mathbb { L } } } w ( i , j ) - \operatorname* { m a x } _ { j \in \mathbb { X } ^ { \mathbb { L } } } w ( i , j ) \right] ,
+$$
+
+where $\mathrm { U S } ( i )$ is the uncertainty score on example $i$ . In order to find a good set $\mathbb { S }$ with high $f _ { w }$ value, we exploit the submodularity of the function, and use an online algorithm under knapsack constraint. More details of this method can be found in the supplementary material (Appendix C). In our experiments, this approach fails to match the uncertainty-based heuristics or to improve upon them when used in combination. Nevertheless, we describe the algorithm and include the negative results for their scientific value.
+
+# 5 EXPERIMENTS
+
+# 5.1 MODEL EFFICIENCY AND PERFORMANCE
+
+In order to evaluate the efficiency and performance CNN-CNN-LSTM as well as other alternatives, we run the experiments on two widely used NER datasets: CoNLL-2003 English (Tjong Kim Sang & De Meulder, 2003) and OntoNotes-5.0 English (Pradhan et al., 2013). We use the standard split of training/validation/test sets, and use the validation set performance to determine hyperparameters such as the learning rate or the number of iterations for early stopping. Unlike Lample et al. (2016) and Chiu & Nichols (2016), we do not train on the validation dataset. We report the F1 score for each model, which is standard. We only consider neural models in this comparison, since they outperform non-neural models for this task. Since our goal here is to compare neural network architectures, we did not experiment with gazetteers.
+
+For neural architectures previously explored by others, we simply cite reported metrics. For LSTM word-level encoder, we use single-layer model with 100 hidden units for CoNLL-2003 English (following Lample et al. (2016)) and two-layer model with 300 hidden units for OntoNotes 5.0 datasets (following Chiu & Nichols (2016)). For character-level LSTM encoder, we use single-layer LSTM with 25 hidden units (following Lample et al. (2016)). For CNN word-level encoder, we use two-layer CNNs with 800 filters and kernel width 5, and for CNN character-level encoder, we use single-layer CNNs with 50 filters and kernel width 3 (following Chiu & Nichols (2016)). Dropout probabilities are all set as 0.5. We use structured skip-gram model (Ling et al., 2015) trained on Gigawords-English corpus (Graff & Cieri, 2003), which showed a good boost over vanilla skip-gram model (Mikolov et al., 2013) we do not report here. We use vanilla stochastic gradient descent, since it is commonly reported in the named entity recognition literature that this outperforms more sophisticated methods at convergence (Lample et al., 2016; Chiu & Nichols, 2016). We uniformly set the step size as 0.001 and the batch size as 128. When using LSTMs for the tag decoder, for inference, we only use greedy decoding; beam search gave very marginal improvement in our initial experiments. We repeat each experiment four times, and report mean and standard deviation. In terms of measuring the training speed of our models, we compute the time spent for one iteration of training on the dataset, with eight K80 GPUs in p2.8xlarge on Amazon Web Services2.
+
+Table 3 and Table 4 show the comparison between our model and other best performing models. LSTM tag decoder shows performance comparable to CRF tag decoder, and it works better than the CRF decoder when used with CNN encoder; compare CNN-CNN-LSTM vs. CNN-CNN-CRF on both tables. On the CoNLL-2003 English dataset which has only four entity types, the training speed of CNN-CNN-LSTM and CNN-CNN-CRF are comparable. However, on the OntoNotes 5.0 English dataset which has 18 entity types, the training speed of CNN-CNN-LSTM is twice faster than CNN-CNN-CRF because the time complexity of computing the partition function for CRF is quadratic to the number of entity types. CNN-CNN-LSTM is also $44 \%$ faster than CNN-LSTMLSTM on OntoNotes, showing the advantage of CNN over LSTM as word encoder; on CoNLL-2003, sentences tend to be shorter and this advantage was not clearly seen; its median number of words in sentences is 12 opposed 17 of OntoNotes. Compared to the CNN-LSTM-CRF model, which is considered as a state-of-the-art model in terms of performance (Chiu & Nichols, 2016; Strubell et al., 2017), CNN-CNN-LSTM provides four times speedup in terms of the training speed, and achieves comparatively high performance measured by F1 score.
+
+# 5.2 PERFORMANCE OF DEEP ACTIVE LEARNING
+
+We use OntoNotes-5.0 English and Chinese data (Pradhan et al., 2013) for our experiments. The training datasets contain 1,088,503 words and 756,063 words respectively. State-of-the-art models trained on the full training sets achieve F1 scores of 86.86 Strubell et al. (2017) and 75.63 (our CNN-CNN-LSTM) on the test sets.
+
+Comparisons of selection algorithms We empirically compare selection algorithms proposed in Section 4, as well as uniformly random baseline (RAND). All algorithms start with an identical $1 \%$ of original training data and a randomly initialized model. In each round, every algorithm chooses sentences from the rest of the training data until 20,000 words have been selected, adding this data to its training set. We then update each model by stochastic gradient descent on its augmented training dataset for 50 passes. We evaluate the performance of algorithm by its F1 score on the test dataset.
+
+Table 3: Evaluations on the test set of CoNLL-2003 English   
+
+<table><tr><td>Char</td><td>Word</td><td>Tag</td><td>Reference</td><td>F1</td><td>Sec/Epoch</td></tr><tr><td>None</td><td>CNN</td><td>CRF</td><td>Collobert et al. (2011)</td><td>88.67</td><td></td></tr><tr><td>None</td><td>LSTM</td><td>CRF</td><td>Huang et al. (2015)</td><td>90.10</td><td></td></tr><tr><td>LSTM</td><td>LSTM</td><td>CRF</td><td>Lample et al. (2016)</td><td>90.94</td><td></td></tr><tr><td>CNN</td><td>LSTM</td><td>CRF</td><td>Chiu &amp; Nichols (2016)</td><td>90.91 ± 0.20</td><td></td></tr><tr><td>GRU</td><td>GRU</td><td>CRF</td><td>Yang et al. (2016)</td><td>90.94</td><td></td></tr><tr><td>None</td><td>Dilated CNN</td><td>CRF</td><td>Strubell et al. (2017)</td><td>90.54 ± 0.18</td><td>-</td></tr><tr><td>LSTM</td><td>LSTM</td><td>LSTM</td><td></td><td>90.89 ± 0.19</td><td>49</td></tr><tr><td>CNN</td><td>LSTM</td><td>LSTM</td><td></td><td>90.58 ± 0.28</td><td>11</td></tr><tr><td>CNN</td><td>CNN</td><td>LSTM</td><td></td><td>90.69 ± 0.19</td><td>11</td></tr><tr><td>CNN</td><td>CNN</td><td>CRF</td><td></td><td>90.35 ± 0.24</td><td>12</td></tr></table>
+
+Table 4: Evaluations on the test set of OntoNotes 5.0 English. $( ^ { * } )$ Training speed of CNN-LSTM-CRF model was measured with our own implementation of it.   
+
+<table><tr><td>Char</td><td>Word</td><td>Tag</td><td>Reference</td><td>F1</td><td>Sec/Epoch</td></tr><tr><td>CNN</td><td>LSTM</td><td>CRF</td><td>Chiu &amp; Nichols (2016)</td><td>86.28 ± 0.26</td><td>83*</td></tr><tr><td>None</td><td>Dilated CNN</td><td>CRF</td><td>Strubell et al. (2017)</td><td>86.84 ± 0.19</td><td>1</td></tr><tr><td>CNN</td><td>LSTM</td><td>LSTM</td><td></td><td>86.40 ± 0.48</td><td>76</td></tr><tr><td>CNN</td><td>CNN</td><td>LSTM</td><td></td><td>86.52 ± 0.25</td><td>22</td></tr><tr><td>CNN</td><td>CNN</td><td>CRF</td><td></td><td>86.15 ± 0.08</td><td>44</td></tr><tr><td>LSTM</td><td>LSTM</td><td>LSTM</td><td></td><td>86.63 ± 0.49</td><td>206</td></tr></table>
+
+Figure 4 shows the results. All active learning algorithms perform significantly better than the random baseline. Among active learners, MNLP and BALD slightly outperformed traditional LC in early rounds. Note that MNLP is computationally more efficient than BALD, since it only requires a single forward pass on the unlabeled dataset to compute uncertainty scores, whereas BALD requires multiple forward passes. Impressively, active learning algorithms achieve $9 9 \%$ performance of the best deep model trained on full data using only $2 4 . 9 \%$ of the training data on the English dataset and $3 0 . 1 \%$ on Chinese. Also, $1 2 . 0 \%$ and $1 6 . 9 \%$ of training data were enough for deep active learning algorithms to surpass the performance of the shallow models from Pradhan et al. (2013) trained on the full training data. We repeated the
+
+![](images/1af3752b9ddc222e9b22bcb8fd3ad79aaf32ea2de65e6b590c98ff09b2bc6579.jpg)  
+Figure 5: Genre distribution of top 1,000 sentences chosen by an active learning algorithm
+
+experiment eight times and confirmed that the trend is replicated across multiple runs; see Appendix B for details.
+
+Detection of under-explored genres To better understand how active learning algorithms choose informative examples, we designed the following experiment. The OntoNotes datasets consist of six genres: broadcast conversation (bc), braodcast news (bn), magazine genre (mz), newswire (nw), telephone conversation (tc), weblogs (wb). We created three training datasets: half-data, which contains random $50 \%$ of the original training data, nw-data, which contains sentences only from newswire $5 1 . 5 \%$ of words in the original data), and no-nw-data, which is the complement of nwdata. Then, we trained CNN-CNN-LSTM model on each dataset. The model trained on half-data achieved 85.10 F1, significantly outperforming others trained on biased datasets (no-nw-data: 81.49, nw-only-data: 82.08). This showed the importance of good genre coverage in training data. Then, we analyzed the genre distribution of 1,000 sentences MNLP chose for each model (see Figure 5). For no-nw-data, the algorithm chose many more newswire (nw) sentences than it did for unbiased half-data (367 vs. 217). On the other hand, it undersampled newswire sentences for nw-only-data and increased the proportion of broadcast news and telephone conversation, which are genres distant from newswire. Impressively, although we did not provide the genre of sentences to the algorithm, it was able to automatically detect underexplored genres.
+
+![](images/b5ac393b740a11100da496af3f87cd9e57aecb325b4a7a51011ccdaac2b7e9d4.jpg)  
+Figure 4: F1 score on the test dataset, in terms of the number of words labeled.
+
+# 6 CONCLUSION
+
+We proposed an efficient model for NER tasks which gives high performances on well-established datasets. Further, we use deep active learning algorithms for NER and empirically demonstrated that they achieve state-of-the-art performance with much less data than models trained in the standard supervised fashion.
+
+# REFERENCES
+
+Daniel Andor, Chris Alberti, David Weiss, Aliaksei Severyn, Alessandro Presta, Kuzman Ganchev, Slav Petrov, and Michael Collins. Globally normalized transition-based neural networks. arXiv preprint arXiv:1603.06042, 2016.
+
+Pranjal Awasthi, Maria Florina Balcan, and Philip M Long. The power of localization for efficiently learning linear separators with noise. In Proceedings of the 46th Annual ACM Symposium on Theory of Computing, pp. 449–458. ACM, 2014.
+
+Ashwinkumar Badanidiyuru, Baharan Mirzasoleiman, Amin Karbasi, and Andreas Krause. Streaming submodular maximization: Massive data summarization on the fly. In Proceedings of the 20th ACM SIGKDD international conference on Knowledge discovery and data mining, pp. 671–680. ACM, 2014.
+
+Maria-Florina Balcan, Alina Beygelzimer, and John Langford. Agnostic active learning. Journal of Computer and System Sciences, 75(1):78–89, 2009.
+
+Alina Beygelzimer, Sanjoy Dasgupta, and John Langford. Importance weighted active learning. In Proceedings of the 26th annual international conference on machine learning, pp. 49–56. ACM, 2009.
+
+Kalina Bontcheva, Leon Derczynski, and Ian Roberts. Crowdsourcing named entity recognition and entity linking corpora. In Handbook of Linguistic Annotation, pp. 875–892. Springer, 2017.
+
+Jason PC Chiu and Eric Nichols. Named entity recognition with bidirectional lstm-cnns. Transactions of the Association for Computational Linguistics, 4:357–370, 2016.
+
+Ronan Collobert, Jason Weston, Léon Bottou, Michael Karlen, Koray Kavukcuoglu, and Pavel Kuksa. Natural language processing (almost) from scratch. Journal of Machine Learning Research, 12 (Aug):2493–2537, 2011.
+
+Aron Culotta and Andrew McCallum. Reducing labeling effort for structured prediction tasks. In AAAI, volume 5, pp. 746–51, 2005.
+
+Andreas Damianou and Neil Lawrence. Deep gaussian processes. In Artificial Intelligence and Statistics, pp. 207–215, 2013.
+
+Sanjoy Dasgupta, Adam Tauman Kalai, and Claire Monteleoni. Analysis of perceptron-based active learning. In International Conference on Computational Learning Theory, pp. 249–263. Springer, 2005.
+
+Yarin Gal and Zoubin Ghahramani. A theoretically grounded application of dropout in recurrent neural networks. In Advances in Neural Information Processing Systems, pp. 1019–1027, 2016.
+
+Yarin Gal, Riashat Islam, and Zoubin Ghahramani. Deep bayesian active learning with image data. arXiv preprint arXiv:1703.02910, 2017.
+
+David Graff and Christopher Cieri. English gigaword, ldc catalog no. LDC2003T05. Linguistic Data Consortium, University of Pennsylvania, 2003.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 770–778, 2016.
+
+Geoffrey Hinton, Li Deng, Dong Yu, George E Dahl, Abdel-rahman Mohamed, Navdeep Jaitly, Andrew Senior, Vincent Vanhoucke, Patrick Nguyen, Tara N Sainath, et al. Deep neural networks for acoustic modeling in speech recognition: The shared views of four research groups. IEEE Signal Processing Magazine, 29(6):82–97, 2012.
+
+Sepp Hochreiter and Jürgen Schmidhuber. Long short-term memory. Neural computation, 9(8): 1735–1780, 1997.
+
+Zhiheng Huang, Wei Xu, and Kai Yu. Bidirectional lstm-crf models for sequence tagging. arXiv preprint arXiv:1508.01991, 2015.
+
+Alex Kendall and Yarin Gal. What uncertainties do we need in bayesian deep learning for computer vision? arXiv preprint arXiv:1703.04977, 2017.
+
+Halil Kilicoglu, Asma Ben Abacha, Yassine Mrabet, Kirk Roberts, Laritza Rodriguez, Sonya E Shooshan, and Dina Demner-Fushman. Annotating named entities in consumer health questions. In LREC, 2016.
+
+Yoon Kim. Convolutional neural networks for sentence classification. arXiv preprint arXiv:1408.5882, 2014.
+
+Andreas Krause and Daniel Golovin. Submodular function maximization. Tractability: Practical Approaches to Hard Problems, 3(19):8, 2012.
+
+Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. In Advances in neural information processing systems, pp. 1097–1105, 2012.
+
+John Lafferty, Andrew McCallum, Fernando Pereira, et al. Conditional random fields: Probabilistic models for segmenting and labeling sequence data. In Proceedings of the eighteenth international conference on machine learning, ICML, volume 1, pp. 282–289, 2001.
+
+Guillaume Lample, Miguel Ballesteros, Sandeep Subramanian, Kazuya Kawakami, and Chris Dyer. Neural architectures for named entity recognition. In Proceedings of NAACL-HLT, pp. 260–270, 2016.
+
+Yann LeCun, Yoshua Bengio, et al. Convolutional networks for images, speech, and time series. The handbook of brain theory and neural networks, 3361(10):1995, 1995.
+
+Jure Leskovec, Andreas Krause, Carlos Guestrin, Christos Faloutsos, Jeanne VanBriesen, and Natalie Glance. Cost-effective outbreak detection in networks. In Proceedings of the 13th ACM SIGKDD international conference on Knowledge discovery and data mining, pp. 420–429. ACM, 2007.
+
+David D Lewis and William A Gale. A sequential algorithm for training text classifiers. In Proceedings of the 17th annual international ACM SIGIR conference on Research and development in information retrieval, pp. 3–12. Springer-Verlag New York, Inc., 1994.
+
+Wang Ling, Chris Dyer, Alan Black, and Isabel Trancoso. Two/too simple adaptations of word2vec for syntax problems. In Proceedings of the 2015 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies. Association for Computational Linguistics, 2015.
+
+Christopher D Manning. Computational linguistics and deep learning. Computational Linguistics, 2016.
+
+Grégoire Mesnil, Xiaodong He, Li Deng, and Yoshua Bengio. Investigation of recurrent-neuralnetwork architectures and learning methods for spoken language understanding. In Interspeech, pp. 3771–3775, 2013.
+
+Tomas Mikolov, Ilya Sutskever, Kai Chen, Greg S Corrado, and Jeff Dean. Distributed representations of words and phrases and their compositionality. In Advances in neural information processing systems, pp. 3111–3119, 2013.
+
+Vinod Nair and Geoffrey E Hinton. Rectified linear units improve restricted boltzmann machines. In Proceedings of the 27th international conference on machine learning (ICML-10), pp. 807–814, 2010.
+
+George L Nemhauser, Laurence A Wolsey, and Marshall L Fisher. An analysis of approximations for maximizing submodular set functions—i. Mathematical Programming, 14(1):265–294, 1978.
+
+Thien Huu Nguyen, Avirup Sil, Georgiana Dinu, and Radu Florian. Toward mention detection robustness with recurrent neural networks. arXiv preprint arXiv:1602.07749, 2016.
+
+Fredrik Olsson. A literature survey of active machine learning in the context of natural language processing. 2009.
+
+Sameer Pradhan, Alessandro Moschitti, Nianwen Xue, Hwee Tou Ng, Anders Björkelund, Olga Uryupina, Yuchen Zhang, and Zhi Zhong. Towards robust linguistic analysis using ontonotes. In CoNLL, pp. 143–152, 2013.
+
+Nils Reimers and Iryna Gurevych. Reporting score distributions makes a difference: Performance study of lstm-networks for sequence tagging. In Proceedings of the 2017 Conference on Empirical Methods in Natural Language Processing, pp. 338–348, 2017.
+
+Burr Settles. Active learning literature survey. University of Wisconsin, Madison, 52(55-66):11, 2010.
+
+Burr Settles and Mark Craven. An analysis of active learning strategies for sequence labeling tasks. In Proceedings of the conference on empirical methods in natural language processing, pp. 1070–1079. Association for Computational Linguistics, 2008.
+
+Dan Shen, Jie Zhang, Jian Su, Guodong Zhou, and Chew-Lim Tan. Multi-criteria-based active learning for named entity recognition. In Proceedings of the 42nd Annual Meeting on Association for Computational Linguistics, pp. 589. Association for Computational Linguistics, 2004.
+
+Nitish Srivastava, Geoffrey E Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout a simple way to prevent neural networks from overfitting. Journal of Machine Learning Research, 15(1):1929–1958, 2014.
+
+Emma Strubell, Patrick Verga, David Belanger, and Andrew McCallum. Fast and accurate entity recognition with iterated dilated convolutions. In Proceedings of the 2017 Conference on Empirical Methods in Natural Language Processing, pp. 2660–2670, 2017.
+
+Erik F Tjong Kim Sang and Fien De Meulder. Introduction to the conll-2003 shared task: Languageindependent named entity recognition. In Proceedings of the seventh conference on Natural language learning at HLT-NAACL 2003-Volume 4, pp. 142–147. Association for Computational Linguistics, 2003.
+
+Simon Tong and Daphne Koller. Support vector machine active learning with applications to text classification. Journal of machine learning research, 2(Nov):45–66, 2001.
+
+Keze Wang, Dongyu Zhang, Ya Li, Ruimao Zhang, and Liang Lin. Cost-effective active learning for deep image classification. IEEE Transactions on Circuits and Systems for Video Technology, 2016.
+
+Kai Wei, Rishabh Iyer, and Jeff Bilmes. Submodularity in data subset selection and active learning. In Proceedings of the 32nd International Conference on Machine Learning (ICML-15), pp. 1954– 1963, 2015.
+
+Songbai Yan and Chicheng Zhang. Revisiting perceptron: Efficient and label-optimal active learning of halfspaces. arXiv preprint arXiv:1702.05581, 2017.
+
+Zhilin Yang, Ruslan Salakhutdinov, and William Cohen. Multi-task cross-lingual sequence tagging from scratch. arXiv preprint arXiv:1603.06270, 2016.
+
+Feifei Zhai, Saloni Potdar, Bing Xiang, and Bowen Zhou. Neural models for sequence chunking. In AAAI, pp. 3365–3371, 2017.
+
+Ye Zhang, Matthew Lease, and Byron C Wallace. Active discriminative text representation learning. In AAAI, pp. 3386–3392, 2017.
+
+# A EFFECT OF BEAM SIZE ON LSTM DECODER
+
+One potential concern when decoding with an LSTM decoder as compared to using a CRF decoder is that finding the best sequence of labels that maximizes the probability $\mathbb { P } \left[ t _ { 2 } , t _ { 3 } , \ldots , t _ { n - 1 } \mid \left\{ { \bf h } _ { i } ^ { \mathrm { E n c } } \right\} \right]$ is computationally intractable. In practice, however, we find that simple greedy decoding, i.e., beam search with beam size 1, works surprisingly well. Table 5 shows how changing the beam size of decoder affects the performance of the model. It can be seen that the performance of the model changes very little with respect to the beam size. Beam search with size 2 is marginally better than greedy decoding, and further increasing the beam size did not help at all. Moreover, we note that while it may be computationally efficient to pick the most likely tag sequence given a CRF encoder, the LSTM decoder may give more accurate predictions, owing to it’s greater representational power and ability to model long-range dependencies. Thus even if we do not always choose the most probable tag sequence from the LSTM, we can still outperform the CRF (as our experiments demonstrate).
+
+Table 5: Effect of beam size in LSTM decoder. We used a single LSTM-LSTM-LSTM model, and evaluated on OntoNotes 5.0 English dataset.   
+
+<table><tr><td>Beam Size</td><td>F1</td></tr><tr><td>1</td><td>87.26</td></tr><tr><td>2</td><td>87.34</td></tr><tr><td>4</td><td>87.33</td></tr><tr><td>8</td><td>87.33</td></tr><tr><td>16</td><td>87.33</td></tr></table>
+
+# B LEARNING CURVE IN ACTIVE LEARNING EXPERIMENTS ACROSS MULTIPLE RUNS
+
+In order to understand the variability of learning curves in Figure 4a across experiments, we repeated the active learning experiment on OntoNotes-5.0 English eight times, each of which started with different initial dataset chosen randomly. Figure 6 shows the result in first nine rounds of labeled data acquisition. While MNLP, LC and BALD are all competitive against each other, there is a noticeable trend that MNLP and BALD outperforms LC in early rounds of data acquisition.
+
+# C REPRESENTATIVENESS-BASED ACTIVE LEARNING
+
+Consider that the confidence of the model can help to distinguish between hard and easy samples. Thus, sampling examples where the model is uncertain might save us from sampling too heavily from regions where the model is already proficient. But intuitively, when we query a batch of examples in each round, we might want to guard against querying examples that are too similar to each other, thus collecting redundant information. We also might worry that a purely uncertainty-based approach would oversample outliers. Thus we explore techniques to guard against these problems by selecting a set of samples that is representative of the dataset. Following Wei et al. (2015), we express the problem of maximizing representativeness of a labeled set as a submodular optimization problem, and provide an efficient streaming algorithm adapted to use a constraint suitable to the NER task. We also provide some with theoretical guarantees.
+
+Submodular utility function In order to reason about the similarity between samples, we first embed each sample $i$ into a fixed-dimensional euclidean space as a vector $\mathbf { x } _ { i }$ . We consider two embedding methods: 1) the average of pre-trained word embeddings, $\begin{array} { r } { \frac { 1 } { n } \sum _ { t = 1 } ^ { n } { \bf w } _ { t } ^ { \mathrm { e m b } } } \end{array}$ , which can be efficiently computed without training of the NER model, and 2) the average of activation maps at the topmost layer of the encoder $\textstyle { \frac { 1 } { n } } \sum _ { t = 1 } ^ { n } \mathbf { h } _ { t } ^ { \mathrm { E n c } }$ , an embedding which might be better suited to the context of the NER task. Then, we consider the following options for defining similarity scores $w ( i , j )$ between each pair of samples $i$ and $j$ : $w ( i , j ) = d - \| x ^ { i } - x ^ { j } \| _ { p }$ where $\begin{array} { r } { \dot { d } = \operatorname* { m a x } _ { i , j \in \mathbb { X } } \| x ^ { i } - \dot { x } ^ { j } \| _ { p } } \end{array}$ for $p = 1 , 2$ which corresponds to closeness in $L _ { 1 }$ and $L _ { 2 }$ distance (Wei et al., 2015), and $w ( i , j ) =$ $\begin{array} { r } { 1 + \frac { x _ { i } \cdot x _ { j } } { \| x _ { i } \| \cdot \| x _ { j } \| } } \end{array}$ , which corresponds to cosine similarity.
+
+![](images/de6e0f584828095d7382a60891c13b1343e96742f2bc69d051247ed27200ca63.jpg)  
+Figure 6: Test F1 score in first nine rounds of labeled data acquisition on OntoNotes-5.0 English dataset across multiple runs of the active learning experiment. The experiment was repeated eight times, with different initial dataset. Error bars indicates standard deviation, and dots indicate individual observation.
+
+Now, we formally define the utility function for labeling new samples. Denote $\mathbb { X }$ as the set of all samples which can be partitioned into two disjoint sets $\mathbb { X } ^ { \mathrm { L } }$ , $\mathbb { X } ^ { \mathbb { I } }$ representing labeled and unlabeled samples, respectively. Let $\mathbb { S } \subseteq \mathbb { X } ^ { \mathrm { U } }$ be a subset of unlabeled samples, then, the utility of labeling the set is defined as follows:
+
+$$
+f ( \mathbb { S } ) = \sum _ { i \in \mathbb { X } ^ { \mathbb { U } } } \left[ \operatorname* { m a x } _ { j \in \mathbb { S } \cup \mathbb { X } ^ { \mathbb { L } } } w ( i , j ) - \operatorname* { m a x } _ { j \in \mathbb { X } ^ { \mathbb { L } } } w ( i , j ) \right] ,
+$$
+
+where the function measures incremental gain of similarity between the labeled set and the rest. Given such utility function $f ( \cdot )$ , choosing a set $\mathbb { S }$ that maximizes the function within the budget can be seen as a monotone submodular maximization problem under a knapsack constraint (Krause & Golovin, 2012):
+
+$$
+\operatorname { m a x } _ { \mathbb { S } \subseteq \mathbb { X } ^ { \cup } , \sum _ { e \in \mathbb { S } } k ( \{ e \} ) \leq K } f ( \mathbb { S } )
+$$
+
+where $k ( \mathbb { S } )$ is the budget for the sample set $\mathbb { S }$ , and $K$ is the total budget within each round. Note that we need to consider the knapsack constraint instead of the cardinality constraint used in the prior work (Wei et al., 2015), because the entire sentence needs to be labeled once selected and sequences of length confer different labeling costs.
+
+Combination with uncertainty sampling Representation-based sampling can benefit from uncertainty-based sampling in the following two ways. First, we can re-weight each sample in the utility function (5) to reflect current model’s uncertainty on it:
+
+$$
+f _ { w } ( \mathbb { S } ) = \sum _ { i } \mathbb { U } \mathbb { S } ( i ) \cdot \left[ \operatorname* { m a x } _ { j \in \mathbb { S } \cup \mathbb { X } ^ { \perp } } w ( i , j ) - \operatorname* { m a x } _ { j \in \mathbb { X } ^ { \perp } } w ( i , j ) \right] ,
+$$
+
+# Algorithm 1 Representativeness-based Sampling
+
+1: Input: Samples $\{ \mathbb { X } ^ { \mathbb { U } } , \mathbb { X } ^ { \mathtt { L } } \}$ , budget $K$ ,   
+pretrained model $\mathbb { M }$ using $\mathbb { X } ^ { \mathrm { L } }$   
+2: while Test score of $\mathbb { M }$ less than th do   
+3: Rank $\mathbb { X } ^ { \mathbb { I } }$ according to Sec. 4,   
+$\tilde { \mathbb { X } } ^ { \mathbb { I } } =$ top samples $\mathbb { S }$ within budget $t \cdot K$   
+4: Set $f$ according to (5) or (7)   
+5: $\mathbb { S } =$ StreamSubmod $\mathsf { M a x } ( f , \tilde { \mathbb { X } } ^ { \mathrm { U } } )$ .   
+6: $\{ \tilde { \mathbb { X } } ^ { \cup } , \mathbb { X } ^ { \mathtt { L } } \} = \{ \mathbb { X } ^ { \cup } - \mathbb { S } , \mathbb { X } ^ { \mathtt { L } } \cup \mathbb { S } \}$   
+7: Train $\mathbb { M }$ with $\mathbb { X } ^ { \mathrm { L } }$ .   
+8: Output: M   
+1: Input: Submodular function $g$ , set X˜ U   
+2: $m = \operatorname* { m a x } _ { e \in \tilde { \mathbb { X } } ^ { \cup } } g ( \{ e \} ) / k ( \{ e \} )$   
+3: $O = \{ ( 1 + \epsilon ) ^ { i } | i \in \mathbb { Z } , ( 1 + \epsilon ) ^ { i } \in [ m , K m ] \}$   
+4: $\mathbb { S } _ { v } : = \varnothing , \forall v \in O$   
+5: for $e$ in $\tilde { \mathbb { X } } ^ { \mathbb { U } }$ do   
+6: for $v \in O$ and $k ( \mathbb { S } _ { v } \cup \{ e \} ) \leq K$ do   
+7: i $\begin{array} { r } { \mathsf { f } \Delta _ { g } ( e | \mathbb { S } _ { v } ) \ge \frac { k ( \{ e \} ) ( v / 2 - g ( \mathbb { S } _ { v } ) ) } { K - k ( \mathbb { S } _ { v } ) } } \end{array}$ then   
+8: Sv := Sv ∪ {e}   
+9: Output: arg maxv∈O f (Sv)
+
+where $\mathrm { U S } ( i )$ is the uncertainty score on example $i$ . Second, even with the state-of-the-art submodular optimization algorithms, the optimization problem (6) can be computationally intractable. To improve the computational efficiency, we restrict the set of unlabeled examples to top samples from uncertainty sampling within budget $t \cdot K$ , where $t$ is a multiplication factor we set as 4 in our experiments.
+
+Streaming algorithm for sample selection Even with the reduction of candidates with uncertainty sampling, (6) is still a computationally challenging problem and requires careful design of optimization algorithms. Suppose $l$ is the number of samples we need to consider. In the simplistic case in which all the samples have the same length and thus the knapsack constraint degenerates to the cardinality constraint, the greedy algorithm (Nemhauser et al., 1978) has an $( 1 - 1 / e )$ -approximation guarantee. However, it requires calculating the utility function $O ( l ^ { 2 } n )$ times, where $n$ is the number of unlabeled samples. In practice, both $l$ and $n$ are large. Alternatively, we can use lazy evaluation to decrease the computation complexity to $O ( l n )$ (Leskovec et al., 2007), but it requires an additional hyperparameter to be chosen in advance. Instead of greedily selecting elements in an offline fashion, we adopt the two-pass streaming algorithm of Badanidiyuru et al. (2014), whose complexity is ${ \cal \tilde { O } } ( l n ) ^ { 3 }$ , and generalize it to the knapsack constraint (shown in Alg. 2). In the first pass, we calculate the maximum function value of a single element normalized by its weight, which gives an estimate of the optimal value. In the second pass, we create $O ( \textstyle { \frac { 1 } { \epsilon } } \log K )$ buckets and greedily update each of the bucket according to:
+
+$$
+\Delta _ { g } ( e | \mathbb { S } _ { v } ) \geq \frac { k ( \{ e \} ) ( v / 2 - g ( \mathbb { S } _ { v } ) ) } { K - k ( \mathbb { S } _ { v } ) } ,
+$$
+
+where each bucket has a different value $v$ , and $\Delta _ { g } ( e | \mathbb { S } _ { v } ) : = g ( \{ e \} \cup \mathbb { S } _ { v } ) - g ( \mathbb { S } _ { v } )$ is the marginal improvement of submodular function $g$ when adding element $e$ to set $\mathbb { S } _ { v }$ . The whole pipeline of the active learning algorithm is shown in Alg. 1. The algorithm gives the following guarantee, which is proven in Appendix.
+
+Theorem 1. Alg. 2 gives $a$ $\frac { ( 1 - \epsilon ) ( 1 - \delta ) } { 2 }$ -approximation guarantee for (6), where $\delta \quad =$ $\operatorname* { m a x } _ { e \in \mathbb { S } } k ( \{ e \} ) / \bar { K }$ .
+
+Proof sketch: The criterion (8) we use guarantees that each update we make is reasonably good. The set $\mathbb { S } _ { v }$ stops updating when either the current budget is almost $K$ , or any sample in the stream after we reach $\mathbb { S } _ { v }$ does not provide enough marginal improvement. While it is easy to give guarantees when the budget is exhausted, it is unlikely to happen; we use a difference expression between current set $\mathbb { S } _ { v }$ and the optimal set, and prove the gap between the two is under control.
+
+In a practical label acquisition process, the budget we set for each round is usually much larger than the length of the longest sentence in the unlabeled set, making $\delta$ negligible. In our experiments, $\delta$ was around 0.01.

parse/train/ry018WZAZ/ry018WZAZ_content_list.json

@@ -0,0 +1,1848 @@
+[
+    {
+        "type": "text",
+        "text": "DEEP ACTIVE LEARNING FOR NAMED ENTITY RECOGNITION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            99,
+            825,
+            145
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Yanyao Shen   \nUT Austin   \nAustin, TX 78712   \nshenyanyao@utexas.edu ",
+        "bbox": [
+            184,
+            170,
+            390,
+            226
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Hyokun Yun Amazon Web Services Seattle, WA 98101 yunhyoku@amazon.com ",
+        "bbox": [
+            424,
+            170,
+            612,
+            226
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Zachary C. Lipton Amazon Web Services Seattle, WA 98101 liptoz@amazon.com ",
+        "bbox": [
+            645,
+            170,
+            813,
+            226
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Yakov Kronrod Amazon Web Services Seattle, WA 98101 kronrod@amazon.com ",
+        "bbox": [
+            183,
+            247,
+            362,
+            303
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Animashree Anandkumar Amazon Web Services Seattle, WA 98101 anima@amazon.com ",
+        "bbox": [
+            503,
+            247,
+            687,
+            303
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            340,
+            544,
+            354
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep learning has yielded state-of-the-art performance on many natural language processing tasks including named entity recognition (NER). However, this typically requires large amounts of labeled data. In this work, we demonstrate that the amount of labeled training data can be drastically reduced when deep learning is combined with active learning. While active learning is sample-efficient, it can be computationally expensive since it requires iterative retraining. To speed this up, we introduce a lightweight architecture for NER, viz., the CNN-CNN-LSTM model consisting of convolutional character and word encoders and a long short term memory (LSTM) tag decoder. The model achieves nearly state-of-the-art performance on standard datasets for the task while being computationally much more efficient than best performing models. We carry out incremental active learning, during the training process, and are able to nearly match state-of-the-art performance with just $2 5 \\%$ of the original training data. ",
+        "bbox": [
+            233,
+            369,
+            766,
+            549
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            573,
+            336,
+            588
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Over the past few years, papers applying deep neural networks (DNNs) to the task of named entity recognition (NER) have successively advanced the state-of-the-art (Collobert et al., 2011; Huang et al., 2015; Lample et al., 2016; Chiu & Nichols, 2016; Yang et al., 2016). However, under typical training procedures, the advantages of deep learning diminish when working with small datasets. For instance, on the OntoNotes-5.0 English dataset, whose training set contains 1,088,503 words, a DNN model outperforms the best shallow model by $2 . 2 4 \\%$ as measured by F1 score (Chiu & Nichols, 2016). However, on the comparatively small CoNLL-2003 English dataset, whose training set contains 203,621 words, the best DNN model enjoys only a $0 . 4 \\%$ advantage. To make deep learning more broadly useful, it is crucial to reduce its training data requirements. ",
+        "bbox": [
+            174,
+            603,
+            825,
+            728
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Generally, the annotation budget for labeling is far less than the total number of available (unlabeled) samples. For NER, getting unlabeled data is practically free, owing to the large amount of content that can be efficiently scraped off the web. On the other hand, it is especially expensive to obtain annotated data for NER since it requires multi-stage pipelines with sufficiently well-trained annotators (Kilicoglu et al., 2016; Bontcheva et al., 2017). In such cases, active learning offers a promising approach to efficiently select the set of samples for labeling. Unlike the supervised learning setting, in which examples are drawn and labeled at random, in the active learning setting, the algorithm can choose which examples to label. ",
+        "bbox": [
+            174,
+            736,
+            825,
+            847
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Active learning aims to select a more informative set of examples in contrast to supervised learning, which is trained on a set of randomly drawn examples. A central challenge in active learning is to determine what constitutes more informative and how the active learner can recognize this based on what it already knows. The most common approach is uncertainty sampling, in which the model preferentially selects examples for which it’s current prediction is least confident. Other approaches include representativeness-based sampling where the model selects a diverse set that represent the input space without adding too much redundancy. ",
+        "bbox": [
+            174,
+            854,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this work, we investigate practical active learning algorithms on lightweight deep neural network architectures for the NER task. Training with active learning proceeds in multiple rounds. Traditional active learning schemes are expensive for deep learning since they require complete retraining of the classifier with newly annotated samples after each round. In our experiments, for example, the model must be retrained 54 times. Because retraining from scratch is not practical, we instead carry out incremental training with each batch of new labels: we mix newly annotated samples with the older ones, and update our neural network weights for a small number of epochs, before querying for labels in a new round. This modification drastically reduces the computational requirements of active learning methods and makes it practical to deploy them. ",
+        "bbox": [
+            174,
+            138,
+            825,
+            263
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We further reduce the computational complexity by selecting a lightweight architecture for NER. We propose a new CNN-CNN-LSTM architecture for NER consisting of a convolutional character-level encoder, convolutional word-level encoder, and long short term memory (LSTM) tag decoder. This model handles out-of-vocabulary words gracefully and, owing to the greater reliance on convolutions (vs recurrent layers), trains much faster than other deep models while performing competitively. ",
+        "bbox": [
+            174,
+            271,
+            825,
+            340
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We introduce a simple uncertainty-based heuristic for active learning with sequence tagging. Our model selects those sentences for which the length-normalized log probability of the current prediction is the lowest. Our experiments with the Onto-Notes 5.0 English and Chinese datasets demonstrate results comparable to the Bayesian active learning by disagreement method (Gal et al., 2017). Moreover our heuristic is faster to compute since it does not require multiple forward passes. On the OntoNotes-5.0 English dataset, our approach matches $9 9 \\%$ of the F1 score achieved by the best deep models trained in a standard, supervised fashion despite using only a $2 4 . 9 \\%$ of the data. On the OntoNotes-5.0 Chinese dataset, we match $9 9 \\%$ performance with only $3 0 . 1 \\%$ of the data. Thus, we are able to achieve state of art performance with drastically lower number of samples. ",
+        "bbox": [
+            174,
+            347,
+            825,
+            473
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            496,
+            341,
+            512
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Deep learning for named entity recognition The use of DNNs for NER was pioneered by Collobert et al. (2011), who proposed an architecture based on temporal convolutional neural networks (CNNs) over the sequence of words. Since then, many papers have proposed improvements to this architecture. Huang et al. (2015) proposed to replace CNN encoder in Collobert et al. (2011) with bidirectional LSTM encoder, while Lample et al. (2016) and Chiu & Nichols (2016) introduced hierarchy in the architecture by replacing hand-engineered character-level features in prior works with additional bidirectional LSTM and CNN encoders respectively. In other related work, Mesnil et al. (2013) and Nguyen et al. (2016) pioneered the use of recurrent neural networks (RNNs) for decoding tags. However, most recent competitive approaches rely upon CRFs as decoder (Lample et al., 2016; Chiu & Nichols, 2016; Yang et al., 2016). In this work, we demonstrate that LSTM decoders outperform CRF decoders and are faster to train when the number of entity types is large. ",
+        "bbox": [
+            174,
+            520,
+            825,
+            674
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Active learning While learning-theoretic properties of active learning algorithms are wellstudied (Dasgupta et al., 2005; Balcan et al., 2009; Awasthi et al., 2014; Yan & Zhang, 2017; Beygelzimer et al., 2009), classic algorithms and guarantees cannot be generalized to DNNs, which are currently are the state-of-the-art techniques for NER. Owing to the limitations of current theoretical analysis, more practical active learning applications employ a range of heuristic procedures for selecting examples to query. For example, Tong & Koller (2001) suggests a margin-based selection criteria, while Settles & Craven (2008) while Shen et al. (2004) combines multiple criteria for NLP tasks. Culotta & McCallum (2005) explores the application of least confidence criterion for linear CRF models on sequence prediction tasks. For a more comprehensive review of the literature, we refer to Settles (2010) and Olsson (2009). ",
+        "bbox": [
+            174,
+            680,
+            825,
+            819
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Deep active learning While DNNs have achieved impressive empirical results across diverse applications (Krizhevsky et al., 2012; Hinton et al., 2012; Manning, 2016), active learning approaches for these models have yet to be well studied, and most current work addresses image classification. Wang et al. (2016) claims to be the first to study active learning for image classification with CNNs and proposes methods based on uncertainty-based sampling, while Gal et al. (2017) and Kendall & Gal (2017) show that sampling based on a Bayesian uncertainty measure can be more advantageous. In one related paper, Zhang et al. (2017) investigate active learning for sentence classification with ",
+        "bbox": [
+            174,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "table",
+        "img_path": "images/6e9d3659b972bb1f7b79cd39cdaa68ee65fcbaf69d5736f78ab1542b83783d43.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Table 1: Prior works on neural architectures for sequence tagging, and their corresponding design choices. "
+        ],
+        "table_body": "<table><tr><td>Character-Level Encoder</td><td>Word-Level Encoder</td><td>Tag Decoder</td><td>Reference</td></tr><tr><td>None</td><td>CNN</td><td>CRF</td><td>Collobert et al. (2011)</td></tr><tr><td>None</td><td>RNN</td><td>RNN</td><td>Mesnil et al. (2013)</td></tr><tr><td>None</td><td>RNN</td><td>GRU</td><td>Nguyen et al. (2016)</td></tr><tr><td>None</td><td>LSTM</td><td>CRF</td><td>Huang et al. (2015)</td></tr><tr><td>LSTM</td><td>LSTM</td><td>CRF</td><td>Lample et al. (2016)</td></tr><tr><td>CNN</td><td>LSTM</td><td>CRF</td><td>Chiu &amp; Nichols (2016)</td></tr><tr><td>CNN</td><td>LSTM</td><td>LSTM,Pointer Networks</td><td>Zhai et al. (2017)</td></tr><tr><td>GRU</td><td>GRU</td><td>CRF</td><td>Yang et al. (2016)</td></tr><tr><td>None</td><td>Dilated CNN</td><td>Independent Softmax, CRF</td><td>Strubell et al. (2017)</td></tr><tr><td>CNN</td><td>CNN</td><td>LSTM</td><td>Ours</td></tr></table>",
+        "bbox": [
+            173,
+            99,
+            882,
+            270
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "CNNs. However, to our knowledge, prior to this work, deep active learning for sequence tagging tasks, which often have structured output space and variable-length input, has not been studied. ",
+        "bbox": [
+            173,
+            339,
+            823,
+            368
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 NER MODEL DESCRIPTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            392,
+            436,
+            409
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Most active learning methods require frequent retraining of the model as new labeled examples are acquired. Therefore, it is crucial that the model can be efficiently retrained. On the other hand, we would still like to reach the level of performance rivaling state-of-the-art DNNs. ",
+        "bbox": [
+            176,
+            428,
+            821,
+            469
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To accomplish this, we first identify that many DNN architectures for NER can be decomposed into three components: 1) the character-level encoder, which extracts features for each word from characters, 2) the word-level encoder which extracts features from the surrounding sequence of words, and 3) the tag decoder, which induces a probability distribution over any sequences of tags. This conceptual framework allows us to view a variety of DNNs in a unified perspective; see Table 1. ",
+        "bbox": [
+            174,
+            476,
+            825,
+            546
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Owing to the superior computational efficiency of CNNs over LSTMs, we propose a lightweight neural network architecture for NER, which we name CNN-CNN-LSTM and describe below. ",
+        "bbox": [
+            173,
+            553,
+            823,
+            582
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "table",
+        "img_path": "images/9b31b66881dbe1569b7640f6a8efec1cd35a1c8e10d5ddeb75d30212d3e5ebab.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Formatted Sentence</td><td>[BOS]</td><td>Kate</td><td>lives</td><td>on</td><td>Mars</td><td>[EOS]</td><td>[PAD]</td></tr><tr><td>Tag</td><td>0</td><td>S-PER</td><td>0</td><td>0</td><td>S-LOC</td><td>0</td><td>0</td></tr></table>",
+        "bbox": [
+            228,
+            598,
+            767,
+            640
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Table 2: Example formatted sentence. To avoid clutter, [BOW] and [EOW] symbols are not shown. ",
+        "bbox": [
+            173,
+            651,
+            821,
+            666
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Data Representation We represent each input sentence as follows; First, special [BOS] and [EOS] tokens are added at the beginning and the end of the sentence, respectively. In order to batch the computation of multiple sentences, sentences with similar length are grouped together into buckets, and [PAD] tokens are added at the end of sentences to make their lengths uniform inside of the bucket. We follow an analogous procedure to represent the characters in each word. For example, the sentence ‘Kate lives on Mars’ is formatted as shown in Table 2. The formatted sentence is denoted as $\\{ { \\bf { x } } _ { i j } \\}$ , where $\\mathbf { x } _ { i j }$ is the one-hot encoding of the $j$ -th character in the $i$ -th word. ",
+        "bbox": [
+            173,
+            686,
+            825,
+            785
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Character-Level Encoder For each word $i$ , we use CNNs (LeCun et al., 1995) to extract characterlevel features $\\mathbf { w } _ { i } ^ { \\mathrm { c h a r } }$ (Figure 1). While LSTM recurrent neural network (Hochreiter & Schmidhuber, 1997) slightly outperforms CNN as a character-level encoder, the improvement is not statistically significant and the computational cost of LSTM encoders is much higher than CNNs (see Section 5, also Reimers & Gurevych (2017) for detailed analysis). ",
+        "bbox": [
+            174,
+            790,
+            825,
+            861
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We apply ReLU nonlinearities (Nair & Hinton, 2010) and dropout (Srivastava et al., 2014) between CNN layers, and include a residual connection between input and output of each layer (He et al., 2016). So that our representation of the word is of fixed length, we apply max-pooling on the outputs of the topmost layer of the character-level encoder (Kim, 2014). ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/6683af6a0971f14bb33b5c1dbf0b43f27e69577cf02b102ab048fd733e75c4f6.jpg",
+        "image_caption": [
+            "Figure 1: Example CNN architecture for Character-level Encoder with two layers. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            328,
+            103,
+            660,
+            252
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Word-Level Encoder To complete our representation of each word, we concatenate its characterlevel features with $\\mathbf { w } _ { i } ^ { \\mathrm { e m b } }$ , a latent word embedding corresponding to that word: ",
+        "bbox": [
+            173,
+            308,
+            825,
+            337
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6eb9050872023663c3d95dbaf54829e464cd81cb0bb31ca20baef1c314ddf7f1.jpg",
+        "text": "$$\n\\mathbf { w } _ { i } ^ { \\mathrm { f u l l } } : = \\left( \\mathbf { w } _ { i } ^ { \\mathrm { c h a r } } , \\mathbf { w } _ { i } ^ { \\mathrm { e m b } } \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            419,
+            342,
+            576,
+            362
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We initialize the latent word embeddings with with word2vec training Mikolov et al. (2013) and then update the embeddings over the course of training. In order to generalize to words unseen in the training data, we replace each word with a special [UNK] (unknown) token with $50 \\%$ probability during training, an approach that resembles the word-drop method due to Lample et al. (2016). ",
+        "bbox": [
+            173,
+            366,
+            825,
+            422
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Given the sequence of word-level input features $\\mathbf { w } _ { 1 } ^ { \\mathrm { f u l l } } , \\mathbf { w } _ { 2 } ^ { \\mathrm { f u l l } } , \\dots , \\mathbf { w } _ { n } ^ { \\mathrm { f u l l } }$ , we extract word-level representations $\\mathbf { \\bar { h } } _ { 1 } ^ { \\mathrm { E n c } } , \\mathbf { h } _ { 2 } ^ { \\mathrm { E n c } } , \\ldots , \\mathbf { h } _ { n } ^ { \\mathrm { E n c } }$ 1 2 nfor each word position in the sentence using a CNN. In Figure 2, we depict an instance of our architecture with two convolutional layers and kernels of width 3. We concatenate the representation at the $l$ -th convolutional layer $\\mathbf { h } _ { i } ^ { ( l ) }$ , with the input features $\\mathbf { w } _ { i } ^ { \\mathrm { f u l l } }$ : ",
+        "bbox": [
+            173,
+            428,
+            825,
+            489
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c62ada6c0fcc76b5ba00f4625356a084dc4545f35861dd5287d8787038a9d7ef.jpg",
+        "text": "$$\n\\mathbf { h } _ { i } ^ { \\mathrm { E n c } } = \\left( \\mathbf { h } _ { i } ^ { ( l ) } , \\mathbf { w } _ { i } ^ { \\mathrm { f u l l } } \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            429,
+            494,
+            566,
+            522
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/d6d9baf18d15c02107109169ae934dcb7fc2ffe6f5cf38aaaadba38e5ebd6e3b.jpg",
+        "image_caption": [
+            "Figure 2: Example CNN architecture for Word-level Encoder with two layers. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            321,
+            541,
+            665,
+            691
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "LSTM RNNs can also perform word-level encoding Huang et al. (2015), and models with LSTM word-level encoding give a slight (but not significant) boost over CNN word-level encoders in terms of F1 score (see Section 5). However, CNN word-level encoders are considerably faster (Strubell et al., 2017), which is crucial for the iterative retraining in our active learning scheme. ",
+        "bbox": [
+            173,
+            734,
+            825,
+            791
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Tag Decoder The tag decoder induces a probability distribution over sequences of tags, conditioned on the word-level encoder features: $\\mathbf { \\bar { \\mathbb { P } } } [ y _ { 2 } , y _ { 3 } , \\ldots , y _ { n - 1 } \\ | \\ \\middle \\{ \\mathbf { h } _ { i } ^ { \\mathrm { E n c } } \\} ] ^ { 1 }$ . Chain CRF (Lafferty et al., 2001) is a popular choice for tag decoder, adopted by most modern DNNs for NER: ",
+        "bbox": [
+            174,
+            797,
+            826,
+            840
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1c3913ea1546fda3326e44542d4a4ea4d90da0e1d99e00986517ee9e3b4310a9.jpg",
+        "text": "$$\n\\mathbb { P } \\left[ t _ { 2 } , t _ { 3 } , \\dots , t _ { n - 1 } \\middle \\vert \\left\\{ \\mathbf { h } _ { i } ^ { \\mathrm { E n c } } \\right\\} \\right] \\propto \\exp \\left( \\sum _ { i = 2 } ^ { n - 1 } \\left\\{ W \\mathbf { h } _ { i } ^ { \\mathrm { E n c } } + b \\right\\} _ { t _ { i } } + A _ { t _ { i - 1 } , t _ { i } } \\right) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            259,
+            845,
+            736,
+            888
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $W$ , A, b are learnable parameters, and $\\{ \\cdot \\} _ { t _ { i } }$ refers to the $t _ { i }$ -th coordinate of the vector. To compute the partition function of (1), which is required for training, usually dynamic programming is employed, and its time complexity is $O ( n T ^ { 2 } )$ where $T$ is the number of entity types (Collobert et al., 2011). ",
+        "bbox": [
+            174,
+            103,
+            825,
+            159
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Alternatively, we use an LSTM RNN for the tag decoder, as depicted in Figure 3. At the first time step, the [GO]-symbol is provided as $y _ { 1 }$ to the decoder LSTM. At each time step $i$ , the LSTM decoder computes $\\mathbf { h } _ { i + 1 } ^ { \\mathrm { D e c } }$ , the hidden state for decoding word $i + 1$ , using the last tag $y _ { i }$ , the current decoder hidden state $\\mathbf { h } _ { i } ^ { \\mathrm { D e c } }$ , and the learned representation of next word $\\mathbf { h } _ { i + 1 } ^ { \\mathrm { E n c } }$ . Using a softmax loss function, $y _ { i + 1 }$ is decoded; this is further fed as an input to the next time step. ",
+        "bbox": [
+            173,
+            166,
+            825,
+            238
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/10095e0f091becdfce4783f31f68cbd62538b19909d162e3149e44895062b50d.jpg",
+        "image_caption": [
+            "Figure 3: LSTM architecture for Tag Decoder. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            369,
+            256,
+            620,
+            414
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Since this is a locally normalized model (Andor et al., 2016), it does not require the costly computation of partition function, and it allows us to significantly speed up training compared to using CRFs. Also, we observed that while it is computationally intractable to find the best sequence of tags with an LSTM decoder, greedily decoding tags from left to right yields the performance comparable to chain CRF decoder (see Appendix A). While the use of RNNs tag decoders has been explored (Mesnil et al., 2013; Nguyen et al., 2016; Zhai et al., 2017), we demonstrate for the first time that models using RNNs instead of CRFs for tag decoder can achieve state-of-the-art performance. See Section 5. ",
+        "bbox": [
+            173,
+            457,
+            826,
+            554
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 ACTIVE LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            574,
+            366,
+            589
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Labeling data for NER usually requires manual annotations by human experts, which are costly to acquire at scale. Active learning seeks to ameliorate this problem by strategically choosing which examples to annotate, in the hope of getting greater performance with fewer annotations. To this end, we consider the following setup for interactively acquiring annotations. The learning process consists of multiple rounds: At the beginning of each round, the active learning algorithm chooses sentences to be annotated up to the predefined budget. After receiving annotations, we update the model parameters by training on the augmented dataset, and proceeds to the next round. We assume that the cost of annotating a sentence is proportional to the number of words in the sentence and that every word in the selected sentence must be annotated at once, i.e. we do not allow or account for partially annotated sentences. ",
+        "bbox": [
+            173,
+            603,
+            825,
+            742
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "While various existing active learning strategies suit this setup (Settles, 2010), we explore the uncertainty sampling strategy. With the uncertainty-based sampling strategy (Lewis & Gale, 1994), we rank the unlabeled examples according to the current model’s uncertainty in its prediction of the corresponding labels. We consider three ranking methods, each of which can be easily implemented in the CNN-CNN-LSTM model or most other deep neural approaches to NER. ",
+        "bbox": [
+            173,
+            750,
+            825,
+            820
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Least Confidence (LC): Culotta & McCallum (2005) proposed to sort examples in ascending order according to the probability assigned by the model to the most likely sequence of tags: ",
+        "bbox": [
+            173,
+            827,
+            823,
+            854
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fe06b75eb13efed2d5fc17d6e46bf9d73fdf5d11538e6406edd5d18ca8b8f780.jpg",
+        "text": "$$\n1 - \\operatorname* { m a x } _ { y _ { 1 } , \\ldots , y _ { n } } \\mathbb { P } \\left[ y _ { 1 } , \\ldots , y _ { n } \\middle \\vert \\left\\{ { \\bf x } _ { i j } \\right\\} \\right] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            383,
+            857,
+            612,
+            881
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Exactly computing (2) requires identifying the most likely sequence of tags according to the LSTM decoder. Because determining the most likely sequence is intractable, we approximate the score by using the probability assigned to the greedily decoded sequence. ",
+        "bbox": [
+            174,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Maximum Normalized Log-Probability (MNLP): Preliminary analysis revealed that the LC method disproportionately selects longer sentences. Note that sorting unlabeled examples in descending order by (2) is equivalent to sorting in ascending order by the following scores: ",
+        "bbox": [
+            176,
+            102,
+            825,
+            147
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0a707234286e4fa7b089f8b4c7c3177a7d1351b3d939d07db4e105e155f99130.jpg",
+        "text": "$$\n\\begin{array} { r l r } { \\underset { y _ { 1 } , \\ldots , y _ { n } } { \\operatorname* { m a x } } } & { } & { \\mathbb { P } \\left[ y _ { 1 } , \\ldots , y _ { n } \\middle \\vert \\left\\{ \\mathbf { x } _ { i j } \\right\\} \\right] \\Leftrightarrow \\underset { y _ { 1 } , \\ldots , y _ { n } } { \\operatorname* { m a x } } \\underset { i = 1 } { \\overset { n } { \\prod } } \\mathbb { P } \\left[ y _ { i } \\middle \\vert y _ { 1 } , \\ldots , y _ { n - 1 } , \\left\\{ \\mathbf { x } _ { i j } \\right\\} \\right] } \\\\ & { } & { \\Leftrightarrow \\underset { y _ { 1 } , \\ldots , y _ { n } } { \\operatorname* { m a x } } \\underset { i = 1 } { \\overset { n } { \\sum } } \\log \\mathbb { P } \\left[ y _ { i } \\middle \\vert y _ { 1 } , \\ldots , y _ { n - 1 } , \\left\\{ \\mathbf { x } _ { i j } \\right\\} \\right] . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            259,
+            155,
+            735,
+            242
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Since (3) contains summation over words, LC method naturally favors longer sentences. Because longer sentences requires more labor for annotation, we find this undesirable, and propose to normalize (3) as follows, which we call Maximum Normalized Log-Probability method: ",
+        "bbox": [
+            178,
+            250,
+            821,
+            292
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/00e9b5b42eeb038e237090dddf5daa6a338e6e1b84b6d795e32873165f4f9595.jpg",
+        "text": "$$\n\\operatorname* { m a x } _ { y _ { 1 } , \\ldots , y _ { n } } { \\frac { 1 } { n } } \\sum _ { i = 1 } ^ { n } \\log \\mathbb { P } \\left[ y _ { i } \\mid y _ { 1 } , \\ldots , y _ { n - 1 } , \\left\\{ \\mathbf { x } _ { i j } \\right\\} \\right] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            344,
+            303,
+            651,
+            344
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Bayesian Active Learning by Disagreement (BALD): We also consider sampling according to the measure of uncertainty proposed by Gal et al. (2017). Observing a correspondence between dropout (Srivastava et al., 2014) and deep Gaussian processes (Damianou & Lawrence, 2013), they propose that the variability of the predictions over successive forward passes due to dropout can be interpreted as a measure of the model’s uncertainty (Gal & Ghahramani, 2016). Denote $\\mathbb { P } ^ { 1 ^ { \\bullet } , \\mathbb { P } ^ { 2 } , \\dots . \\mathbb { P } ^ { M } }$ as models resulting from applying $M$ independently sampled dropout masks. One measure of our uncertainty on the $i$ th word is $f _ { i }$ , the fraction of models which disagreed with the most popular choice: ",
+        "bbox": [
+            173,
+            361,
+            825,
+            460
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8ca4850f90b202e648ec472c7434a1b568eb6ca2bc9a11a9eb93608b30dcde59.jpg",
+        "text": "$$\nf _ { i } = 1 - \\frac { \\operatorname* { m a x } _ { y } \\left| \\left\\{ m : \\mathrm { a r g m a x } _ { y ^ { \\prime } } \\mathbb { P } ^ { m } \\left[ y _ { i } = y ^ { \\prime } \\right] = y \\right\\} \\right| } { M } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            321,
+            481,
+            674,
+            516
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $\\left. \\cdot \\right.$ denotes cardinality of a set. We normalize this by the number of words as $\\textstyle { \\frac { 1 } { n } } \\sum _ { j = 1 } ^ { n } f _ { j }$ , In this paper, we draw $M = 1 0 0$ independent dropout masks. ",
+        "bbox": [
+            174,
+            525,
+            825,
+            556
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Other Sampling Strategies. Consider that the confidence of the model can help to distinguish between hard and easy samples. Thus, sampling examples where the model is uncertain might save us from sampling too heavily from regions where the model is already proficient. But intuitively, when we query a batch of examples in each round, we might want to guard against querying examples that are too similar to each other, thus collecting redundant information. We also might worry that a purely uncertainty-based approach would oversample outliers. Thus we explore techniques to guard against these problems by selecting a set of samples that is representative of the dataset. Following Wei et al. (2015), we express the problem of maximizing representativeness of a labeled set as a submodular optimization problem, and provide an efficient streaming algorithm adapted to use a constraint suitable to the NER task. ",
+        "bbox": [
+            173,
+            574,
+            825,
+            715
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Our approach to representativeness-based sampling proceeds as follows: Denote $\\mathbb { X }$ as the set of all samples, and $\\mathbb { X } ^ { L } , \\mathring \\mathbb { X } ^ { U }$ representing the set of labeled and unlabeled samples respectively. For an unlabeled set $\\mathbb { S } \\in \\mathbb { X } ^ { U }$ , the utility $f _ { w }$ is defined as the summation of marginal utility gain over all unlabeled points, weighted by their uncertainty. More formally, ",
+        "bbox": [
+            174,
+            722,
+            825,
+            779
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0be50d5d535dd2124ab7c636e57ccbcd9e8a7eedfc3c78a642c7cacbc9385af5.jpg",
+        "text": "$$\nf _ { w } ( \\mathbb { S } ) = \\sum _ { i \\in \\mathbb { X } ^ { U } } \\mathbb { U } \\mathbb { S } ( i ) \\cdot \\left[ \\operatorname* { m a x } _ { j \\in \\mathbb { S } \\cup \\mathbb { X } ^ { \\mathbb { L } } } w ( i , j ) - \\operatorname* { m a x } _ { j \\in \\mathbb { X } ^ { \\mathbb { L } } } w ( i , j ) \\right] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            318,
+            787,
+            678,
+            829
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathrm { U S } ( i )$ is the uncertainty score on example $i$ . In order to find a good set $\\mathbb { S }$ with high $f _ { w }$ value, we exploit the submodularity of the function, and use an online algorithm under knapsack constraint. More details of this method can be found in the supplementary material (Appendix C). In our experiments, this approach fails to match the uncertainty-based heuristics or to improve upon them when used in combination. Nevertheless, we describe the algorithm and include the negative results for their scientific value. ",
+        "bbox": [
+            173,
+            839,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            326,
+            118
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.1 MODEL EFFICIENCY AND PERFORMANCE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            135,
+            496,
+            148
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In order to evaluate the efficiency and performance CNN-CNN-LSTM as well as other alternatives, we run the experiments on two widely used NER datasets: CoNLL-2003 English (Tjong Kim Sang & De Meulder, 2003) and OntoNotes-5.0 English (Pradhan et al., 2013). We use the standard split of training/validation/test sets, and use the validation set performance to determine hyperparameters such as the learning rate or the number of iterations for early stopping. Unlike Lample et al. (2016) and Chiu & Nichols (2016), we do not train on the validation dataset. We report the F1 score for each model, which is standard. We only consider neural models in this comparison, since they outperform non-neural models for this task. Since our goal here is to compare neural network architectures, we did not experiment with gazetteers. ",
+        "bbox": [
+            174,
+            161,
+            825,
+            286
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "For neural architectures previously explored by others, we simply cite reported metrics. For LSTM word-level encoder, we use single-layer model with 100 hidden units for CoNLL-2003 English (following Lample et al. (2016)) and two-layer model with 300 hidden units for OntoNotes 5.0 datasets (following Chiu & Nichols (2016)). For character-level LSTM encoder, we use single-layer LSTM with 25 hidden units (following Lample et al. (2016)). For CNN word-level encoder, we use two-layer CNNs with 800 filters and kernel width 5, and for CNN character-level encoder, we use single-layer CNNs with 50 filters and kernel width 3 (following Chiu & Nichols (2016)). Dropout probabilities are all set as 0.5. We use structured skip-gram model (Ling et al., 2015) trained on Gigawords-English corpus (Graff & Cieri, 2003), which showed a good boost over vanilla skip-gram model (Mikolov et al., 2013) we do not report here. We use vanilla stochastic gradient descent, since it is commonly reported in the named entity recognition literature that this outperforms more sophisticated methods at convergence (Lample et al., 2016; Chiu & Nichols, 2016). We uniformly set the step size as 0.001 and the batch size as 128. When using LSTMs for the tag decoder, for inference, we only use greedy decoding; beam search gave very marginal improvement in our initial experiments. We repeat each experiment four times, and report mean and standard deviation. In terms of measuring the training speed of our models, we compute the time spent for one iteration of training on the dataset, with eight K80 GPUs in p2.8xlarge on Amazon Web Services2. ",
+        "bbox": [
+            174,
+            292,
+            825,
+            529
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 3 and Table 4 show the comparison between our model and other best performing models. LSTM tag decoder shows performance comparable to CRF tag decoder, and it works better than the CRF decoder when used with CNN encoder; compare CNN-CNN-LSTM vs. CNN-CNN-CRF on both tables. On the CoNLL-2003 English dataset which has only four entity types, the training speed of CNN-CNN-LSTM and CNN-CNN-CRF are comparable. However, on the OntoNotes 5.0 English dataset which has 18 entity types, the training speed of CNN-CNN-LSTM is twice faster than CNN-CNN-CRF because the time complexity of computing the partition function for CRF is quadratic to the number of entity types. CNN-CNN-LSTM is also $44 \\%$ faster than CNN-LSTMLSTM on OntoNotes, showing the advantage of CNN over LSTM as word encoder; on CoNLL-2003, sentences tend to be shorter and this advantage was not clearly seen; its median number of words in sentences is 12 opposed 17 of OntoNotes. Compared to the CNN-LSTM-CRF model, which is considered as a state-of-the-art model in terms of performance (Chiu & Nichols, 2016; Strubell et al., 2017), CNN-CNN-LSTM provides four times speedup in terms of the training speed, and achieves comparatively high performance measured by F1 score. ",
+        "bbox": [
+            173,
+            536,
+            825,
+            729
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.2 PERFORMANCE OF DEEP ACTIVE LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            751,
+            517,
+            763
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We use OntoNotes-5.0 English and Chinese data (Pradhan et al., 2013) for our experiments. The training datasets contain 1,088,503 words and 756,063 words respectively. State-of-the-art models trained on the full training sets achieve F1 scores of 86.86 Strubell et al. (2017) and 75.63 (our CNN-CNN-LSTM) on the test sets. ",
+        "bbox": [
+            174,
+            776,
+            825,
+            833
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Comparisons of selection algorithms We empirically compare selection algorithms proposed in Section 4, as well as uniformly random baseline (RAND). All algorithms start with an identical $1 \\%$ of original training data and a randomly initialized model. In each round, every algorithm chooses sentences from the rest of the training data until 20,000 words have been selected, adding this data to its training set. We then update each model by stochastic gradient descent on its augmented training dataset for 50 passes. We evaluate the performance of algorithm by its F1 score on the test dataset. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            895
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/1bdd99a6dc7a213458d518e2c13c216153f3ea53fa499273468cdf948f71e113.jpg",
+        "table_caption": [
+            "Table 3: Evaluations on the test set of CoNLL-2003 English "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Char</td><td>Word</td><td>Tag</td><td>Reference</td><td>F1</td><td>Sec/Epoch</td></tr><tr><td>None</td><td>CNN</td><td>CRF</td><td>Collobert et al. (2011)</td><td>88.67</td><td></td></tr><tr><td>None</td><td>LSTM</td><td>CRF</td><td>Huang et al. (2015)</td><td>90.10</td><td></td></tr><tr><td>LSTM</td><td>LSTM</td><td>CRF</td><td>Lample et al. (2016)</td><td>90.94</td><td></td></tr><tr><td>CNN</td><td>LSTM</td><td>CRF</td><td>Chiu &amp; Nichols (2016)</td><td>90.91 ± 0.20</td><td></td></tr><tr><td>GRU</td><td>GRU</td><td>CRF</td><td>Yang et al. (2016)</td><td>90.94</td><td></td></tr><tr><td>None</td><td>Dilated CNN</td><td>CRF</td><td>Strubell et al. (2017)</td><td>90.54 ± 0.18</td><td>-</td></tr><tr><td>LSTM</td><td>LSTM</td><td>LSTM</td><td></td><td>90.89 ± 0.19</td><td>49</td></tr><tr><td>CNN</td><td>LSTM</td><td>LSTM</td><td></td><td>90.58 ± 0.28</td><td>11</td></tr><tr><td>CNN</td><td>CNN</td><td>LSTM</td><td></td><td>90.69 ± 0.19</td><td>11</td></tr><tr><td>CNN</td><td>CNN</td><td>CRF</td><td></td><td>90.35 ± 0.24</td><td>12</td></tr></table>",
+        "bbox": [
+            179,
+            101,
+            818,
+            276
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/79384c61fb684102de8fbd4b8cb7754d303dfa07341da1385c34722b72ebfe43.jpg",
+        "table_caption": [
+            "Table 4: Evaluations on the test set of OntoNotes 5.0 English. $( ^ { * } )$ Training speed of CNN-LSTM-CRF model was measured with our own implementation of it. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Char</td><td>Word</td><td>Tag</td><td>Reference</td><td>F1</td><td>Sec/Epoch</td></tr><tr><td>CNN</td><td>LSTM</td><td>CRF</td><td>Chiu &amp; Nichols (2016)</td><td>86.28 ± 0.26</td><td>83*</td></tr><tr><td>None</td><td>Dilated CNN</td><td>CRF</td><td>Strubell et al. (2017)</td><td>86.84 ± 0.19</td><td>1</td></tr><tr><td>CNN</td><td>LSTM</td><td>LSTM</td><td></td><td>86.40 ± 0.48</td><td>76</td></tr><tr><td>CNN</td><td>CNN</td><td>LSTM</td><td></td><td>86.52 ± 0.25</td><td>22</td></tr><tr><td>CNN</td><td>CNN</td><td>CRF</td><td></td><td>86.15 ± 0.08</td><td>44</td></tr><tr><td>LSTM</td><td>LSTM</td><td>LSTM</td><td></td><td>86.63 ± 0.49</td><td>206</td></tr></table>",
+        "bbox": [
+            179,
+            318,
+            820,
+            438
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            507,
+            823,
+            535
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Figure 4 shows the results. All active learning algorithms perform significantly better than the random baseline. Among active learners, MNLP and BALD slightly outperformed traditional LC in early rounds. Note that MNLP is computationally more efficient than BALD, since it only requires a single forward pass on the unlabeled dataset to compute uncertainty scores, whereas BALD requires multiple forward passes. Impressively, active learning algorithms achieve $9 9 \\%$ performance of the best deep model trained on full data using only $2 4 . 9 \\%$ of the training data on the English dataset and $3 0 . 1 \\%$ on Chinese. Also, $1 2 . 0 \\%$ and $1 6 . 9 \\%$ of training data were enough for deep active learning algorithms to surpass the performance of the shallow models from Pradhan et al. (2013) trained on the full training data. We repeated the ",
+        "bbox": [
+            174,
+            540,
+            485,
+            791
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/1af3752b9ddc222e9b22bcb8fd3ad79aaf32ea2de65e6b590c98ff09b2bc6579.jpg",
+        "image_caption": [
+            "Figure 5: Genre distribution of top 1,000 sentences chosen by an active learning algorithm "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            517,
+            574,
+            790,
+            722
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "experiment eight times and confirmed that the trend is replicated across multiple runs; see Appendix B for details. ",
+        "bbox": [
+            174,
+            791,
+            823,
+            819
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Detection of under-explored genres To better understand how active learning algorithms choose informative examples, we designed the following experiment. The OntoNotes datasets consist of six genres: broadcast conversation (bc), braodcast news (bn), magazine genre (mz), newswire (nw), telephone conversation (tc), weblogs (wb). We created three training datasets: half-data, which contains random $50 \\%$ of the original training data, nw-data, which contains sentences only from newswire $5 1 . 5 \\%$ of words in the original data), and no-nw-data, which is the complement of nwdata. Then, we trained CNN-CNN-LSTM model on each dataset. The model trained on half-data achieved 85.10 F1, significantly outperforming others trained on biased datasets (no-nw-data: 81.49, nw-only-data: 82.08). This showed the importance of good genre coverage in training data. Then, we analyzed the genre distribution of 1,000 sentences MNLP chose for each model (see Figure 5). For no-nw-data, the algorithm chose many more newswire (nw) sentences than it did for unbiased half-data (367 vs. 217). On the other hand, it undersampled newswire sentences for nw-only-data and increased the proportion of broadcast news and telephone conversation, which are genres distant from newswire. Impressively, although we did not provide the genre of sentences to the algorithm, it was able to automatically detect underexplored genres. ",
+        "bbox": [
+            173,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/b5ac393b740a11100da496af3f87cd9e57aecb325b4a7a51011ccdaac2b7e9d4.jpg",
+        "image_caption": [
+            "Figure 4: F1 score on the test dataset, in terms of the number of words labeled. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            98,
+            849,
+            303
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            342,
+            826,
+            453
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            473,
+            318,
+            488
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We proposed an efficient model for NER tasks which gives high performances on well-established datasets. Further, we use deep active learning algorithms for NER and empirically demonstrated that they achieve state-of-the-art performance with much less data than models trained in the standard supervised fashion. ",
+        "bbox": [
+            174,
+            503,
+            825,
+            560
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            580,
+            285,
+            595
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Daniel Andor, Chris Alberti, David Weiss, Aliaksei Severyn, Alessandro Presta, Kuzman Ganchev, Slav Petrov, and Michael Collins. Globally normalized transition-based neural networks. arXiv preprint arXiv:1603.06042, 2016. ",
+        "bbox": [
+            174,
+            603,
+            825,
+            646
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Pranjal Awasthi, Maria Florina Balcan, and Philip M Long. The power of localization for efficiently learning linear separators with noise. In Proceedings of the 46th Annual ACM Symposium on Theory of Computing, pp. 449–458. ACM, 2014. ",
+        "bbox": [
+            174,
+            654,
+            823,
+            696
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ashwinkumar Badanidiyuru, Baharan Mirzasoleiman, Amin Karbasi, and Andreas Krause. Streaming submodular maximization: Massive data summarization on the fly. In Proceedings of the 20th ACM SIGKDD international conference on Knowledge discovery and data mining, pp. 671–680. ACM, 2014. ",
+        "bbox": [
+            171,
+            704,
+            828,
+            762
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Maria-Florina Balcan, Alina Beygelzimer, and John Langford. Agnostic active learning. Journal of Computer and System Sciences, 75(1):78–89, 2009. ",
+        "bbox": [
+            173,
+            770,
+            823,
+            799
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Alina Beygelzimer, Sanjoy Dasgupta, and John Langford. Importance weighted active learning. In Proceedings of the 26th annual international conference on machine learning, pp. 49–56. ACM, 2009. ",
+        "bbox": [
+            174,
+            806,
+            825,
+            849
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Kalina Bontcheva, Leon Derczynski, and Ian Roberts. Crowdsourcing named entity recognition and entity linking corpora. In Handbook of Linguistic Annotation, pp. 875–892. Springer, 2017. ",
+        "bbox": [
+            176,
+            858,
+            821,
+            887
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jason PC Chiu and Eric Nichols. Named entity recognition with bidirectional lstm-cnns. Transactions of the Association for Computational Linguistics, 4:357–370, 2016. ",
+        "bbox": [
+            174,
+            895,
+            820,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ronan Collobert, Jason Weston, Léon Bottou, Michael Karlen, Koray Kavukcuoglu, and Pavel Kuksa. Natural language processing (almost) from scratch. Journal of Machine Learning Research, 12 (Aug):2493–2537, 2011. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            146
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Aron Culotta and Andrew McCallum. Reducing labeling effort for structured prediction tasks. In AAAI, volume 5, pp. 746–51, 2005. ",
+        "bbox": [
+            171,
+            154,
+            823,
+            184
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Andreas Damianou and Neil Lawrence. Deep gaussian processes. In Artificial Intelligence and Statistics, pp. 207–215, 2013. ",
+        "bbox": [
+            173,
+            190,
+            823,
+            220
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sanjoy Dasgupta, Adam Tauman Kalai, and Claire Monteleoni. Analysis of perceptron-based active learning. In International Conference on Computational Learning Theory, pp. 249–263. Springer, 2005. ",
+        "bbox": [
+            176,
+            228,
+            825,
+            271
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yarin Gal and Zoubin Ghahramani. A theoretically grounded application of dropout in recurrent neural networks. In Advances in Neural Information Processing Systems, pp. 1019–1027, 2016. ",
+        "bbox": [
+            171,
+            279,
+            823,
+            309
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yarin Gal, Riashat Islam, and Zoubin Ghahramani. Deep bayesian active learning with image data. arXiv preprint arXiv:1703.02910, 2017. ",
+        "bbox": [
+            171,
+            315,
+            825,
+            345
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "David Graff and Christopher Cieri. English gigaword, ldc catalog no. LDC2003T05. Linguistic Data Consortium, University of Pennsylvania, 2003. ",
+        "bbox": [
+            171,
+            353,
+            825,
+            382
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 770–778, 2016. ",
+        "bbox": [
+            174,
+            390,
+            826,
+            433
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Geoffrey Hinton, Li Deng, Dong Yu, George E Dahl, Abdel-rahman Mohamed, Navdeep Jaitly, Andrew Senior, Vincent Vanhoucke, Patrick Nguyen, Tara N Sainath, et al. Deep neural networks for acoustic modeling in speech recognition: The shared views of four research groups. IEEE Signal Processing Magazine, 29(6):82–97, 2012. ",
+        "bbox": [
+            173,
+            440,
+            825,
+            497
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sepp Hochreiter and Jürgen Schmidhuber. Long short-term memory. Neural computation, 9(8): 1735–1780, 1997. ",
+        "bbox": [
+            171,
+            506,
+            825,
+            535
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Zhiheng Huang, Wei Xu, and Kai Yu. Bidirectional lstm-crf models for sequence tagging. arXiv preprint arXiv:1508.01991, 2015. ",
+        "bbox": [
+            171,
+            542,
+            823,
+            571
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alex Kendall and Yarin Gal. What uncertainties do we need in bayesian deep learning for computer vision? arXiv preprint arXiv:1703.04977, 2017. ",
+        "bbox": [
+            171,
+            580,
+            825,
+            609
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Halil Kilicoglu, Asma Ben Abacha, Yassine Mrabet, Kirk Roberts, Laritza Rodriguez, Sonya E Shooshan, and Dina Demner-Fushman. Annotating named entities in consumer health questions. In LREC, 2016. ",
+        "bbox": [
+            174,
+            617,
+            825,
+            660
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yoon Kim. Convolutional neural networks for sentence classification. arXiv preprint arXiv:1408.5882, 2014. ",
+        "bbox": [
+            171,
+            667,
+            825,
+            696
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Andreas Krause and Daniel Golovin. Submodular function maximization. Tractability: Practical Approaches to Hard Problems, 3(19):8, 2012. ",
+        "bbox": [
+            171,
+            705,
+            825,
+            734
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. In Advances in neural information processing systems, pp. 1097–1105, 2012. ",
+        "bbox": [
+            176,
+            742,
+            825,
+            785
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "John Lafferty, Andrew McCallum, Fernando Pereira, et al. Conditional random fields: Probabilistic models for segmenting and labeling sequence data. In Proceedings of the eighteenth international conference on machine learning, ICML, volume 1, pp. 282–289, 2001. ",
+        "bbox": [
+            174,
+            792,
+            825,
+            837
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Guillaume Lample, Miguel Ballesteros, Sandeep Subramanian, Kazuya Kawakami, and Chris Dyer. Neural architectures for named entity recognition. In Proceedings of NAACL-HLT, pp. 260–270, 2016. ",
+        "bbox": [
+            176,
+            844,
+            825,
+            886
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun, Yoshua Bengio, et al. Convolutional networks for images, speech, and time series. The handbook of brain theory and neural networks, 3361(10):1995, 1995. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jure Leskovec, Andreas Krause, Carlos Guestrin, Christos Faloutsos, Jeanne VanBriesen, and Natalie Glance. Cost-effective outbreak detection in networks. In Proceedings of the 13th ACM SIGKDD international conference on Knowledge discovery and data mining, pp. 420–429. ACM, 2007. ",
+        "bbox": [
+            176,
+            103,
+            823,
+            147
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "David D Lewis and William A Gale. A sequential algorithm for training text classifiers. In Proceedings of the 17th annual international ACM SIGIR conference on Research and development in information retrieval, pp. 3–12. Springer-Verlag New York, Inc., 1994. ",
+        "bbox": [
+            174,
+            156,
+            826,
+            199
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Wang Ling, Chris Dyer, Alan Black, and Isabel Trancoso. Two/too simple adaptations of word2vec for syntax problems. In Proceedings of the 2015 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies. Association for Computational Linguistics, 2015. ",
+        "bbox": [
+            174,
+            208,
+            826,
+            265
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Christopher D Manning. Computational linguistics and deep learning. Computational Linguistics, 2016. ",
+        "bbox": [
+            174,
+            275,
+            825,
+            305
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Grégoire Mesnil, Xiaodong He, Li Deng, and Yoshua Bengio. Investigation of recurrent-neuralnetwork architectures and learning methods for spoken language understanding. In Interspeech, pp. 3771–3775, 2013. ",
+        "bbox": [
+            173,
+            314,
+            825,
+            358
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tomas Mikolov, Ilya Sutskever, Kai Chen, Greg S Corrado, and Jeff Dean. Distributed representations of words and phrases and their compositionality. In Advances in neural information processing systems, pp. 3111–3119, 2013. ",
+        "bbox": [
+            174,
+            367,
+            823,
+            410
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Vinod Nair and Geoffrey E Hinton. Rectified linear units improve restricted boltzmann machines. In Proceedings of the 27th international conference on machine learning (ICML-10), pp. 807–814, 2010. ",
+        "bbox": [
+            174,
+            420,
+            826,
+            463
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "George L Nemhauser, Laurence A Wolsey, and Marshall L Fisher. An analysis of approximations for maximizing submodular set functions—i. Mathematical Programming, 14(1):265–294, 1978. ",
+        "bbox": [
+            173,
+            473,
+            823,
+            503
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Thien Huu Nguyen, Avirup Sil, Georgiana Dinu, and Radu Florian. Toward mention detection robustness with recurrent neural networks. arXiv preprint arXiv:1602.07749, 2016. ",
+        "bbox": [
+            173,
+            512,
+            823,
+            542
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Fredrik Olsson. A literature survey of active machine learning in the context of natural language processing. 2009. ",
+        "bbox": [
+            169,
+            551,
+            823,
+            580
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sameer Pradhan, Alessandro Moschitti, Nianwen Xue, Hwee Tou Ng, Anders Björkelund, Olga Uryupina, Yuchen Zhang, and Zhi Zhong. Towards robust linguistic analysis using ontonotes. In CoNLL, pp. 143–152, 2013. ",
+        "bbox": [
+            176,
+            590,
+            825,
+            633
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nils Reimers and Iryna Gurevych. Reporting score distributions makes a difference: Performance study of lstm-networks for sequence tagging. In Proceedings of the 2017 Conference on Empirical Methods in Natural Language Processing, pp. 338–348, 2017. ",
+        "bbox": [
+            174,
+            643,
+            825,
+            688
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Burr Settles. Active learning literature survey. University of Wisconsin, Madison, 52(55-66):11, 2010. ",
+        "bbox": [
+            169,
+            696,
+            823,
+            713
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Burr Settles and Mark Craven. An analysis of active learning strategies for sequence labeling tasks. In Proceedings of the conference on empirical methods in natural language processing, pp. 1070–1079. Association for Computational Linguistics, 2008. ",
+        "bbox": [
+            174,
+            722,
+            826,
+            765
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Dan Shen, Jie Zhang, Jian Su, Guodong Zhou, and Chew-Lim Tan. Multi-criteria-based active learning for named entity recognition. In Proceedings of the 42nd Annual Meeting on Association for Computational Linguistics, pp. 589. Association for Computational Linguistics, 2004. ",
+        "bbox": [
+            174,
+            775,
+            825,
+            818
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nitish Srivastava, Geoffrey E Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout a simple way to prevent neural networks from overfitting. Journal of Machine Learning Research, 15(1):1929–1958, 2014. ",
+        "bbox": [
+            178,
+            828,
+            825,
+            871
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Emma Strubell, Patrick Verga, David Belanger, and Andrew McCallum. Fast and accurate entity recognition with iterated dilated convolutions. In Proceedings of the 2017 Conference on Empirical Methods in Natural Language Processing, pp. 2660–2670, 2017. ",
+        "bbox": [
+            174,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Erik F Tjong Kim Sang and Fien De Meulder. Introduction to the conll-2003 shared task: Languageindependent named entity recognition. In Proceedings of the seventh conference on Natural language learning at HLT-NAACL 2003-Volume 4, pp. 142–147. Association for Computational Linguistics, 2003. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            159
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Simon Tong and Daphne Koller. Support vector machine active learning with applications to text classification. Journal of machine learning research, 2(Nov):45–66, 2001. ",
+        "bbox": [
+            171,
+            169,
+            825,
+            196
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Keze Wang, Dongyu Zhang, Ya Li, Ruimao Zhang, and Liang Lin. Cost-effective active learning for deep image classification. IEEE Transactions on Circuits and Systems for Video Technology, 2016. ",
+        "bbox": [
+            174,
+            205,
+            823,
+            236
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Kai Wei, Rishabh Iyer, and Jeff Bilmes. Submodularity in data subset selection and active learning. In Proceedings of the 32nd International Conference on Machine Learning (ICML-15), pp. 1954– 1963, 2015. ",
+        "bbox": [
+            174,
+            243,
+            825,
+            286
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Songbai Yan and Chicheng Zhang. Revisiting perceptron: Efficient and label-optimal active learning of halfspaces. arXiv preprint arXiv:1702.05581, 2017. ",
+        "bbox": [
+            171,
+            295,
+            823,
+            325
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Zhilin Yang, Ruslan Salakhutdinov, and William Cohen. Multi-task cross-lingual sequence tagging from scratch. arXiv preprint arXiv:1603.06270, 2016. ",
+        "bbox": [
+            173,
+            333,
+            823,
+            363
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Feifei Zhai, Saloni Potdar, Bing Xiang, and Bowen Zhou. Neural models for sequence chunking. In AAAI, pp. 3365–3371, 2017. ",
+        "bbox": [
+            173,
+            371,
+            823,
+            400
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ye Zhang, Matthew Lease, and Byron C Wallace. Active discriminative text representation learning. In AAAI, pp. 3386–3392, 2017. ",
+        "bbox": [
+            173,
+            409,
+            825,
+            438
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A EFFECT OF BEAM SIZE ON LSTM DECODER ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            578,
+            118
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "One potential concern when decoding with an LSTM decoder as compared to using a CRF decoder is that finding the best sequence of labels that maximizes the probability $\\mathbb { P } \\left[ t _ { 2 } , t _ { 3 } , \\ldots , t _ { n - 1 } \\mid \\left\\{ { \\bf h } _ { i } ^ { \\mathrm { E n c } } \\right\\} \\right]$ is computationally intractable. In practice, however, we find that simple greedy decoding, i.e., beam search with beam size 1, works surprisingly well. Table 5 shows how changing the beam size of decoder affects the performance of the model. It can be seen that the performance of the model changes very little with respect to the beam size. Beam search with size 2 is marginally better than greedy decoding, and further increasing the beam size did not help at all. Moreover, we note that while it may be computationally efficient to pick the most likely tag sequence given a CRF encoder, the LSTM decoder may give more accurate predictions, owing to it’s greater representational power and ability to model long-range dependencies. Thus even if we do not always choose the most probable tag sequence from the LSTM, we can still outperform the CRF (as our experiments demonstrate). ",
+        "bbox": [
+            174,
+            133,
+            825,
+            301
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/99f9854ef3a0b4a5aaa875c402c1f7a6df97a394c4d2d028048bad2295c7fa60.jpg",
+        "table_caption": [
+            "Table 5: Effect of beam size in LSTM decoder. We used a single LSTM-LSTM-LSTM model, and evaluated on OntoNotes 5.0 English dataset. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Beam Size</td><td>F1</td></tr><tr><td>1</td><td>87.26</td></tr><tr><td>2</td><td>87.34</td></tr><tr><td>4</td><td>87.33</td></tr><tr><td>8</td><td>87.33</td></tr><tr><td>16</td><td>87.33</td></tr></table>",
+        "bbox": [
+            423,
+            315,
+            575,
+            415
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "B LEARNING CURVE IN ACTIVE LEARNING EXPERIMENTS ACROSS MULTIPLE RUNS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            494,
+            748,
+            529
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In order to understand the variability of learning curves in Figure 4a across experiments, we repeated the active learning experiment on OntoNotes-5.0 English eight times, each of which started with different initial dataset chosen randomly. Figure 6 shows the result in first nine rounds of labeled data acquisition. While MNLP, LC and BALD are all competitive against each other, there is a noticeable trend that MNLP and BALD outperforms LC in early rounds of data acquisition. ",
+        "bbox": [
+            174,
+            545,
+            825,
+            614
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "C REPRESENTATIVENESS-BASED ACTIVE LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            638,
+            622,
+            652
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Consider that the confidence of the model can help to distinguish between hard and easy samples. Thus, sampling examples where the model is uncertain might save us from sampling too heavily from regions where the model is already proficient. But intuitively, when we query a batch of examples in each round, we might want to guard against querying examples that are too similar to each other, thus collecting redundant information. We also might worry that a purely uncertainty-based approach would oversample outliers. Thus we explore techniques to guard against these problems by selecting a set of samples that is representative of the dataset. Following Wei et al. (2015), we express the problem of maximizing representativeness of a labeled set as a submodular optimization problem, and provide an efficient streaming algorithm adapted to use a constraint suitable to the NER task. We also provide some with theoretical guarantees. ",
+        "bbox": [
+            173,
+            670,
+            826,
+            809
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Submodular utility function In order to reason about the similarity between samples, we first embed each sample $i$ into a fixed-dimensional euclidean space as a vector $\\mathbf { x } _ { i }$ . We consider two embedding methods: 1) the average of pre-trained word embeddings, $\\begin{array} { r } { \\frac { 1 } { n } \\sum _ { t = 1 } ^ { n } { \\bf w } _ { t } ^ { \\mathrm { e m b } } } \\end{array}$ , which can be efficiently computed without training of the NER model, and 2) the average of activation maps at the topmost layer of the encoder $\\textstyle { \\frac { 1 } { n } } \\sum _ { t = 1 } ^ { n } \\mathbf { h } _ { t } ^ { \\mathrm { E n c } }$ , an embedding which might be better suited to the context of the NER task. Then, we consider the following options for defining similarity scores $w ( i , j )$ between each pair of samples $i$ and $j$ : $w ( i , j ) = d - \\| x ^ { i } - x ^ { j } \\| _ { p }$ where $\\begin{array} { r } { \\dot { d } = \\operatorname* { m a x } _ { i , j \\in \\mathbb { X } } \\| x ^ { i } - \\dot { x } ^ { j } \\| _ { p } } \\end{array}$ for $p = 1 , 2$ which corresponds to closeness in $L _ { 1 }$ and $L _ { 2 }$ distance (Wei et al., 2015), and $w ( i , j ) =$ $\\begin{array} { r } { 1 + \\frac { x _ { i } \\cdot x _ { j } } { \\| x _ { i } \\| \\cdot \\| x _ { j } \\| } } \\end{array}$ , which corresponds to cosine similarity. ",
+        "bbox": [
+            173,
+            827,
+            825,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/de6e0f584828095d7382a60891c13b1343e96742f2bc69d051247ed27200ca63.jpg",
+        "image_caption": [
+            "Figure 6: Test F1 score in first nine rounds of labeled data acquisition on OntoNotes-5.0 English dataset across multiple runs of the active learning experiment. The experiment was repeated eight times, with different initial dataset. Error bars indicates standard deviation, and dots indicate individual observation. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            220,
+            140,
+            740,
+            433
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            534,
+            823,
+            564
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Now, we formally define the utility function for labeling new samples. Denote $\\mathbb { X }$ as the set of all samples which can be partitioned into two disjoint sets $\\mathbb { X } ^ { \\mathrm { L } }$ , $\\mathbb { X } ^ { \\mathbb { I } }$ representing labeled and unlabeled samples, respectively. Let $\\mathbb { S } \\subseteq \\mathbb { X } ^ { \\mathrm { U } }$ be a subset of unlabeled samples, then, the utility of labeling the set is defined as follows: ",
+        "bbox": [
+            173,
+            571,
+            825,
+            628
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/64b1912a2fd709bd57afe655ba3b59cf9098a706fde5fb02e7063383b86e7a10.jpg",
+        "text": "$$\nf ( \\mathbb { S } ) = \\sum _ { i \\in \\mathbb { X } ^ { \\mathbb { U } } } \\left[ \\operatorname* { m a x } _ { j \\in \\mathbb { S } \\cup \\mathbb { X } ^ { \\mathbb { L } } } w ( i , j ) - \\operatorname* { m a x } _ { j \\in \\mathbb { X } ^ { \\mathbb { L } } } w ( i , j ) \\right] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            348,
+            633,
+            648,
+            672
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "where the function measures incremental gain of similarity between the labeled set and the rest. Given such utility function $f ( \\cdot )$ , choosing a set $\\mathbb { S }$ that maximizes the function within the budget can be seen as a monotone submodular maximization problem under a knapsack constraint (Krause & Golovin, 2012): ",
+        "bbox": [
+            173,
+            680,
+            825,
+            736
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/606fef7bb410bbc84dec1a83f317152c2ada3e09ac49a78586705bf87677b93d.jpg",
+        "text": "$$\n\\operatorname { m a x } _ { \\mathbb { S } \\subseteq \\mathbb { X } ^ { \\cup } , \\sum _ { e \\in \\mathbb { S } } k ( \\{ e \\} ) \\leq K } f ( \\mathbb { S } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            415,
+            736,
+            583,
+            762
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "where $k ( \\mathbb { S } )$ is the budget for the sample set $\\mathbb { S }$ , and $K$ is the total budget within each round. Note that we need to consider the knapsack constraint instead of the cardinality constraint used in the prior work (Wei et al., 2015), because the entire sentence needs to be labeled once selected and sequences of length confer different labeling costs. ",
+        "bbox": [
+            173,
+            767,
+            825,
+            824
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Combination with uncertainty sampling Representation-based sampling can benefit from uncertainty-based sampling in the following two ways. First, we can re-weight each sample in the utility function (5) to reflect current model’s uncertainty on it: ",
+        "bbox": [
+            173,
+            839,
+            823,
+            882
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c404a73d2bccf3a3685ac105fcf649e782a27d7ec3a28863915f2f962fc03cea.jpg",
+        "text": "$$\nf _ { w } ( \\mathbb { S } ) = \\sum _ { i } \\mathbb { U } \\mathbb { S } ( i ) \\cdot \\left[ \\operatorname* { m a x } _ { j \\in \\mathbb { S } \\cup \\mathbb { X } ^ { \\perp } } w ( i , j ) - \\operatorname* { m a x } _ { j \\in \\mathbb { X } ^ { \\perp } } w ( i , j ) \\right] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            321,
+            890,
+            674,
+            928
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 Representativeness-based Sampling ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            118,
+            475,
+            132
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "1: Input: Samples $\\{ \\mathbb { X } ^ { \\mathbb { U } } , \\mathbb { X } ^ { \\mathtt { L } } \\}$ , budget $K$ ,   \npretrained model $\\mathbb { M }$ using $\\mathbb { X } ^ { \\mathrm { L } }$   \n2: while Test score of $\\mathbb { M }$ less than th do   \n3: Rank $\\mathbb { X } ^ { \\mathbb { I } }$ according to Sec. 4,   \n$\\tilde { \\mathbb { X } } ^ { \\mathbb { I } } =$ top samples $\\mathbb { S }$ within budget $t \\cdot K$   \n4: Set $f$ according to (5) or (7)   \n5: $\\mathbb { S } =$ StreamSubmod $\\mathsf { M a x } ( f , \\tilde { \\mathbb { X } } ^ { \\mathrm { U } } )$ .   \n6: $\\{ \\tilde { \\mathbb { X } } ^ { \\cup } , \\mathbb { X } ^ { \\mathtt { L } } \\} = \\{ \\mathbb { X } ^ { \\cup } - \\mathbb { S } , \\mathbb { X } ^ { \\mathtt { L } } \\cup \\mathbb { S } \\}$   \n7: Train $\\mathbb { M }$ with $\\mathbb { X } ^ { \\mathrm { L } }$ .   \n8: Output: M   \n1: Input: Submodular function $g$ , set X˜ U   \n2: $m = \\operatorname* { m a x } _ { e \\in \\tilde { \\mathbb { X } } ^ { \\cup } } g ( \\{ e \\} ) / k ( \\{ e \\} )$   \n3: $O = \\{ ( 1 + \\epsilon ) ^ { i } | i \\in \\mathbb { Z } , ( 1 + \\epsilon ) ^ { i } \\in [ m , K m ] \\}$   \n4: $\\mathbb { S } _ { v } : = \\varnothing , \\forall v \\in O$   \n5: for $e$ in $\\tilde { \\mathbb { X } } ^ { \\mathbb { U } }$ do   \n6: for $v \\in O$ and $k ( \\mathbb { S } _ { v } \\cup \\{ e \\} ) \\leq K$ do   \n7: i $\\begin{array} { r } { \\mathsf { f } \\Delta _ { g } ( e | \\mathbb { S } _ { v } ) \\ge \\frac { k ( \\{ e \\} ) ( v / 2 - g ( \\mathbb { S } _ { v } ) ) } { K - k ( \\mathbb { S } _ { v } ) } } \\end{array}$ then   \n8: Sv := Sv ∪ {e}   \n9: Output: arg maxv∈O f (Sv) ",
+        "bbox": [
+            179,
+            137,
+            482,
+            285
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            516,
+            138,
+            820,
+            280
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathrm { U S } ( i )$ is the uncertainty score on example $i$ . Second, even with the state-of-the-art submodular optimization algorithms, the optimization problem (6) can be computationally intractable. To improve the computational efficiency, we restrict the set of unlabeled examples to top samples from uncertainty sampling within budget $t \\cdot K$ , where $t$ is a multiplication factor we set as 4 in our experiments. ",
+        "bbox": [
+            173,
+            314,
+            825,
+            371
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Streaming algorithm for sample selection Even with the reduction of candidates with uncertainty sampling, (6) is still a computationally challenging problem and requires careful design of optimization algorithms. Suppose $l$ is the number of samples we need to consider. In the simplistic case in which all the samples have the same length and thus the knapsack constraint degenerates to the cardinality constraint, the greedy algorithm (Nemhauser et al., 1978) has an $( 1 - 1 / e )$ -approximation guarantee. However, it requires calculating the utility function $O ( l ^ { 2 } n )$ times, where $n$ is the number of unlabeled samples. In practice, both $l$ and $n$ are large. Alternatively, we can use lazy evaluation to decrease the computation complexity to $O ( l n )$ (Leskovec et al., 2007), but it requires an additional hyperparameter to be chosen in advance. Instead of greedily selecting elements in an offline fashion, we adopt the two-pass streaming algorithm of Badanidiyuru et al. (2014), whose complexity is ${ \\cal \\tilde { O } } ( l n ) ^ { 3 }$ , and generalize it to the knapsack constraint (shown in Alg. 2). In the first pass, we calculate the maximum function value of a single element normalized by its weight, which gives an estimate of the optimal value. In the second pass, we create $O ( \\textstyle { \\frac { 1 } { \\epsilon } } \\log K )$ buckets and greedily update each of the bucket according to: ",
+        "bbox": [
+            173,
+            386,
+            826,
+            582
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "equation",
+        "img_path": "images/66015aa9076bdd813d892de001cda384deb028d406b900c2bbfce01b6ff14115.jpg",
+        "text": "$$\n\\Delta _ { g } ( e | \\mathbb { S } _ { v } ) \\geq \\frac { k ( \\{ e \\} ) ( v / 2 - g ( \\mathbb { S } _ { v } ) ) } { K - k ( \\mathbb { S } _ { v } ) } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            379,
+            579,
+            617,
+            613
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "where each bucket has a different value $v$ , and $\\Delta _ { g } ( e | \\mathbb { S } _ { v } ) : = g ( \\{ e \\} \\cup \\mathbb { S } _ { v } ) - g ( \\mathbb { S } _ { v } )$ is the marginal improvement of submodular function $g$ when adding element $e$ to set $\\mathbb { S } _ { v }$ . The whole pipeline of the active learning algorithm is shown in Alg. 1. The algorithm gives the following guarantee, which is proven in Appendix. ",
+        "bbox": [
+            174,
+            616,
+            825,
+            674
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Theorem 1. Alg. 2 gives $a$ $\\frac { ( 1 - \\epsilon ) ( 1 - \\delta ) } { 2 }$ -approximation guarantee for (6), where $\\delta \\quad =$ $\\operatorname* { m a x } _ { e \\in \\mathbb { S } } k ( \\{ e \\} ) / \\bar { K }$ . ",
+        "bbox": [
+            169,
+            676,
+            823,
+            709
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Proof sketch: The criterion (8) we use guarantees that each update we make is reasonably good. The set $\\mathbb { S } _ { v }$ stops updating when either the current budget is almost $K$ , or any sample in the stream after we reach $\\mathbb { S } _ { v }$ does not provide enough marginal improvement. While it is easy to give guarantees when the budget is exhausted, it is unlikely to happen; we use a difference expression between current set $\\mathbb { S } _ { v }$ and the optimal set, and prove the gap between the two is under control. ",
+        "bbox": [
+            173,
+            719,
+            825,
+            791
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "In a practical label acquisition process, the budget we set for each round is usually much larger than the length of the longest sentence in the unlabeled set, making $\\delta$ negligible. In our experiments, $\\delta$ was around 0.01. ",
+        "bbox": [
+            174,
+            797,
+            825,
+            839
+        ],
+        "page_idx": 14
+    }
+]