Add files using upload-large-folder tool

parse/train/BJfYvo09Y7/BJfYvo09Y7.md

@@ -0,0 +1,337 @@
+# HIERARCHICAL VISUOMOTOR CONTROLOF HUMANOIDS
+
+Josh Merel∗, Arun Ahuja∗,   
+Vu Pham, Saran Tunyasuvunakool, Siqi Liu, Dhruva Tirumala,   
+Nicolas Heess & Greg Wayne   
+DeepMind   
+London, UK   
+{jsmerel,arahuja,vuph,stunya,liusiqi,dhruvat, heess,gregwayne}@google.com
+
+# ABSTRACT
+
+We aim to build complex humanoid agents that integrate perception, motor control, and memory. In this work, we partly factor this problem into low-level motor control from proprioception and high-level coordination of the low-level skills informed by vision. We develop an architecture capable of surprisingly flexible, task-directed motor control of a relatively high-DoF humanoid body by combining pre-training of low-level motor controllers with a high-level, task-focused controller that switches among low-level sub-policies. The resulting system is able to control a physically-simulated humanoid body to solve tasks that require coupling visual perception from an unstabilized egocentric RGB camera during locomotion in the environment. Supplementary video link1
+
+# 1 INTRODUCTION
+
+In reinforcement learning (RL), a major challenge is to simultaneously cope with high-dimensional input and high-dimensional action spaces. As techniques have matured, it is now possible to train high-dimensional vision-based policies from scratch to generate a range of interesting behaviors ranging from game-playing to navigation (Jaderberg et al., 2018; OpenAI, 2018; Wayne et al., 2018). Likewise, for controlling bodies with a large number of degrees of freedom (DoFs), in simulation, reinforcement learning methods are beginning to surpass optimal control techniques. Here, we try to synthesize this progress and tackle high-dimensional input and output at the same time. We evaluate the feasibility of full-body visuomotor control by comparing several strategies for humanoid control from vision.
+
+Both to simplify the engineering of a visuomotor system and to reduce the complexity of taskdirected exploration, we construct modular agents in which a high-level system possessing egocentric vision and memory is coupled to a low-level, reactive motor control system. We build on recent advances in imitation learning to make flexible low-level motor controllers for high-DoF humanoids. The motor skills embodied by the low-level controllers are coordinated and sequenced by the high-level system, which is trained to maximize sparse task reward.
+
+Our approach is inspired by themes from neuroscience as well as ideas developed and made concrete algorithmically in the animation and robotics literatures. In motor neuroscience, studies of spinal reflexes in animals ranging from frogs to cats have led to the view that locomotion and reaching are highly prestructured, enabling subcortical structures such as the basal ganglia to coordinate a motor repertoire; and cortical systems with access to visual input can send low complexity signals to motor systems in order to evoke elaborate movements (Flash & Hochner, 2005; Bizzi et al., 2008; Grillner et al., 2005).
+
+The study of “movement primitives” for robotics descends from the work of Ijspeert et al. (2002). Subsequent research has focused on innovations for learning or constructing primitives for control of movments (Ijspeert et al., 2003; Kober & Peters, 2009), deploying and sequencing them to solve tasks (Sentis & Khatib, 2005; Kober & Peters, 2014; Konidaris et al., 2012), and increasing the complexity of the control inputs to the primitives (Neumann et al., 2014). Particularly relevant to our cause is the work of Kober et al. (2008) in which primitives were coupled by reinforcement learning to external perceptual inputs.
+
+Research in the animation literature has also sought to produce physically simulated characters capable of distinct movements that can be flexibly sequenced. This ambition can be traced to the virtual stuntman (Faloutsos et al., 2001b;a) and has been advanced markedly in the work of Liu (Liu et al., 2012). Further recent work has relied on reinforcement learning to schedule control policies known as “control fragments”, each one able to carry out only a specialized short movement segment (Liu & Hodgins, 2017; 2018). In work to date, such control fragments have yet to be coupled to visual input as we will pursue here. From the perspective of the RL literature (Sutton et al., 1999), motor primitives and control fragments may be considered specialized instantiations of “option” sub-policies.
+
+Our work aims to contribute to this multi-disciplinary literature by demonstrating concretely how control-fragment-like low-level movements can be coupled to and controlled by a vision and memory-based high-level controller to solve tasks. Furthermore, we demonstrate the scalability of the approach to greater number of control fragments than previous works. Taken together, we demonstrate progress towards the goal of integrated agents with vision, memory, and motor control.
+
+# 2 APPROACH
+
+We present a system capable of solving tasks from vision by switching among low-level motor controllers for the humanoid body. This scheme involves a general separation of control where a low-level controller handles motor coordination and a high-level controller signals/selects lowlevel behavior based on task context (see also Heess et al. 2016; Peng et al. 2017). In the present work, the low-level motor controllers operate using proprioceptive observations, and the high-level controller operate using proprioception along with first-person/egocentric vision. We first describe the procedure for creating low-level controllers from motion capture data, then describe and contrast multiple approaches for interfacing the high- and low-level controllers.
+
+# 2.1 TRACKING MOTION CAPTURE CLIPS
+
+For simulated character control, there has been a line of research extracting humanoid behavior from motion capture (“mocap”) data. The SAMCON algorithm is a forward sampling approach that converts a possibly noisy, kinematic pose sequence into a physical trajectory. It relies on a beamsearch-like planning algorithm (Liu et al., 2010; 2015) that infers an action sequence corresponding to the pose sequence. In subsequent work, these behaviors have been adapted into policies (Liu et al., 2012; Ding et al., 2015). More recently, RL has also been used to produce time-indexed policies which serve as robust tracking controllers (Peng et al., 2018). While the resulting time-indexed policies are somewhat less general as a result, time-indexing or phase-variables are common in the animation literature and also employed in kinematic control of characters (Holden et al., 2017). We likewise use mocap trajectories as reference data, from which we derive policies that are single purpose – that is, each policy robustly tracks a short motion capture reference motion (2-6 sec), but that is all each policy is capable of.
+
+Humanoid body We use a 56 degree-of-freedom (DoF) humanoid body that was developed in previous work (Merel et al., 2017), a version of which is available with motion-capture playback in the DeepMind control suite (Tassa et al., 2018). Here, we actuate the joints with position-control: each joint is given an actuation range in $[ - 1 , 1 ]$ , and this is mapped to the angular range of that joint.
+
+Single-clip tracking policies For each clip, we train a policy $\pi _ { \boldsymbol { \theta } } ( \boldsymbol { a } | \boldsymbol { s } , t )$ with parameters $\theta$ such that it maximizes a discounted sum of rewards, $r _ { t }$ , where the reward at each step comes from a custom scoring function (see eqns. 1, 2 defined immediately below). This tracking approach most closely follows Peng et al. (2018). Note that here the state optionally includes a normalized time $t$ that goes from 0 at the beginning of the clip to 1 at the end of the clip. For cyclical behaviors like locomotion, a gait cycle can be isolated manually and kinematically blended circularly by weighted linear interpolation of the poses to produce a repeating walk. The time input is reset each gaitcycle (i.e. it follows a sawtooth function). As proposed in Merel et al. (2017); Peng et al. (2018), episodes are initialized along the motion capture trajectory; and episodes can be terminated when it is determined that the behavior has failed significantly or irrecoverably. Our specific termination condition triggers if parts of the body other than hands or feet make contact with the ground. See Fig. 1 for a schematic.
+
+![](images/a52ff1c19d10a1768593fef3986a65bde7480d2334b7e76ecc0761318f823dab.jpg)  
+Figure 1: Illustration of tracking-based RL training. Training iteratively refines a policy to robustly track the reference trajectory as well as physically feasible.
+
+We first define an energy function most similar to SAMCON’s (Liu et al., 2010):
+
+$$
+\begin{array} { r } { E _ { t o t a l } = w _ { q p o s } E _ { q p o s } + w _ { q v e l } E _ { q v e l } + w _ { o r i } E _ { o r i } + } \\ { w _ { e e } E _ { e e } + w _ { v e l } E _ { v e l } + w _ { g y r o } E _ { g y r o } } \end{array}
+$$
+
+where $E _ { q p o s }$ is a energy defined on all joint angles, $E _ { q v e l }$ on joint velocities, $E _ { o r i }$ on the body root (global-space) quaternion, $E _ { e e }$ on egocentric vectors between the root and the end-effectors (see Merel et al. (2017)), $E _ { v e l }$ on the (global-space) translational velocities, and $E _ { g y r o }$ on the body root rotational velocities. More specifically:
+
+$$
+\begin{array} { l l } { { E _ { q p o s } = \displaystyle \frac { 1 } { N _ { q p o s } } \sum | \vec { q } _ { p o s } - \vec { q } _ { p o s } ^ { * } | } } & { { \qquad E _ { e e } = \displaystyle \frac { 1 } { N _ { e e } } \sum | | \vec { q } _ { e e } - \vec { q } _ { e e } ^ { * } | | _ { 2 } } } \\ { { E _ { q v e l } = \displaystyle \frac { 1 } { N _ { q v e l } } \sum | \vec { q } _ { v e l } - \vec { q } _ { v e l } ^ { * } | } } & { { \qquad E _ { v e l } = 0 . 1 \cdot \frac { 1 } { N _ { v e l } } \sum | \vec { x } _ { v e l } - \vec { x } _ { v e l } ^ { * } | } } \\ { { E _ { o r i } = | | \log ( \vec { q } _ { o r i } \cdot \vec { q } _ { o r i } ^ { * - 1 } ) | | _ { 2 } } } & { { \qquad E _ { g y r o } = 0 . 1 \cdot | | \vec { q } _ { g y r o } - \vec { q } _ { g y r o } ^ { * } | | _ { 2 } } } \end{array}
+$$
+
+where $\vec { q }$ represents the pose and $\vec { q } ^ { \star }$ represents the reference pose. In this work, we used coefficients $w _ { q p o s } = 5$ , $w _ { q v e l } = 1$ , $w _ { o r i } = 2 0$ , $w _ { g y r o } = 1$ , $w _ { v e l } = 1$ , $w _ { e e } = 2$ . We tuned these by sweeping over parameters in a custom implementation of SAMCON (not detailed here), and we have found these coefficients tend to work fairly well across a wide range of movements for this body.
+
+From the energy, we write the reward function:
+
+$$
+r _ { t } = \exp ( - \beta E _ { t o t a l } / w _ { t o t a l } )
+$$
+
+where $w _ { t o t a l }$ is the sum of the per energy-term weights and $\beta$ is a sharpness parameter ( $\beta = 1 0$ throughout). Since all terms in the energy are non-negative, the reward is normalized $r _ { t } \in ( 0 , 1 ]$ with perfect tracking giving a reward of 1 and large deviations tending toward 0.
+
+Acquiring reference data features for some quantities required setting the body to the pose specified by the joint angles: e.g., setting $\vec { x } _ { p o s }$ , $\vec { q } _ { p o s }$ , and $\vec { q } _ { o r i }$ to compute the end-effector vectors $\vec { q } _ { e e }$ . Joint angle velocities, root rotational velocities, and translational velocities $( \vec { q } _ { v e l } , \vec { q } _ { g y r o } , \vec { x } _ { v e l } )$ were derived from the motion capture data by finite difference calculations on the corresponding positions. Note that the reward function here was not restricted to egocentric features – indeed, the velocity and quaternion were non-egocentric. Importantly, however, the policy received exclusively egocentric observations, so that, for example, rotating the initial pose of the humanoid would not affect the policy’s ability to execute the behavior. The full set of proprioceptive features we provided the policy consists of joint angles $( \vec { q } _ { p o s } )$ and velocities $( \vec { q } _ { v e l } )$ , root-to-end-effector vectors $( \vec { q } _ { e e } )$ , rootframe velocimeter $( \vec { q } _ { v e l o c } )$ , rotational velocity $( \vec { q } _ { g y r o } )$ , root-frame accelerometers $( \vec { q } _ { a c c e l } )$ , and 3D orientation relative to the $\mathbf { Z }$ -axis $\vec { r } _ { z }$ : functionally a gravity sensor).
+
+Low-level controller reinforcement learning details Because the body is position-controlled, ( $\dot { \boldsymbol { a } } _ { t }$ has the same dimension and semantics as a subset of the body pose), we can pre-train the policy to produce target poses by supervised learning m $\begin{array} { r } { \operatorname * { l a x } _ { \theta } \sum _ { t } \log \pi \big ( \dot { q } _ { p o s , t + 1 } ^ { \ast } | s _ { t } ^ { \ast } , t \big ) } \end{array}$ . This produces very poor control but facilitates the subsequent stage of RL-based imitation learning. We generally found that training with some pretraining considerably shortened the time the training took to converge and improved the resulting policies.
+
+For RL, we performed off-policy training using a distributed actor-critic implementation, closest to that used in (Hausman et al., 2018). This implementation used a replay buffer and target networks as done in previous work (Lillicrap et al., 2015; Heess et al., 2015). The Q-function was learned off-policy using TD-learning using importance-weighted Retrace (Munos et al., 2016), and the actor was learned off-policy using SVG(0) (Heess et al., 2015). This is to say that we learned the policy by taking gradients with respect to the Q function (target networks were updated every 500 learning steps). Gradient updates to the policy were performed using short time windows, $\{ s _ { \tau } , a _ { \tau } \} _ { \tau = 1 \dots T }$ , sampled from replay:
+
+$$
+\operatorname* { m a x } _ { \pi _ { \theta } } \sum _ { \tau = 1 \dots T } \mathbb { E } _ { a \sim \pi ( a \mid s _ { \tau } ) } [ Q _ { t a r g e t } ( s _ { \tau } , a ) ] - \eta \mathcal { D } _ { K L } [ \pi _ { \theta } ( a \mid s _ { \tau } ) \mid | \pi _ { t a r g e t } ( a \mid s _ { \tau } ) ]
+$$
+
+where $\eta$ was fixed in our experiments. While the general details of the RL algorithm are not pertinent to the success of this approach (e.g. Peng et al. (2018) used on-policy RL), we found two details to be critical, and both were consistent with the results reported in Peng et al. (2018). Policy updates needed to be performed conservatively with the update including a term which restricts $\mathcal { D } _ { K L } [ \pi _ { n e w } | | \pi _ { o l d } ]$ (Heess et al., 2015; Schulman et al., 2017). Secondly, we found that attempting to learn the variance of the policy actions tended to result in premature convergence, so best results were obtained using a stochastic policy with fixed noise (we used noise with $\sigma = . 1$ ).
+
+# 2.2 VARIETIES OF LOW-LEVEL MOTOR CONTROL
+
+We next consider how to design low-level motor controllers derived from motion capture trajectories. Broadly, existing approaches fall into two categories: structured and cold-switching controllers. In structured controllers, there is a hand-designed relationship between “skill-selection” variables and the generated behavior. Recent work by Peng et al. (2018) explored specific handdesigned, structured controllers. While parameterized skill-selection coupled with manual curation and preprocessing of motion capture data can produce artistically satisfying results, the range of behavior has been limited and implementation requires considerable expertise and animation skill. By contrast, an approach in which behaviors are combined by a more automatic procedure promises to ultimately scale to a wider range of behaviors.
+
+Below, we describe some specific choices for both structured and cold-switching controllers. For structured control schemes, we consider: (1) a steerable controller that produces running behavior with a controllable turning radius, and (2) a switching controller that is a single policy that can switch between the behaviors learned from multiple mocap clips, with switch points allowed at the end of gait cycles. The allowed transitions were defined by a transition graph. For cold switching, we will not explicitly train transitions between behaviors.
+
+Steerable controller Following up on the ability to track a single cyclical behavior like locomotion described above, we can introduce the ability to parametrically turn. To do this we distorted the reference trajectory accordingly and trained the policy to track the reference with the turning radius as additional input. Each gait cycle we picked a random turning radius parameter and in that gaitcyle we rotate the reference clip heading $( \vec { q } _ { o r i } )$ at that constant rate (with appropriate bookkeeping for other positions and velocities). The result was a policy that, using only one gait cycle clip as input, could turn with a specified rate of turning.
+
+Switching controller An alternative to a single behavior with a single continuously controllable parameter is a single policy that is capable of switching among a discrete set of behaviors based on a 1-of- $k$ input. Training consisted of randomly starting in a pose sampled from a random mocap clip and transitioning among clips according to a graph of permitted transitions. Given a small, discrete set of clips that were manually “cut” to begin and end at similar points in a gait cycle, we initialized a discrete Markov process among clips with some initial distribution over clips and transitioned between clips that were compatible (walk forward to turn left, etc.) (Fig. 2).
+
+![](images/41f156a8599a7799b4decec73235f5cf28ac8e46bf148be9849e545f799100fd.jpg)  
+Figure 2: Training settings for explicit training of transition-capable controllers. Panel A depicts a cartoon of a training episode for a steerable controller in which the turning radius of a each gait-cycle is selected randomly. Panel B depicts training a policy under an explicit, hand-designed transition graph for $k$ options.
+
+Cold-switching of behaviors and control fragments We can also leave the task of sequencing behaviors to the high-level controller, instead of building structured low-level policies with explicit, designed transitions. Here, we did not attempt to combine the clips into a single policy; instead, we cut behaviors into short micro-behaviors of roughly 0.1 to 0.3 seconds, which we refer to as control fragments (Liu & Hodgins, 2017). Compared to switching using the complete behaviors, the micro-behaviors, or control fragments, allow for better transitions and more flexible locomotion. Additionally, we can easily scale to many clips without manual intervention. For example, clip 1 would generate a list of fragments: $\pi _ { 1 } ^ { 1 } \dot { ( } a | s _ { t } \dot { , } \tau )$ $\vert s _ { t } , \tau ) , \pi _ { 2 } ^ { 1 } ( a \vert s _ { t } , \tau ) , \ldots , \pi _ { 1 0 } ^ { 1 } ( a \vert s _ { t } , \tau )$ . When fragment 1 was chosen, $\tau$ the time-indexing variable was set to $\tau = 0$ initially and ticked until, say, $\tau =$ 0.1. Choosing fragment 2, $\pi _ { 2 } ^ { 1 }$ , would likewise send a signal to the clip 1 policy starting from $\tau = 0 . 1$ , etc. Whereas we have to specify a small set of consistent behaviors for the other lowlevel controller models, we could easily construct hundreds (or possibly more) control fragments cheaply and without significant curatorial attention. Since the control fragments were not trained with switching behavior, we refer to the random access switching among fragments by the highlevel controller as “cold-switching” (Fig. 3).
+
+![](images/a6d7a01dc50a75c518c7d4f24eabdbd3e67c1603d0153bd4c2ad7fe0d39b9be4.jpg)  
+Figure 3: Cold-switching among a set of behaviors (A) only at end of clips to form a trajectory composed of sequentially activation of the policies (B). Alternatively, policies are fragmented at a pre-specified set of times, cutting the policy into sub-policies (C), which serve as control fragments, enabling sequencing at a higher frequency (D).
+
+![](images/fe90f6cb65acf49f3aba690c9ea9e320407050a50e70ddac20984bb96d8d70a3.jpg)  
+Figure 4: Schematic of the architecture: a high-level controller (HL) selects among multiple lowlevel (LL) control fragments, which are policies with proprioception. Switching from one control fragment to another occurs every $k$ time steps.
+
+# 2.3 TRAINING HL-POLICIES TO SOLVE TASKS USING LL-CONTROLLERS
+
+We integrated the low-level controllers into an agent architecture with vision and and an LSTM memory in order to apply it to tasks including directed movements to target locations, a running course with wall or gap obstacles, a foraging task for “balls”, and a simple memory task involving detecting and memorizing the reward value of the balls.
+
+The interface between the high-level controller and the low-level depends on the type of low-level controller: for the steerable controller, the high-level produces a one-dimensional output; for the switching and control fragment controllers, the high-level produces a 1-of-K index to select the lowlevel policies. The high-level policies are trained off-policy using data from a replay buffer. The replay buffer contains data generated from distributed actors, and in general the learner processes the same replay data multiple times.
+
+The high-level controller senses inputs from proprioceptive data and, for visual tasks, an egocentric camera mounted at the root of the body (Fig. 4). A noteworthy challenge arises due to the movement of the camera itself during locomotion. The proprioceptive inputs are encoded by a single linear layer, and the image is encoded by a ResNet (see Appendix A). The separate inputs streams are then flattened, concatenated, and passed to an LSTM, enabling temporally integrated decisions, with a stochastic policy and a value function head. The high-level controller receives inputs at each time step even though it may only act when the previous behavior (gait cycle or control fragment) has terminated.
+
+Importantly, while the low-level skills used exclusively egocentric proprioceptive input, the highlevel controller used vision to select from or modulate them, enabling the system as a whole to effect visuomotor computations.
+
+High-level controller reinforcement learning details For the steerable controller, the policy was a parameterized Gaussian distribution that produces the steering angle $a _ { s } \in [ - 1 . 5 , 1 . 5 ]$ . The mean of Gaussian was constrained via a tanh and sampled actions were clipped to the steering angle range. The steering angle was held constant for a full gait cycle. The policy was trained as previously described by learning a state-action value function off-policy using TD-learning with Retrace (Munos et al., 2016) with the policy trained using SVG(0) (Heess et al., 2015).
+
+For the switching controller and the discrete control fragments approach, the policy was a multinomial over the discrete set of behaviors. In either case, the high-level controller would trigger the behavior for its period $T$ (a gait cycle or a fragment length). To train these discrete controllers, we fit the state-value baseline $V$ -function using V-Trace and update the policy according to the method in Espeholt et al. (2018). While we provided a target for the value function loss at each time step, the policy gradient loss for the high-level was non-zero only when a new action was sampled (every $T$ steps).
+
+![](images/6fde06b4a4230a10bdd07fed3dccb7725034668043b6a27735e50bc2924220a9.jpg)  
+Figure 5: A. Go-to-target: in this task, the agent moves on an open plane to a target provided in egocentric coordinates. B. Walls: The agent runs forward while avoiding solid walls using vision. C. Gaps: The agent runs forward and must jump between platforms to advance. D. Forage: Using vision, the agent roams in a procedurally-generated maze to collect balls, which provide sparse rewards. E. Heterogeneous Forage: The agent must probe and remember rewards that are randomly assigned to the balls in each episode.
+
+Query-based control fragment selection We considered an alternative family of ideas to interface with control fragments based on producing a Gaussian policy search query to be compared against a feature-key for each control fragment. We then selected the control fragment whose key was nearest the query-action. Our method was based on the Wolpertinger approach introduced in (Dulac-Arnold et al., 2015). Here, the Q-function was evaluated for each of $k$ nearest neighbors to the query-action, and the control fragment were selected with Boltzmann exploration, i.e. $p ( a _ { i } ^ { H L } | h ) \stackrel { \cdot } { \propto } \exp ( \frac { 1 } { T } Q ( h , a _ { i } ^ { H L } ) )$ , where $h$ is the output of the LSTM. See Appendix A.3.3 for more details. The intuition was that this would allow the high-level policy to be less precise as the Qfunction could assist it in selecting good actions. However, this approach under-performed relative to discrete action selection as we show in our results.
+
+# 3 EXPERIMENTS
+
+# 3.1 RESULTS ON CORE TASKS
+
+We compared the various approaches on a variety of tasks implemented in MuJoCo (Todorov et al., 2012). The core tasks we considered for the main comparisons were Go-to-target, wall navigation (Walls), running on gapped platforms (Gaps), foraging for colored ball rewards (Forage), and a foraging task requiring the agent to remember the reward value of the different colored balls (Heterogeneous Forage) (see Fig. 5). In Go-to-target, the agent received a sparse reward of 1 for each time step it was within a proximity radius of the target. For Walls and Gaps, adapted from Heess et al. (2017) to operate from vision, the agent received a reward proportional to its forward velocity. Forage was broadly similar to explore object locations in the DeepMind Lab task suite (Beattie et al., 2016) (with a humanoid body) while Heterogeneous Forage was a simplified version of explore object rewards. In all tasks, the body was initialized to a random pose from a subset of the reference motion capture data. For all tasks, other than Go-to-target, the high-level agent received a 64x64 image from the camera attached to the root of the body, in addition to the proprioceptive information.
+
+We compared the agents on our core set of tasks. Our overall best results were achieved using control fragments with discrete selection (Fig. 6). Additional training details are provided in Appendix A. For comparison, we also include the control experiment of training a policy to control the humanoid from scratch (without low-level controllers) as well as training a simple rolling ball body. The performance of the rolling ball is not directly comparable because its velocity differs from that of the humanoid, but isolates the task complexity from the challenge of motor control of the humanoid body. The switching controllers selected between a base set of four policies: stand, run, left and right turn. For the control fragments approach we were able to augment this set as described in Table 2.
+
+![](images/27596c13ee2a21747e57ac52841bea06152e3afb93b2d8927c8131c1e65feb8f.jpg)  
+Figure 6: Performance of various approaches on each core task. Of the approaches we compared, discrete switching among control fragments performed the best. Plots show the mean and standard error over multiple runs.
+
+The end-to-end approach (described in Appendix A.4) succeeded at only Go-to-target, however the resulting visual appearance was jarring. In the more complex Forage task, the end-to-end approach failed entirely. The steering controller was also able to perform the Go-to-target task, but a fixed turning radius meant that it was unable to make a direct approach the target, resulting in a long travel time to the target and lower score. Both the steering controller and switching controller were able to reach the end of the course in the Walls task, but only the control fragments approach allowed for sharper turns and quicker adjustments for agent to achieve a higher velocity. Generally, the switching controller with transitions started to learn faster and appeared the most graceful because of its predefined, smooth transitions, but its comparative lack of flexibility meant that its asymptotic task performance was relatively low. In the Forage task, where a score of $> 1 5 0$ means the agent is able to move around the maze and 600 is maximum collection of reward, the switching controller with transitions was able to traverse the maze but unable to adjust to the layout of the maze to make sharper turns to collect all objects. The control fragments approach was able to construct rotations and abrupt turns to collect the objects in each room. In the Gaps task, we were able to use the control fragments approach with 12 single-clip policies, where it would be laborious to pretrain transitions for each of these. In this task, the high-level controller selected between the 4 original stand, run and turn policies as well as 8 additional jumps, resulting in 359 fragments, and was able to synthesize them to move forward along the separated platforms. In the final Heterogeneous Forage task, we confirmed that the agent, equipped with an LSTM in the high-level controller, was capable of memory-dependent control behavior. See our Extended Video2 for a comprehensive presentation of the controllers.
+
+All control fragment comparisons above used control fragments of 3 time steps (0.09s). To further understand the performance of the control fragment approach, we did a more exhaustive comparison of performance on Go-to-target of the effect of fragment length, number of fragments, as well as introduction of redundant clips (see appendix B). We saw benefits in early exploration due to using fragments for more than one time step but lower ultimate performance. Adding more fragments was helpful when those fragments were functionally similar to the standard set and the high-level controller was able to robustly handle those that involved extraneous movements unrelated to locomotion.
+
+![](images/525b45d62d672078e6bc0bb8bb839469e1430379fb7e893d788934d5f5268269.jpg)  
+Figure 7: Example agent-view frames and corresponding visuomotor salience visualizations. Note that the ball is more sharply emphasized, suggesting the selected actions were influenced by the affordance of tacking toward the ball.
+
+# 3.2 ANALYSIS OF TRAINED HIGH-LEVEL POLICIES
+
+While the query-based approaches did not outperform the discrete control fragment selection (Fig. 6), we include a representative visualization in Appendix A.3 to help clarify why this approach may not have worked well. In the present setting, it appears that the proposal distribution over queries generated by the high-level policy was high variance and did not learn to index the fragments precisely.
+
+On Forage, the high-level controller with discrete selection of control fragments generated structured transitions between fragments (Appendix C). Largely, movements remained within clip or behavior type. The high-level controller ignored some fragments involving transitions from standing to running and left-right turns to use fast-walk-and-turn movements.
+
+To assess the visual features that drove movements, we computed saliency maps (Simonyan et al., 2013) showing the intensity of the gradient of the selected action’s log-probability with respect to each pixel: $\begin{array} { r } { { \check { S _ { t ; x , y } } } = \frac { 1 } { Z } \operatorname* { m i n } ( g , \frac { 1 } { 3 } \check { \sum _ { c } } | \nabla _ { I _ { x , y , c } } \log \pi ( a _ { t } ^ { H L } | h _ { t } ) | ) } \end{array}$ with normalization $Z$ and clipping $g$ (Fig. 7). Consistently, action selection was sensitive to the borders of the balls as well as to the walls. The visual features that this analysis identifies correspond roughly to sensorimotor affordances (Gibson, 2014); the agent’s perceptual representations were shaped by goals and action.
+
+# 4 DISCUSSION
+
+In this work we explored the problem of learning to reuse motor skills to solve whole body humanoid tasks from egocentric camera observations. We compared a range of approaches for reusing lowlevel motor skills that were obtained from motion capture data, including variations related to those presented in Liu & Hodgins (2017); Peng et al. (2018). To date, there is limited learning-based work on humanoids in simulation reusing motor skills to solve new tasks, and much of what does exist is in the animation literature. A technical contribution of the present work was to move past hand-designed observation features (as used in Heess et al. (2017); Peng et al. (2018)) towards a more ecological observation setting: using a front-facing camera is more similar to the kinds of observations a real-world, embodied agent would have. We also show that hierarchical motor skill reuse allowed us to solve tasks that we could not with a flat policy. For the walls and go-to-target tasks, learning from scratch was slower and produced less robust behavior. For the forage tasks, learning from scratch failed completely. Finally, the heterogeneous forage is an example of task that integrates memory and perception.
+
+There are some other very clear continuities between what we present here and previous work. For learning low-level tracking policies from motion capture data, we employed a manually specified similarity measure against motion capture reference trajectories, consistent with previous work (Liu et al., 2010; 2015; Peng et al., 2018). Additionally, the low-level policies were time-indexed: they operated over only a certain temporal duration and received time or phase as input. Considerably less research has focused on learning imitation policies either without a pre-specified scoring function or without time-indexing (but see e.g. Merel et al. (2017)). Compared to previous work using control fragments (Liu & Hodgins, 2017), our low-level controllers were built without a sampling-based planner and were parameterized as neural networks rather than linear-feedback policies.
+
+We also want to make clear that the graph-transition and steerable structured low-level control approaches require significant manual curation and design: motion capture clips must be segmented by hand, possibly manipulated by blending/smoothing clips from the end of one clip to the beginning of another. This labor intensive process requires considerable skill as an animator; in some sense this almost treats humanoid control as a computer-aided animation problem, whereas we aim to treat humanoid motor control as an automated and data-driven machine learning problem. We acknowledge that relative to previous work aimed at graphics and animation, our controllers are less graceful. Each approach involving motion capture data can suffer from distinct artifacts, especially without detailed manual editing – the hand-designed controllers have artifacts at transitions due to imprecise kinematic blending but are smooth within a behavior, whereas the control fragments have a lesser but consistent level of jitter throughout due to frequent switching. Methods to automatically (i.e. without human labor) reduce movement artifacts when dealing with large movement repertoires would be interesting to pursue.
+
+Moreover, we wish to emphasize that due to the human-intensive components of training structured low-level controllers, fully objective algorithm comparison with previous work can be somewhat difficult. This will remain an issue so long as human editing is a significant component of the dominant solutions. Here, we focused on building movement behaviors with minimal curation, at scale, that can be recruited to solve tasks. Specifically, we presented two methods that do not require curation and can re-use low-level skills with cold-switching. Additionally, these methods can scale to a large number of different behaviors without further intervention.
+
+We view this work as an important step toward the flexible use of motor skills in an integrated visuomotor agent that is able to cope with tasks that pose simultaneous perceptual, memory, and motor challenges to the agent. Future work will necessarily involve refining the naturalness of the motor skills to enable more general environment interactions and to subserve more complicated, compositional tasks.
+
+# ACKNOWLEDGMENTS
+
+We thank Yuval Tassa for helpful comments. The data used in this project was obtained from mocap.cs.cmu.edu. The database was created with funding from NSF EIA-019621.
+
+# REFERENCES
+
+Charles Beattie, Joel Z Leibo, Denis Teplyashin, Tom Ward, Marcus Wainwright, Heinrich Kuttler, ¨ Andrew Lefrancq, Simon Green, V´ıctor Valdes, Amir Sadik, et al. Deepmind lab. ´ arXiv preprint arXiv:1612.03801, 2016.   
+E Bizzi, VCK Cheung, A d’Avella, P Saltiel, and Me Tresch. Combining modules for movement. Brain research reviews, 57(1):125–133, 2008.   
+Kai Ding, Libin Liu, Michiel Van de Panne, and KangKang Yin. Learning reduced-order feedback policies for motion skills. In Proceedings of the 14th ACM SIGGRAPH/Eurographics Symposium on Computer Animation, pp. 83–92. ACM, 2015.   
+Gabriel Dulac-Arnold, Richard Evans, Hado van Hasselt, Peter Sunehag, Timothy Lillicrap, Jonathan Hunt, Timothy Mann, Theophane Weber, Thomas Degris, and Ben Coppin. Deep reinforcement learning in large discrete action spaces. arXiv preprint arXiv:1512.07679, 2015.   
+Lasse Espeholt, Hubert Soyer, Remi Munos, Karen Simonyan, Vlad Mnih, Tom Ward, Yotam Doron, Vlad Firoiu, Tim Harley, Iain Dunning, Shane Legg, and Koray Kavukcuoglu. IMPALA:
+
+Scalable distributed deep-RL with importance weighted actor-learner architectures. In Proceedings of the 35th International Conference on Machine Learning, volume 80, pp. 1407–1416, 2018.
+
+Petros Faloutsos, Michiel Van de Panne, and Demetri Terzopoulos. Composable controllers for physics-based character animation. In Proceedings of the 28th annual conference on Computer graphics and interactive techniques, pp. 251–260. ACM, 2001a.
+
+Petros Faloutsos, Michiel van de Panne, and Demetri Terzopoulos. The virtual stuntman: dynamic characters with a repertoire of autonomous motor skills. Computers & Graphics, 25(6):933–953, 2001b.
+
+Tamar Flash and Binyamin Hochner. Motor primitives in vertebrates and invertebrates. Current opinion in neurobiology, 15(6):660–666, 2005.
+
+James J Gibson. The ecological approach to visual perception: classic edition. Psychology Press, 2014.
+
+Sten Grillner, Jeanette Hellgren, Ariane Menard, Kazuya Saitoh, and Martin A Wikstrom. Mech- ¨ anisms for selection of basic motor programs–roles for the striatum and pallidum. Trends in neurosciences, 28(7):364–370, 2005.
+
+Karol Hausman, Jost Tobias Springenberg, Ziyu Wang, Nicolas Heess, and Martin Riedmiller. Learning an embedding space for transferable robot skills. International Conference on Learning Representations, 2018. URL https://openreview.net/forum?id $\underline { { \underline { { \mathbf { \Pi } } } } } =$ rk07ZXZRb. accepted as poster.
+
+Nicolas Heess, Gregory Wayne, David Silver, Tim Lillicrap, Tom Erez, and Yuval Tassa. Learning continuous control policies by stochastic value gradients. In Advances in Neural Information Processing Systems, pp. 2944–2952, 2015.
+
+Nicolas Heess, Greg Wayne, Yuval Tassa, Timothy Lillicrap, Martin Riedmiller, and David Silver. Learning and transfer of modulated locomotor controllers. arXiv preprint arXiv:1610.05182, 2016.
+
+Nicolas Heess, TB Dhruva, Srinivasan Sriram, Jay Lemmon, Josh Merel, Greg Wayne, Yuval Tassa, Tom Erez, Ziyu Wang, SM Ali Eslami, et al. Emergence of locomotion behaviours in rich environments. arXiv preprint arXiv:1707.02286, 2017.
+
+Daniel Holden, Taku Komura, and Jun Saito. Phase-functioned neural networks for character control. ACM Transactions on Graphics (TOG), 36(4):42, 2017.
+
+Auke J Ijspeert, Jun Nakanishi, and Stefan Schaal. Learning attractor landscapes for learning motor primitives. In Advances in neural information processing systems, pp. 1547–1554, 2003.
+
+Auke Jan Ijspeert, Jun Nakanishi, and Stefan Schaal. Movement imitation with nonlinear dynamical systems in humanoid robots. In Robotics and Automation, 2002. Proceedings. ICRA’02. IEEE International Conference on, volume 2, pp. 1398–1403. IEEE, 2002.
+
+Max Jaderberg, Wojciech M Czarnecki, Iain Dunning, Luke Marris, Guy Lever, Antonio Garcia Castaneda, Charles Beattie, Neil C Rabinowitz, Ari S Morcos, Avraham Ruderman, et al. Humanlevel performance in first-person multiplayer games with population-based deep reinforcement learning. arXiv preprint arXiv:1807.01281, 2018.
+
+Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. CoRR, abs/1412.6980, 2014. URL http://arxiv.org/abs/1412.6980.
+
+Jens Kober and Jan Peters. Learning prioritized control of motor primitives. In Learning Motor Skills, pp. 149–160. Springer, 2014.
+
+Jens Kober and Jan R Peters. Policy search for motor primitives in robotics. In Advances in neural information processing systems, pp. 849–856, 2009.
+
+Jens Kober, Betty Mohler, and Jan Peters. Learning perceptual coupling for motor primitives. In Intelligent Robots and Systems, 2008. IROS 2008. IEEE/RSJ International Conference on, pp. 834–839. IEEE, 2008.
+
+George Konidaris, Scott Kuindersma, Roderic Grupen, and Andrew Barto. Robot learning from demonstration by constructing skill trees. The International Journal of Robotics Research, 31(3): 360–375, 2012.
+
+Timothy P Lillicrap, Jonathan J Hunt, Alexander Pritzel, Nicolas Heess, Tom Erez, Yuval Tassa, David Silver, and Daan Wierstra. Continuous control with deep reinforcement learning. arXiv preprint arXiv:1509.02971, 2015.
+
+Libin Liu and Jessica Hodgins. Learning to schedule control fragments for physics-based characters using deep q-learning. ACM Transactions on Graphics (TOG), 36(3):29, 2017.
+
+Libin Liu and Jessica Hodgins. Learning basketball dribbling skills using trajectory optimization and deep reinforcement learning. ACM Transactions on Graphics (TOG), 37(4):142, 2018.
+
+Libin Liu, KangKang Yin, Michiel van de Panne, Tianjia Shao, and Weiwei Xu. Sampling-based contact-rich motion control. In ACM Transactions on Graphics (TOG), volume 29, pp. 128. ACM, 2010.
+
+Libin Liu, KangKang Yin, Michiel van de Panne, and Baining Guo. Terrain runner: control, parameterization, composition, and planning for highly dynamic motions. ACM Transactions on Graphics (TOG), 31(6):154, 2012.
+
+Libin Liu, KangKang Yin, and Baining Guo. Improving sampling-based motion control. In Computer Graphics Forum, volume 34, pp. 415–423. Wiley Online Library, 2015.
+
+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.
+
+Remi Munos, Tom Stepleton, Anna Harutyunyan, and Marc Bellemare. Safe and efficient off-policy ´ reinforcement learning. In Advances in Neural Information Processing Systems, pp. 1054–1062, 2016.
+
+Gerhard Neumann, Christian Daniel, Alexandros Paraschos, Andras Kupcsik, and Jan Peters. Learning modular policies for robotics. Frontiers in computational neuroscience, 8:62, 2014.
+
+OpenAI. Openai five. journal=https://blog.openai.com/openai-five/, 2018.
+
+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.
+
+Xue Bin Peng, Pieter Abbeel, Sergey Levine, and Michiel van de Panne. Deepmimic: Example-guided deep reinforcement learning of physics-based character skills. arXiv preprint arXiv:1804.02717, 2018.
+
+John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy optimization algorithms. arXiv preprint arXiv:1707.06347, 2017.
+
+Luis Sentis and Oussama Khatib. Synthesis of whole-body behaviors through hierarchical control of behavioral primitives. International Journal of Humanoid Robotics, 2(04):505–518, 2005.
+
+Karen Simonyan, Andrea Vedaldi, and Andrew Zisserman. Deep inside convolutional networks: Visualising image classification models and saliency maps. arXiv preprint arXiv:1312.6034, 2013.
+
+Richard S Sutton, Doina Precup, and Satinder Singh. Between mdps and semi-mdps: A framework for temporal abstraction in reinforcement learning. Artificial intelligence, 112(1-2):181– 211, 1999.
+
+Yuval Tassa, Yotam Doron, Alistair Muldal, Tom Erez, Yazhe Li, Diego de Las Casas, David Budden, Abbas Abdolmaleki, Josh Merel, Andrew Lefrancq, et al. Deepmind control suite. arXiv preprint arXiv:1801.00690, 2018.
+
+Emanuel Todorov, Tom Erez, and Yuval Tassa. Mujoco: A physics engine for model-based control. In Intelligent Robots and Systems (IROS), 2012 IEEE/RSJ International Conference on, pp. 5026– 5033. IEEE, 2012.
+
+Greg Wayne, Chia-Chun Hung, David Amos, Mehdi Mirza, Arun Ahuja, Agnieszka GrabskaBarwinska, Jack Rae, Piotr Mirowski, Joel Z Leibo, Adam Santoro, et al. Unsupervised predictive memory in a goal-directed agent. arXiv preprint arXiv:1803.10760, 2018.
+
+# APPENDICES
+
+# A ADDITIONAL TRAINING DETAILS
+
+Following Espeholt et al. (2018), all training was done using a distributed actor-learner architecture. Many asynchronous actors interact with the environment to produce trajectories of $\left( { { s _ { t } } , { a _ { t } } , { r _ { t } } , { s _ { t + 1 } } } \right)$ tuples of a fixed rollout length, $N$ . In contrast to Espeholt et al. (2018), each trajectory was stored in a replay buffer. The learner sampled trajectories of length $N$ at random and performed updates. Each actor retrieved parameters from the learner at a fixed time interval. The learner ran on a single Pascal 100 or Volta 100 GPU. The plots presented use the steps processed by the learner on the $\mathbf { X }$ -axis. This is the number of transition retrieved from the replay buffer, which is equivalent to the number of gradient updates $\mathbf { X }$ batch size x rollout length.
+
+We performed all optimization with Adam (Kingma & Ba, 2014) and used hyperparameter sweeps to select learning rates and batch sizes.
+
+Table 1: Parameters for training the agent on different environments/tasks.   
+
+<table><tr><td>Task</td><td colspan="6"></td></tr><tr><td></td><td>unroll</td><td>LSTM state size</td><td> value MLP</td><td>gamma</td><td>replay size</td><td></td></tr><tr><td>Go To Target</td><td>10</td><td>128</td><td>(128,1)</td><td>0.99</td><td>106</td><td></td></tr><tr><td>Walls / Gaps</td><td>20</td><td>128</td><td>(128,1)</td><td>0.99</td><td>104</td><td></td></tr><tr><td>Forage</td><td>50</td><td>256</td><td>(200,200,1)</td><td>0.995</td><td>104</td><td></td></tr><tr><td>Heterogeneous Forage</td><td>200</td><td>256</td><td>(200,200,1)</td><td>0.99</td><td>105</td><td></td></tr></table>
+
+A.1 SELECTED LOW-LEVEL POLICIES TRAINED FROM MOTION CAPTURE
+
+For the switching controller and control fragments approach we used a standard set of four policies trained from motion capture which imitated stand, run, left and right turn behaviors. In the switching controller, pretrained transitions were created in the reference data. For the control fragments approach, we were able to augment the set without any additional work and the selected policies are described in Table 2.
+
+Table 2: Selected motion-capture clips for control fragments controller.   
+
+<table><tr><td>Task</td><td>Selected policies</td><td>Num.control fragments</td></tr><tr><td></td><td></td><td></td></tr><tr><td>Go To Target</td><td>stand,run,left turn, right turn</td><td>105</td></tr><tr><td>Walls Forage</td><td>stand,run,left turn,right turn stand, run,left turn, right turn,</td><td>105 183</td></tr><tr><td></td><td>2 walk and turns</td><td></td></tr><tr><td>Heterogeneous Forage</td><td>stand,run,left turn,right turn, 2 turns and 2 about-face</td><td>359</td></tr><tr><td>Gaps</td><td>stand, run,left turn, right turn, 8 jumps</td><td>359</td></tr></table>
+
+# A.2 HETEROGENEOUS FORAGE TASK
+
+In the heterogeneous forage task, the humanoid is spawned in a room with 6 balls, 3 colored red and 3 colored green. Each episode, one color is selected at random and assigned a positive value $( + 3 0 )$ or a negative value (-10) and the agent must sample a ball and then only collect the positive ones.
+
+# A.3 HIGH-LEVEL CONTROLLER TRAINING DETAILS
+
+The architecture of the high-level controller consisted of proprioceptive encoder and an optional image encoder which, along with prior reward and action, were passed to an LSTM. This encoding core was shared with both the actor and critic. The details of the encoder are depicted in Fig. A.1.
+
+![](images/42f07898632084501e84aeba11404b8492ee92bd9cc485cfca2da2af62e2b933.jpg)  
+Figure A.1: Complete diagram of high-level agent architecture with encoders.
+
+# A.3.1 STEERING CONTROLLER TRAINING DETAILS
+
+The steering controller policy head took as input the outputs of the LSTM in Fig. A.1. The policy head was an LSTM, with a state size of 128, followed by a linear layer. The linear layer produced the parameters for a 1-D Gaussian. The $\mu$ parameters were constrained by a tanh and the $\sigma$ parameters were clipped between [0.1, 1].
+
+The policy was trained with a SVG(0) update (Heess et al., 2015). A state-action value / Q function was implemented as an MLP with dimensions in Table 1 and trained with a Retrace target. Target networks were used for Q and updated every 100 training iterations.
+
+The policy was also updated by an additional entropy cost at each time step, which was added to the policy update with a weight of $1 e ^ { - 5 }$ .
+
+# A.3.2 SWITCHING CONTROLLER TRAINING DETAILS
+
+The switching controller policy head took as input the outputs of the LSTM in Fig. A.1. The policy head was an LSTM, with a state size of 128, followed by a linear layer to produce the logits of the multinomial distribution.
+
+The policy was updated with a policy gradient using $N$ -step empirical returns with bootstrapping to compute an advantage, where $N$ was equivalent to the rollout length in Table 1. The value-function (trained via V-Trace) was used as a baseline.
+
+The policy was also updated by an additional entropy cost at each time step, which was added to the policy update with a weight of .01.
+
+# A.3.3 DETAILS OF QUERY-BASED ACTION SELECTION APPROACH
+
+We train a policy to produce a continuous feature vector (i.e. the query-action), so the selector is parameterized by a diagonal multivariate Gaussian action model. The semantics of the query-action
+
+will correspond to the features in the control fragment feature-key vectors, which were partial state observations (velocity, orientation, and end-effector relative positions) of the control fragment’s nominal start or end pose.
+
+![](images/cd6c61e928dee70f58a1eb5aa865ca84638ea0db9f7f842e70489fae05b108b5.jpg)  
+Figure A.2: Illustration of query-based control fragment selection in which a query feature vector is produced, compared with key feature vectors for all control fragments, and the Q-value of selecting each control fragment in the current state is used to determine which control fragment is executed.
+
+In this approach, the Q function was trained with 1 step returns. So, for samples $\left( { { s _ { t } } , { a _ { t } } , { r _ { t } } , { s _ { t + 1 } } } \right)$ from replay:
+
+$$
+\begin{array} { l } { q _ { t a r g e t } = \displaystyle r _ { t } + \gamma \mathbb { E } _ { a \sim \pi ( \cdot | h _ { t + 1 } ) } [ Q ( h _ { t + 1 } , a ) ] } \\ { \ell _ { c r i t i c } = \displaystyle \frac { 1 } { 2 } | | Q ( h _ { t } , a _ { t } ) - q _ { t a r g e t } | | _ { 2 } ^ { 2 } } \end{array}
+$$
+
+The total loss is summed across minibatches sampled from replay. Note that for the query-based approach we have query actions which are in the same space as but generally distinct from the reference keys of the control fragments which are selected after the sampling procedure.
+
+The high-level policy emits query actions, which are rectified to reference keys by a nearest lookup (i.e. the selected actions). This leads to two, slightly different high-level actions in the same space. This leads to the question of what is the appropriate action on which to perform both policy updates and value function updates.
+
+To handle this, it proved most stable to compute targets and loss terms for both the query-actions and selected actions for each state from replay. In this way, a single Q function represented the value of query-actions and selected actions. This was technically an approximation as the training of the Q-function pools these two kinds of action input. Finally, the policy update used the SVG(0)-style update (Heess et al., 2015):
+
+$$
+\ell _ { a c t o r } = - \mathbb { E } _ { \xi \sim \mathcal { N } ( 0 , 1 ) } Q ( h _ { t } , a ( h _ { t } , \xi ) )
+$$
+
+![](images/456f1796b93b9f6866c69ba2dd351ab7b81930826d3bf9c2a7775b48bf9b00e1.jpg)  
+Figure A.3: Visualization (using PCA) of the actions produced by the trained query-based policy (on go-to-target). Query actions are the continuous actions generated by the policy. Reference keys are the feature vectors associated with the control fragments (here, features of the final state of the nominal trajectory of the fragment). Selected actions are the actions produced by the sampling mechanism and they are overlain to emphasize the control reference keys actually selected. The most prominent feature of this visualization is the lack of precision in the query actions. Note that 45/105 control fragments were selected by the trained policy.
+
+We hypothesize that the limited success of this approach is perhaps partly due to the impreciseness in their selectivity (see Fig A.3). After finding these approaches were not working very well, an additional analysis of a trained discrete-selection agent, not shown here, found that the second most preferred control fragment (in a given state) was not usually the control fragment with the most similar reference key. This implies that the premise of the query-based approach, namely that similar fragments should be preferentially confused/explored may not be as well-justified in this case as we speculated, when we initially conceived of trying it. That analysis notwithstanding, we remain optimistic this approach may end up being more useful than we found it to be here.
+
+# A.4 END-TO-END CONTROLLER TRAINING DETAILS
+
+End-to-end training on each task was performed in a similar fashion to training the low-level controllers. Using the same architecture as in A.1, the policy was trained to output the 56-dimensional action for the position-controlled humanoid. As in the low-level training, the policy was trained with a SVG(0) update (Heess et al., 2015) and Q was trained with a Retrace target. The episode was terminated when the humanoid was in an irrecoverable state and when the head fell below a fixed height.
+
+# B SCALING AND FRAGMENT LENGTH
+
+We compared performance as a function of the number of fragments as a well as the length of fragments. If using a fixed number of behaviors and cutting them into control fragments of various lengths, two features are coupled: the length of the fragments vs. how many fragments there are. One can imagine a trade-off – more fragments might make exploration harder, but shorter temporal commitment to a fragment may ultimately lead to more precise control. To partially decouple the number of fragments from their length, we also compared performance with functionally redundant but larger sets of control fragments.
+
+![](images/6b289bd44fedf7a27aa9a2f095746ea297dc362f63ca3f305019122c845ad17a.jpg)  
+Figure A.4: A. Training was most stable with shorter fragment length (1 / .03 sec or 3 / .09 sec. B. Increasing the number of fragments, by duplicating the original set, did not hurt training performance. C. Additional functionally redundant policies (i.e. 4 vs 8 behaviors, cut into many control fragments) improved training speed, while additional extraneous policies were easily ignored.
+
+Ultimately, it appears that from a strict task-performance perspective, shorter control fragments tend to perform best as they allow greatest responsiveness. That being said, the visual appearance of the behavior tends to be smoother for longer control fragments. Control fragments of length 3 (.09 sec) seemed to trade-off behavioral coherence against performance favorably. Hypothetically, longer control fragments might also shape the action-space and exploration distribution favorably. We see a suggestion of this with longer-fragment curves ascending earlier.
+
+![](images/a09f591112df1799327368396e89430b347dc52e552aded2dedf0cdb7036349f.jpg)  
+Figure A.5: Transition density between control fragments for a trained agent on Forage. The background colors reflect density of transitions within a clip/behavior class (darker is denser), and single fragment transition densities are overlain as circles where size indicates the density of that particular transition.
+
+![](images/5ad7e4fe5a33b6cfba79dcdb2a7f0b6c8e1c1dedd1459d43c5898d4b665d2803.jpg)  
+Figure A.6: We depict a timeseries of the behavior of a trained high-level policy on Forage. In this particular trained agent, it frequently transitions to a particular stand fragment which it has learned to rely on. Green vertical lines depict reward acquisition.

parse/train/BJfYvo09Y7/BJfYvo09Y7_content_list.json

@@ -0,0 +1,1814 @@
+[
+    {
+        "type": "text",
+        "text": "HIERARCHICAL VISUOMOTOR CONTROLOF HUMANOIDS",
+        "text_level": 1,
+        "bbox": [
+            173,
+            99,
+            655,
+            145
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Josh Merel∗, Arun Ahuja∗,   \nVu Pham, Saran Tunyasuvunakool, Siqi Liu, Dhruva Tirumala,   \nNicolas Heess & Greg Wayne   \nDeepMind   \nLondon, UK   \n{jsmerel,arahuja,vuph,stunya,liusiqi,dhruvat, heess,gregwayne}@google.com ",
+        "bbox": [
+            184,
+            170,
+            625,
+            268
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            304,
+            544,
+            319
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We aim to build complex humanoid agents that integrate perception, motor control, and memory. In this work, we partly factor this problem into low-level motor control from proprioception and high-level coordination of the low-level skills informed by vision. We develop an architecture capable of surprisingly flexible, task-directed motor control of a relatively high-DoF humanoid body by combining pre-training of low-level motor controllers with a high-level, task-focused controller that switches among low-level sub-policies. The resulting system is able to control a physically-simulated humanoid body to solve tasks that require coupling visual perception from an unstabilized egocentric RGB camera during locomotion in the environment. Supplementary video link1 ",
+        "bbox": [
+            233,
+            335,
+            764,
+            474
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            501,
+            336,
+            517
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In reinforcement learning (RL), a major challenge is to simultaneously cope with high-dimensional input and high-dimensional action spaces. As techniques have matured, it is now possible to train high-dimensional vision-based policies from scratch to generate a range of interesting behaviors ranging from game-playing to navigation (Jaderberg et al., 2018; OpenAI, 2018; Wayne et al., 2018). Likewise, for controlling bodies with a large number of degrees of freedom (DoFs), in simulation, reinforcement learning methods are beginning to surpass optimal control techniques. Here, we try to synthesize this progress and tackle high-dimensional input and output at the same time. We evaluate the feasibility of full-body visuomotor control by comparing several strategies for humanoid control from vision. ",
+        "bbox": [
+            174,
+            532,
+            825,
+            657
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Both to simplify the engineering of a visuomotor system and to reduce the complexity of taskdirected exploration, we construct modular agents in which a high-level system possessing egocentric vision and memory is coupled to a low-level, reactive motor control system. We build on recent advances in imitation learning to make flexible low-level motor controllers for high-DoF humanoids. The motor skills embodied by the low-level controllers are coordinated and sequenced by the high-level system, which is trained to maximize sparse task reward. ",
+        "bbox": [
+            174,
+            665,
+            823,
+            747
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Our approach is inspired by themes from neuroscience as well as ideas developed and made concrete algorithmically in the animation and robotics literatures. In motor neuroscience, studies of spinal reflexes in animals ranging from frogs to cats have led to the view that locomotion and reaching are highly prestructured, enabling subcortical structures such as the basal ganglia to coordinate a motor repertoire; and cortical systems with access to visual input can send low complexity signals to motor systems in order to evoke elaborate movements (Flash & Hochner, 2005; Bizzi et al., 2008; Grillner et al., 2005). ",
+        "bbox": [
+            174,
+            755,
+            825,
+            852
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The study of “movement primitives” for robotics descends from the work of Ijspeert et al. (2002). Subsequent research has focused on innovations for learning or constructing primitives for control of movments (Ijspeert et al., 2003; Kober & Peters, 2009), deploying and sequencing them to solve tasks (Sentis & Khatib, 2005; Kober & Peters, 2014; Konidaris et al., 2012), and increasing the complexity of the control inputs to the primitives (Neumann et al., 2014). Particularly relevant to our cause is the work of Kober et al. (2008) in which primitives were coupled by reinforcement learning to external perceptual inputs. ",
+        "bbox": [
+            176,
+            859,
+            823,
+            887
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            174
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Research in the animation literature has also sought to produce physically simulated characters capable of distinct movements that can be flexibly sequenced. This ambition can be traced to the virtual stuntman (Faloutsos et al., 2001b;a) and has been advanced markedly in the work of Liu (Liu et al., 2012). Further recent work has relied on reinforcement learning to schedule control policies known as “control fragments”, each one able to carry out only a specialized short movement segment (Liu & Hodgins, 2017; 2018). In work to date, such control fragments have yet to be coupled to visual input as we will pursue here. From the perspective of the RL literature (Sutton et al., 1999), motor primitives and control fragments may be considered specialized instantiations of “option” sub-policies. ",
+        "bbox": [
+            174,
+            180,
+            825,
+            305
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our work aims to contribute to this multi-disciplinary literature by demonstrating concretely how control-fragment-like low-level movements can be coupled to and controlled by a vision and memory-based high-level controller to solve tasks. Furthermore, we demonstrate the scalability of the approach to greater number of control fragments than previous works. Taken together, we demonstrate progress towards the goal of integrated agents with vision, memory, and motor control. ",
+        "bbox": [
+            174,
+            313,
+            823,
+            382
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 APPROACH",
+        "text_level": 1,
+        "bbox": [
+            174,
+            402,
+            297,
+            417
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We present a system capable of solving tasks from vision by switching among low-level motor controllers for the humanoid body. This scheme involves a general separation of control where a low-level controller handles motor coordination and a high-level controller signals/selects lowlevel behavior based on task context (see also Heess et al. 2016; Peng et al. 2017). In the present work, the low-level motor controllers operate using proprioceptive observations, and the high-level controller operate using proprioception along with first-person/egocentric vision. We first describe the procedure for creating low-level controllers from motion capture data, then describe and contrast multiple approaches for interfacing the high- and low-level controllers. ",
+        "bbox": [
+            174,
+            434,
+            823,
+            545
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 TRACKING MOTION CAPTURE CLIPS ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            561,
+            462,
+            575
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "For simulated character control, there has been a line of research extracting humanoid behavior from motion capture (“mocap”) data. The SAMCON algorithm is a forward sampling approach that converts a possibly noisy, kinematic pose sequence into a physical trajectory. It relies on a beamsearch-like planning algorithm (Liu et al., 2010; 2015) that infers an action sequence corresponding to the pose sequence. In subsequent work, these behaviors have been adapted into policies (Liu et al., 2012; Ding et al., 2015). More recently, RL has also been used to produce time-indexed policies which serve as robust tracking controllers (Peng et al., 2018). While the resulting time-indexed policies are somewhat less general as a result, time-indexing or phase-variables are common in the animation literature and also employed in kinematic control of characters (Holden et al., 2017). We likewise use mocap trajectories as reference data, from which we derive policies that are single purpose – that is, each policy robustly tracks a short motion capture reference motion (2-6 sec), but that is all each policy is capable of. ",
+        "bbox": [
+            174,
+            587,
+            825,
+            753
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Humanoid body We use a 56 degree-of-freedom (DoF) humanoid body that was developed in previous work (Merel et al., 2017), a version of which is available with motion-capture playback in the DeepMind control suite (Tassa et al., 2018). Here, we actuate the joints with position-control: each joint is given an actuation range in $[ - 1 , 1 ]$ , and this is mapped to the angular range of that joint. ",
+        "bbox": [
+            174,
+            768,
+            823,
+            825
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Single-clip tracking policies For each clip, we train a policy $\\pi _ { \\boldsymbol { \\theta } } ( \\boldsymbol { a } | \\boldsymbol { s } , t )$ with parameters $\\theta$ such that it maximizes a discounted sum of rewards, $r _ { t }$ , where the reward at each step comes from a custom scoring function (see eqns. 1, 2 defined immediately below). This tracking approach most closely follows Peng et al. (2018). Note that here the state optionally includes a normalized time $t$ that goes from 0 at the beginning of the clip to 1 at the end of the clip. For cyclical behaviors like locomotion, a gait cycle can be isolated manually and kinematically blended circularly by weighted linear interpolation of the poses to produce a repeating walk. The time input is reset each gaitcycle (i.e. it follows a sawtooth function). As proposed in Merel et al. (2017); Peng et al. (2018), episodes are initialized along the motion capture trajectory; and episodes can be terminated when it is determined that the behavior has failed significantly or irrecoverably. Our specific termination condition triggers if parts of the body other than hands or feet make contact with the ground. See Fig. 1 for a schematic. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/a52ff1c19d10a1768593fef3986a65bde7480d2334b7e76ecc0761318f823dab.jpg",
+        "image_caption": [
+            "Figure 1: Illustration of tracking-based RL training. Training iteratively refines a policy to robustly track the reference trajectory as well as physically feasible. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            99,
+            607,
+            291
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            314,
+            825,
+            398
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We first define an energy function most similar to SAMCON’s (Liu et al., 2010): ",
+        "bbox": [
+            174,
+            405,
+            700,
+            420
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/41ef81311d850fbb4627ece7f8d9d3cd05873221f66f1541265ffebde739ded3.jpg",
+        "text": "$$\n\\begin{array} { r } { E _ { t o t a l } = w _ { q p o s } E _ { q p o s } + w _ { q v e l } E _ { q v e l } + w _ { o r i } E _ { o r i } + } \\\\ { w _ { e e } E _ { e e } + w _ { v e l } E _ { v e l } + w _ { g y r o } E _ { g y r o } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            334,
+            424,
+            665,
+            462
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $E _ { q p o s }$ is a energy defined on all joint angles, $E _ { q v e l }$ on joint velocities, $E _ { o r i }$ on the body root (global-space) quaternion, $E _ { e e }$ on egocentric vectors between the root and the end-effectors (see Merel et al. (2017)), $E _ { v e l }$ on the (global-space) translational velocities, and $E _ { g y r o }$ on the body root rotational velocities. More specifically: ",
+        "bbox": [
+            174,
+            464,
+            826,
+            520
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/43e730f1768a1d14404681cfd79ccb2041d08064f226532b26ca8f2658fb947a.jpg",
+        "text": "$$\n\\begin{array} { l l } { { E _ { q p o s } = \\displaystyle \\frac { 1 } { N _ { q p o s } } \\sum | \\vec { q } _ { p o s } - \\vec { q } _ { p o s } ^ { * } | } } & { { \\qquad E _ { e e } = \\displaystyle \\frac { 1 } { N _ { e e } } \\sum | | \\vec { q } _ { e e } - \\vec { q } _ { e e } ^ { * } | | _ { 2 } } } \\\\ { { E _ { q v e l } = \\displaystyle \\frac { 1 } { N _ { q v e l } } \\sum | \\vec { q } _ { v e l } - \\vec { q } _ { v e l } ^ { * } | } } & { { \\qquad E _ { v e l } = 0 . 1 \\cdot \\frac { 1 } { N _ { v e l } } \\sum | \\vec { x } _ { v e l } - \\vec { x } _ { v e l } ^ { * } | } } \\\\ { { E _ { o r i } = | | \\log ( \\vec { q } _ { o r i } \\cdot \\vec { q } _ { o r i } ^ { * - 1 } ) | | _ { 2 } } } & { { \\qquad E _ { g y r o } = 0 . 1 \\cdot | | \\vec { q } _ { g y r o } - \\vec { q } _ { g y r o } ^ { * } | | _ { 2 } } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            236,
+            525,
+            763,
+            614
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\vec { q }$ represents the pose and $\\vec { q } ^ { \\star }$ represents the reference pose. In this work, we used coefficients $w _ { q p o s } = 5$ , $w _ { q v e l } = 1$ , $w _ { o r i } = 2 0$ , $w _ { g y r o } = 1$ , $w _ { v e l } = 1$ , $w _ { e e } = 2$ . We tuned these by sweeping over parameters in a custom implementation of SAMCON (not detailed here), and we have found these coefficients tend to work fairly well across a wide range of movements for this body. ",
+        "bbox": [
+            174,
+            617,
+            825,
+            674
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "From the energy, we write the reward function: ",
+        "bbox": [
+            176,
+            680,
+            482,
+            694
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6ad46834bf4d59aef19e8d2f06e6d3e6ace3683f55e925017ea713b1a4b9af4e.jpg",
+        "text": "$$\nr _ { t } = \\exp ( - \\beta E _ { t o t a l } / w _ { t o t a l } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            405,
+            699,
+            593,
+            717
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $w _ { t o t a l }$ is the sum of the per energy-term weights and $\\beta$ is a sharpness parameter ( $\\beta = 1 0$ throughout). Since all terms in the energy are non-negative, the reward is normalized $r _ { t } \\in ( 0 , 1 ]$ with perfect tracking giving a reward of 1 and large deviations tending toward 0. ",
+        "bbox": [
+            174,
+            722,
+            825,
+            765
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Acquiring reference data features for some quantities required setting the body to the pose specified by the joint angles: e.g., setting $\\vec { x } _ { p o s }$ , $\\vec { q } _ { p o s }$ , and $\\vec { q } _ { o r i }$ to compute the end-effector vectors $\\vec { q } _ { e e }$ . Joint angle velocities, root rotational velocities, and translational velocities $( \\vec { q } _ { v e l } , \\vec { q } _ { g y r o } , \\vec { x } _ { v e l } )$ were derived from the motion capture data by finite difference calculations on the corresponding positions. Note that the reward function here was not restricted to egocentric features – indeed, the velocity and quaternion were non-egocentric. Importantly, however, the policy received exclusively egocentric observations, so that, for example, rotating the initial pose of the humanoid would not affect the policy’s ability to execute the behavior. The full set of proprioceptive features we provided the policy consists of joint angles $( \\vec { q } _ { p o s } )$ and velocities $( \\vec { q } _ { v e l } )$ , root-to-end-effector vectors $( \\vec { q } _ { e e } )$ , rootframe velocimeter $( \\vec { q } _ { v e l o c } )$ , rotational velocity $( \\vec { q } _ { g y r o } )$ , root-frame accelerometers $( \\vec { q } _ { a c c e l } )$ , and 3D orientation relative to the $\\mathbf { Z }$ -axis $\\vec { r } _ { z }$ : functionally a gravity sensor). ",
+        "bbox": [
+            173,
+            770,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Low-level controller reinforcement learning details Because the body is position-controlled, ( $\\dot { \\boldsymbol { a } } _ { t }$ has the same dimension and semantics as a subset of the body pose), we can pre-train the policy to produce target poses by supervised learning m $\\begin{array} { r } { \\operatorname * { l a x } _ { \\theta } \\sum _ { t } \\log \\pi \\big ( \\dot { q } _ { p o s , t + 1 } ^ { \\ast } | s _ { t } ^ { \\ast } , t \\big ) } \\end{array}$ . This produces very poor control but facilitates the subsequent stage of RL-based imitation learning. We generally found that training with some pretraining considerably shortened the time the training took to converge and improved the resulting policies. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            188
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For RL, we performed off-policy training using a distributed actor-critic implementation, closest to that used in (Hausman et al., 2018). This implementation used a replay buffer and target networks as done in previous work (Lillicrap et al., 2015; Heess et al., 2015). The Q-function was learned off-policy using TD-learning using importance-weighted Retrace (Munos et al., 2016), and the actor was learned off-policy using SVG(0) (Heess et al., 2015). This is to say that we learned the policy by taking gradients with respect to the Q function (target networks were updated every 500 learning steps). Gradient updates to the policy were performed using short time windows, $\\{ s _ { \\tau } , a _ { \\tau } \\} _ { \\tau = 1 \\dots T }$ , sampled from replay: ",
+        "bbox": [
+            173,
+            194,
+            825,
+            306
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/31e476748a6335ac28c81e8d19ca4ba5906fd898a5497b7550f711b8c4cc87f1.jpg",
+        "text": "$$\n\\operatorname* { m a x } _ { \\pi _ { \\theta } } \\sum _ { \\tau = 1 \\dots T } \\mathbb { E } _ { a \\sim \\pi ( a \\mid s _ { \\tau } ) } [ Q _ { t a r g e t } ( s _ { \\tau } , a ) ] - \\eta \\mathcal { D } _ { K L } [ \\pi _ { \\theta } ( a \\mid s _ { \\tau } ) \\mid | \\pi _ { t a r g e t } ( a \\mid s _ { \\tau } ) ]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            254,
+            308,
+            741,
+            342
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\eta$ was fixed in our experiments. While the general details of the RL algorithm are not pertinent to the success of this approach (e.g. Peng et al. (2018) used on-policy RL), we found two details to be critical, and both were consistent with the results reported in Peng et al. (2018). Policy updates needed to be performed conservatively with the update including a term which restricts $\\mathcal { D } _ { K L } [ \\pi _ { n e w } | | \\pi _ { o l d } ]$ (Heess et al., 2015; Schulman et al., 2017). Secondly, we found that attempting to learn the variance of the policy actions tended to result in premature convergence, so best results were obtained using a stochastic policy with fixed noise (we used noise with $\\sigma = . 1$ ). ",
+        "bbox": [
+            174,
+            343,
+            825,
+            441
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.2 VARIETIES OF LOW-LEVEL MOTOR CONTROL ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            458,
+            524,
+            472
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We next consider how to design low-level motor controllers derived from motion capture trajectories. Broadly, existing approaches fall into two categories: structured and cold-switching controllers. In structured controllers, there is a hand-designed relationship between “skill-selection” variables and the generated behavior. Recent work by Peng et al. (2018) explored specific handdesigned, structured controllers. While parameterized skill-selection coupled with manual curation and preprocessing of motion capture data can produce artistically satisfying results, the range of behavior has been limited and implementation requires considerable expertise and animation skill. By contrast, an approach in which behaviors are combined by a more automatic procedure promises to ultimately scale to a wider range of behaviors. ",
+        "bbox": [
+            174,
+            483,
+            825,
+            609
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Below, we describe some specific choices for both structured and cold-switching controllers. For structured control schemes, we consider: (1) a steerable controller that produces running behavior with a controllable turning radius, and (2) a switching controller that is a single policy that can switch between the behaviors learned from multiple mocap clips, with switch points allowed at the end of gait cycles. The allowed transitions were defined by a transition graph. For cold switching, we will not explicitly train transitions between behaviors. ",
+        "bbox": [
+            174,
+            616,
+            825,
+            699
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Steerable controller Following up on the ability to track a single cyclical behavior like locomotion described above, we can introduce the ability to parametrically turn. To do this we distorted the reference trajectory accordingly and trained the policy to track the reference with the turning radius as additional input. Each gait cycle we picked a random turning radius parameter and in that gaitcyle we rotate the reference clip heading $( \\vec { q } _ { o r i } )$ at that constant rate (with appropriate bookkeeping for other positions and velocities). The result was a policy that, using only one gait cycle clip as input, could turn with a specified rate of turning. ",
+        "bbox": [
+            174,
+            713,
+            825,
+            811
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Switching controller An alternative to a single behavior with a single continuously controllable parameter is a single policy that is capable of switching among a discrete set of behaviors based on a 1-of- $k$ input. Training consisted of randomly starting in a pose sampled from a random mocap clip and transitioning among clips according to a graph of permitted transitions. Given a small, discrete set of clips that were manually “cut” to begin and end at similar points in a gait cycle, we initialized a discrete Markov process among clips with some initial distribution over clips and transitioned between clips that were compatible (walk forward to turn left, etc.) (Fig. 2). ",
+        "bbox": [
+            174,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/41f156a8599a7799b4decec73235f5cf28ac8e46bf148be9849e545f799100fd.jpg",
+        "image_caption": [
+            "Figure 2: Training settings for explicit training of transition-capable controllers. Panel A depicts a cartoon of a training episode for a steerable controller in which the turning radius of a each gait-cycle is selected randomly. Panel B depicts training a policy under an explicit, hand-designed transition graph for $k$ options. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            218,
+            98,
+            779,
+            291
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Cold-switching of behaviors and control fragments We can also leave the task of sequencing behaviors to the high-level controller, instead of building structured low-level policies with explicit, designed transitions. Here, we did not attempt to combine the clips into a single policy; instead, we cut behaviors into short micro-behaviors of roughly 0.1 to 0.3 seconds, which we refer to as control fragments (Liu & Hodgins, 2017). Compared to switching using the complete behaviors, the micro-behaviors, or control fragments, allow for better transitions and more flexible locomotion. Additionally, we can easily scale to many clips without manual intervention. For example, clip 1 would generate a list of fragments: $\\pi _ { 1 } ^ { 1 } \\dot { ( } a | s _ { t } \\dot { , } \\tau )$ $\\vert s _ { t } , \\tau ) , \\pi _ { 2 } ^ { 1 } ( a \\vert s _ { t } , \\tau ) , \\ldots , \\pi _ { 1 0 } ^ { 1 } ( a \\vert s _ { t } , \\tau )$ . When fragment 1 was chosen, $\\tau$ the time-indexing variable was set to $\\tau = 0$ initially and ticked until, say, $\\tau =$ 0.1. Choosing fragment 2, $\\pi _ { 2 } ^ { 1 }$ , would likewise send a signal to the clip 1 policy starting from $\\tau = 0 . 1$ , etc. Whereas we have to specify a small set of consistent behaviors for the other lowlevel controller models, we could easily construct hundreds (or possibly more) control fragments cheaply and without significant curatorial attention. Since the control fragments were not trained with switching behavior, we refer to the random access switching among fragments by the highlevel controller as “cold-switching” (Fig. 3). ",
+        "bbox": [
+            173,
+            400,
+            825,
+            611
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/a6d7a01dc50a75c518c7d4f24eabdbd3e67c1603d0153bd4c2ad7fe0d39b9be4.jpg",
+        "image_caption": [
+            "Figure 3: Cold-switching among a set of behaviors (A) only at end of clips to form a trajectory composed of sequentially activation of the policies (B). Alternatively, policies are fragmented at a pre-specified set of times, cutting the policy into sub-policies (C), which serve as control fragments, enabling sequencing at a higher frequency (D). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            633,
+            826,
+            832
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/fe90f6cb65acf49f3aba690c9ea9e320407050a50e70ddac20984bb96d8d70a3.jpg",
+        "image_caption": [
+            "Figure 4: Schematic of the architecture: a high-level controller (HL) selects among multiple lowlevel (LL) control fragments, which are policies with proprioception. Switching from one control fragment to another occurs every $k$ time steps. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            205,
+            99,
+            795,
+            318
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "2.3 TRAINING HL-POLICIES TO SOLVE TASKS USING LL-CONTROLLERS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            402,
+            684,
+            416
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We integrated the low-level controllers into an agent architecture with vision and and an LSTM memory in order to apply it to tasks including directed movements to target locations, a running course with wall or gap obstacles, a foraging task for “balls”, and a simple memory task involving detecting and memorizing the reward value of the balls. ",
+        "bbox": [
+            174,
+            429,
+            825,
+            486
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The interface between the high-level controller and the low-level depends on the type of low-level controller: for the steerable controller, the high-level produces a one-dimensional output; for the switching and control fragment controllers, the high-level produces a 1-of-K index to select the lowlevel policies. The high-level policies are trained off-policy using data from a replay buffer. The replay buffer contains data generated from distributed actors, and in general the learner processes the same replay data multiple times. ",
+        "bbox": [
+            174,
+            493,
+            825,
+            577
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The high-level controller senses inputs from proprioceptive data and, for visual tasks, an egocentric camera mounted at the root of the body (Fig. 4). A noteworthy challenge arises due to the movement of the camera itself during locomotion. The proprioceptive inputs are encoded by a single linear layer, and the image is encoded by a ResNet (see Appendix A). The separate inputs streams are then flattened, concatenated, and passed to an LSTM, enabling temporally integrated decisions, with a stochastic policy and a value function head. The high-level controller receives inputs at each time step even though it may only act when the previous behavior (gait cycle or control fragment) has terminated. ",
+        "bbox": [
+            174,
+            583,
+            825,
+            695
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Importantly, while the low-level skills used exclusively egocentric proprioceptive input, the highlevel controller used vision to select from or modulate them, enabling the system as a whole to effect visuomotor computations. ",
+        "bbox": [
+            176,
+            702,
+            821,
+            744
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "High-level controller reinforcement learning details For the steerable controller, the policy was a parameterized Gaussian distribution that produces the steering angle $a _ { s } \\in [ - 1 . 5 , 1 . 5 ]$ . The mean of Gaussian was constrained via a tanh and sampled actions were clipped to the steering angle range. The steering angle was held constant for a full gait cycle. The policy was trained as previously described by learning a state-action value function off-policy using TD-learning with Retrace (Munos et al., 2016) with the policy trained using SVG(0) (Heess et al., 2015). ",
+        "bbox": [
+            174,
+            763,
+            825,
+            847
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For the switching controller and the discrete control fragments approach, the policy was a multinomial over the discrete set of behaviors. In either case, the high-level controller would trigger the behavior for its period $T$ (a gait cycle or a fragment length). To train these discrete controllers, we fit the state-value baseline $V$ -function using V-Trace and update the policy according to the method in Espeholt et al. (2018). While we provided a target for the value function loss at each time step, the policy gradient loss for the high-level was non-zero only when a new action was sampled (every $T$ steps). ",
+        "bbox": [
+            174,
+            854,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/6fde06b4a4230a10bdd07fed3dccb7725034668043b6a27735e50bc2924220a9.jpg",
+        "image_caption": [
+            "Figure 5: A. Go-to-target: in this task, the agent moves on an open plane to a target provided in egocentric coordinates. B. Walls: The agent runs forward while avoiding solid walls using vision. C. Gaps: The agent runs forward and must jump between platforms to advance. D. Forage: Using vision, the agent roams in a procedurally-generated maze to collect balls, which provide sparse rewards. E. Heterogeneous Forage: The agent must probe and remember rewards that are randomly assigned to the balls in each episode. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            236,
+            99,
+            759,
+            291
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            416,
+            823,
+            445
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Query-based control fragment selection We considered an alternative family of ideas to interface with control fragments based on producing a Gaussian policy search query to be compared against a feature-key for each control fragment. We then selected the control fragment whose key was nearest the query-action. Our method was based on the Wolpertinger approach introduced in (Dulac-Arnold et al., 2015). Here, the Q-function was evaluated for each of $k$ nearest neighbors to the query-action, and the control fragment were selected with Boltzmann exploration, i.e. $p ( a _ { i } ^ { H L } | h ) \\stackrel { \\cdot } { \\propto } \\exp ( \\frac { 1 } { T } Q ( h , a _ { i } ^ { H L } ) )$ , where $h$ is the output of the LSTM. See Appendix A.3.3 for more details. The intuition was that this would allow the high-level policy to be less precise as the Qfunction could assist it in selecting good actions. However, this approach under-performed relative to discrete action selection as we show in our results. ",
+        "bbox": [
+            174,
+            462,
+            825,
+            601
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            622,
+            326,
+            638
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.1 RESULTS ON CORE TASKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            654,
+            392,
+            667
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We compared the various approaches on a variety of tasks implemented in MuJoCo (Todorov et al., 2012). The core tasks we considered for the main comparisons were Go-to-target, wall navigation (Walls), running on gapped platforms (Gaps), foraging for colored ball rewards (Forage), and a foraging task requiring the agent to remember the reward value of the different colored balls (Heterogeneous Forage) (see Fig. 5). In Go-to-target, the agent received a sparse reward of 1 for each time step it was within a proximity radius of the target. For Walls and Gaps, adapted from Heess et al. (2017) to operate from vision, the agent received a reward proportional to its forward velocity. Forage was broadly similar to explore object locations in the DeepMind Lab task suite (Beattie et al., 2016) (with a humanoid body) while Heterogeneous Forage was a simplified version of explore object rewards. In all tasks, the body was initialized to a random pose from a subset of the reference motion capture data. For all tasks, other than Go-to-target, the high-level agent received a 64x64 image from the camera attached to the root of the body, in addition to the proprioceptive information. ",
+        "bbox": [
+            173,
+            680,
+            825,
+            861
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We compared the agents on our core set of tasks. Our overall best results were achieved using control fragments with discrete selection (Fig. 6). Additional training details are provided in Appendix A. For comparison, we also include the control experiment of training a policy to control the humanoid from scratch (without low-level controllers) as well as training a simple rolling ball body. The performance of the rolling ball is not directly comparable because its velocity differs from that of the humanoid, but isolates the task complexity from the challenge of motor control of the humanoid body. The switching controllers selected between a base set of four policies: stand, run, left and right turn. For the control fragments approach we were able to augment this set as described in Table 2. ",
+        "bbox": [
+            176,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/27596c13ee2a21747e57ac52841bea06152e3afb93b2d8927c8131c1e65feb8f.jpg",
+        "image_caption": [
+            "Figure 6: Performance of various approaches on each core task. Of the approaches we compared, discrete switching among control fragments performed the best. Plots show the mean and standard error over multiple runs. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            103,
+            792,
+            392
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            481,
+            825,
+            551
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The end-to-end approach (described in Appendix A.4) succeeded at only Go-to-target, however the resulting visual appearance was jarring. In the more complex Forage task, the end-to-end approach failed entirely. The steering controller was also able to perform the Go-to-target task, but a fixed turning radius meant that it was unable to make a direct approach the target, resulting in a long travel time to the target and lower score. Both the steering controller and switching controller were able to reach the end of the course in the Walls task, but only the control fragments approach allowed for sharper turns and quicker adjustments for agent to achieve a higher velocity. Generally, the switching controller with transitions started to learn faster and appeared the most graceful because of its predefined, smooth transitions, but its comparative lack of flexibility meant that its asymptotic task performance was relatively low. In the Forage task, where a score of $> 1 5 0$ means the agent is able to move around the maze and 600 is maximum collection of reward, the switching controller with transitions was able to traverse the maze but unable to adjust to the layout of the maze to make sharper turns to collect all objects. The control fragments approach was able to construct rotations and abrupt turns to collect the objects in each room. In the Gaps task, we were able to use the control fragments approach with 12 single-clip policies, where it would be laborious to pretrain transitions for each of these. In this task, the high-level controller selected between the 4 original stand, run and turn policies as well as 8 additional jumps, resulting in 359 fragments, and was able to synthesize them to move forward along the separated platforms. In the final Heterogeneous Forage task, we confirmed that the agent, equipped with an LSTM in the high-level controller, was capable of memory-dependent control behavior. See our Extended Video2 for a comprehensive presentation of the controllers. ",
+        "bbox": [
+            174,
+            558,
+            825,
+            849
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "All control fragment comparisons above used control fragments of 3 time steps (0.09s). To further understand the performance of the control fragment approach, we did a more exhaustive comparison of performance on Go-to-target of the effect of fragment length, number of fragments, as well as introduction of redundant clips (see appendix B). We saw benefits in early exploration due to using fragments for more than one time step but lower ultimate performance. Adding more fragments was helpful when those fragments were functionally similar to the standard set and the high-level controller was able to robustly handle those that involved extraneous movements unrelated to locomotion. ",
+        "bbox": [
+            176,
+            857,
+            823,
+            898
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/525b45d62d672078e6bc0bb8bb839469e1430379fb7e893d788934d5f5268269.jpg",
+        "image_caption": [
+            "Figure 7: Example agent-view frames and corresponding visuomotor salience visualizations. Note that the ball is more sharply emphasized, suggesting the selected actions were influenced by the affordance of tacking toward the ball. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            228,
+            108,
+            777,
+            261
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            353,
+            825,
+            422
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "3.2 ANALYSIS OF TRAINED HIGH-LEVEL POLICIES ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            441,
+            532,
+            455
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "While the query-based approaches did not outperform the discrete control fragment selection (Fig. 6), we include a representative visualization in Appendix A.3 to help clarify why this approach may not have worked well. In the present setting, it appears that the proposal distribution over queries generated by the high-level policy was high variance and did not learn to index the fragments precisely. ",
+        "bbox": [
+            174,
+            467,
+            825,
+            537
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "On Forage, the high-level controller with discrete selection of control fragments generated structured transitions between fragments (Appendix C). Largely, movements remained within clip or behavior type. The high-level controller ignored some fragments involving transitions from standing to running and left-right turns to use fast-walk-and-turn movements. ",
+        "bbox": [
+            174,
+            544,
+            825,
+            599
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "To assess the visual features that drove movements, we computed saliency maps (Simonyan et al., 2013) showing the intensity of the gradient of the selected action’s log-probability with respect to each pixel: $\\begin{array} { r } { { \\check { S _ { t ; x , y } } } = \\frac { 1 } { Z } \\operatorname* { m i n } ( g , \\frac { 1 } { 3 } \\check { \\sum _ { c } } | \\nabla _ { I _ { x , y , c } } \\log \\pi ( a _ { t } ^ { H L } | h _ { t } ) | ) } \\end{array}$ with normalization $Z$ and clipping $g$ (Fig. 7). Consistently, action selection was sensitive to the borders of the balls as well as to the walls. The visual features that this analysis identifies correspond roughly to sensorimotor affordances (Gibson, 2014); the agent’s perceptual representations were shaped by goals and action. ",
+        "bbox": [
+            174,
+            607,
+            825,
+            690
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4 DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            712,
+            310,
+            727
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this work we explored the problem of learning to reuse motor skills to solve whole body humanoid tasks from egocentric camera observations. We compared a range of approaches for reusing lowlevel motor skills that were obtained from motion capture data, including variations related to those presented in Liu & Hodgins (2017); Peng et al. (2018). To date, there is limited learning-based work on humanoids in simulation reusing motor skills to solve new tasks, and much of what does exist is in the animation literature. A technical contribution of the present work was to move past hand-designed observation features (as used in Heess et al. (2017); Peng et al. (2018)) towards a more ecological observation setting: using a front-facing camera is more similar to the kinds of observations a real-world, embodied agent would have. We also show that hierarchical motor skill reuse allowed us to solve tasks that we could not with a flat policy. For the walls and go-to-target tasks, learning from scratch was slower and produced less robust behavior. For the forage tasks, learning from scratch failed completely. Finally, the heterogeneous forage is an example of task that integrates memory and perception. ",
+        "bbox": [
+            174,
+            743,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "There are some other very clear continuities between what we present here and previous work. For learning low-level tracking policies from motion capture data, we employed a manually specified similarity measure against motion capture reference trajectories, consistent with previous work (Liu et al., 2010; 2015; Peng et al., 2018). Additionally, the low-level policies were time-indexed: they operated over only a certain temporal duration and received time or phase as input. Considerably less research has focused on learning imitation policies either without a pre-specified scoring function or without time-indexing (but see e.g. Merel et al. (2017)). Compared to previous work using control fragments (Liu & Hodgins, 2017), our low-level controllers were built without a sampling-based planner and were parameterized as neural networks rather than linear-feedback policies. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            228
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We also want to make clear that the graph-transition and steerable structured low-level control approaches require significant manual curation and design: motion capture clips must be segmented by hand, possibly manipulated by blending/smoothing clips from the end of one clip to the beginning of another. This labor intensive process requires considerable skill as an animator; in some sense this almost treats humanoid control as a computer-aided animation problem, whereas we aim to treat humanoid motor control as an automated and data-driven machine learning problem. We acknowledge that relative to previous work aimed at graphics and animation, our controllers are less graceful. Each approach involving motion capture data can suffer from distinct artifacts, especially without detailed manual editing – the hand-designed controllers have artifacts at transitions due to imprecise kinematic blending but are smooth within a behavior, whereas the control fragments have a lesser but consistent level of jitter throughout due to frequent switching. Methods to automatically (i.e. without human labor) reduce movement artifacts when dealing with large movement repertoires would be interesting to pursue. ",
+        "bbox": [
+            174,
+            236,
+            825,
+            416
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Moreover, we wish to emphasize that due to the human-intensive components of training structured low-level controllers, fully objective algorithm comparison with previous work can be somewhat difficult. This will remain an issue so long as human editing is a significant component of the dominant solutions. Here, we focused on building movement behaviors with minimal curation, at scale, that can be recruited to solve tasks. Specifically, we presented two methods that do not require curation and can re-use low-level skills with cold-switching. Additionally, these methods can scale to a large number of different behaviors without further intervention. ",
+        "bbox": [
+            174,
+            422,
+            825,
+            520
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We view this work as an important step toward the flexible use of motor skills in an integrated visuomotor agent that is able to cope with tasks that pose simultaneous perceptual, memory, and motor challenges to the agent. Future work will necessarily involve refining the naturalness of the motor skills to enable more general environment interactions and to subserve more complicated, compositional tasks. ",
+        "bbox": [
+            174,
+            527,
+            825,
+            597
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            613,
+            326,
+            626
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We thank Yuval Tassa for helpful comments. The data used in this project was obtained from mocap.cs.cmu.edu. The database was created with funding from NSF EIA-019621. ",
+        "bbox": [
+            174,
+            636,
+            823,
+            665
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            685,
+            285,
+            700
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Charles Beattie, Joel Z Leibo, Denis Teplyashin, Tom Ward, Marcus Wainwright, Heinrich Kuttler, ¨ Andrew Lefrancq, Simon Green, V´ıctor Valdes, Amir Sadik, et al. Deepmind lab. ´ arXiv preprint arXiv:1612.03801, 2016.   \nE Bizzi, VCK Cheung, A d’Avella, P Saltiel, and Me Tresch. Combining modules for movement. Brain research reviews, 57(1):125–133, 2008.   \nKai Ding, Libin Liu, Michiel Van de Panne, and KangKang Yin. Learning reduced-order feedback policies for motion skills. In Proceedings of the 14th ACM SIGGRAPH/Eurographics Symposium on Computer Animation, pp. 83–92. ACM, 2015.   \nGabriel Dulac-Arnold, Richard Evans, Hado van Hasselt, Peter Sunehag, Timothy Lillicrap, Jonathan Hunt, Timothy Mann, Theophane Weber, Thomas Degris, and Ben Coppin. Deep reinforcement learning in large discrete action spaces. arXiv preprint arXiv:1512.07679, 2015.   \nLasse Espeholt, Hubert Soyer, Remi Munos, Karen Simonyan, Vlad Mnih, Tom Ward, Yotam Doron, Vlad Firoiu, Tim Harley, Iain Dunning, Shane Legg, and Koray Kavukcuoglu. IMPALA: ",
+        "bbox": [
+            173,
+            708,
+            826,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Scalable distributed deep-RL with importance weighted actor-learner architectures. In Proceedings of the 35th International Conference on Machine Learning, volume 80, pp. 1407–1416, 2018. ",
+        "bbox": [
+            187,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Petros Faloutsos, Michiel Van de Panne, and Demetri Terzopoulos. Composable controllers for physics-based character animation. In Proceedings of the 28th annual conference on Computer graphics and interactive techniques, pp. 251–260. ACM, 2001a. ",
+        "bbox": [
+            174,
+            156,
+            825,
+            199
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Petros Faloutsos, Michiel van de Panne, and Demetri Terzopoulos. The virtual stuntman: dynamic characters with a repertoire of autonomous motor skills. Computers & Graphics, 25(6):933–953, 2001b. ",
+        "bbox": [
+            173,
+            209,
+            826,
+            251
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tamar Flash and Binyamin Hochner. Motor primitives in vertebrates and invertebrates. Current opinion in neurobiology, 15(6):660–666, 2005. ",
+        "bbox": [
+            174,
+            262,
+            823,
+            291
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "James J Gibson. The ecological approach to visual perception: classic edition. Psychology Press, 2014. ",
+        "bbox": [
+            169,
+            301,
+            825,
+            330
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sten Grillner, Jeanette Hellgren, Ariane Menard, Kazuya Saitoh, and Martin A Wikstrom. Mech- ¨ anisms for selection of basic motor programs–roles for the striatum and pallidum. Trends in neurosciences, 28(7):364–370, 2005. ",
+        "bbox": [
+            176,
+            340,
+            823,
+            383
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Karol Hausman, Jost Tobias Springenberg, Ziyu Wang, Nicolas Heess, and Martin Riedmiller. Learning an embedding space for transferable robot skills. International Conference on Learning Representations, 2018. URL https://openreview.net/forum?id $\\underline { { \\underline { { \\mathbf { \\Pi } } } } } =$ rk07ZXZRb. accepted as poster. ",
+        "bbox": [
+            174,
+            392,
+            825,
+            449
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nicolas Heess, Gregory Wayne, David Silver, Tim Lillicrap, Tom Erez, and Yuval Tassa. Learning continuous control policies by stochastic value gradients. In Advances in Neural Information Processing Systems, pp. 2944–2952, 2015. ",
+        "bbox": [
+            174,
+            459,
+            825,
+            503
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nicolas Heess, Greg Wayne, Yuval Tassa, Timothy Lillicrap, Martin Riedmiller, and David Silver. Learning and transfer of modulated locomotor controllers. arXiv preprint arXiv:1610.05182, 2016. ",
+        "bbox": [
+            173,
+            512,
+            825,
+            555
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nicolas Heess, TB Dhruva, Srinivasan Sriram, Jay Lemmon, Josh Merel, Greg Wayne, Yuval Tassa, Tom Erez, Ziyu Wang, SM Ali Eslami, et al. Emergence of locomotion behaviours in rich environments. arXiv preprint arXiv:1707.02286, 2017. ",
+        "bbox": [
+            174,
+            565,
+            825,
+            609
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Daniel Holden, Taku Komura, and Jun Saito. Phase-functioned neural networks for character control. ACM Transactions on Graphics (TOG), 36(4):42, 2017. ",
+        "bbox": [
+            173,
+            618,
+            823,
+            648
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Auke J Ijspeert, Jun Nakanishi, and Stefan Schaal. Learning attractor landscapes for learning motor primitives. In Advances in neural information processing systems, pp. 1547–1554, 2003. ",
+        "bbox": [
+            173,
+            657,
+            823,
+            688
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Auke Jan Ijspeert, Jun Nakanishi, and Stefan Schaal. Movement imitation with nonlinear dynamical systems in humanoid robots. In Robotics and Automation, 2002. Proceedings. ICRA’02. IEEE International Conference on, volume 2, pp. 1398–1403. IEEE, 2002. ",
+        "bbox": [
+            174,
+            696,
+            825,
+            739
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Max Jaderberg, Wojciech M Czarnecki, Iain Dunning, Luke Marris, Guy Lever, Antonio Garcia Castaneda, Charles Beattie, Neil C Rabinowitz, Ari S Morcos, Avraham Ruderman, et al. Humanlevel performance in first-person multiplayer games with population-based deep reinforcement learning. arXiv preprint arXiv:1807.01281, 2018. ",
+        "bbox": [
+            173,
+            750,
+            825,
+            806
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. CoRR, abs/1412.6980, 2014. URL http://arxiv.org/abs/1412.6980. ",
+        "bbox": [
+            171,
+            818,
+            823,
+            845
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jens Kober and Jan Peters. Learning prioritized control of motor primitives. In Learning Motor Skills, pp. 149–160. Springer, 2014. ",
+        "bbox": [
+            171,
+            856,
+            823,
+            885
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jens Kober and Jan R Peters. Policy search for motor primitives in robotics. In Advances in neural information processing systems, pp. 849–856, 2009. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jens Kober, Betty Mohler, and Jan Peters. Learning perceptual coupling for motor primitives. In Intelligent Robots and Systems, 2008. IROS 2008. IEEE/RSJ International Conference on, pp. 834–839. IEEE, 2008. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            145
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "George Konidaris, Scott Kuindersma, Roderic Grupen, and Andrew Barto. Robot learning from demonstration by constructing skill trees. The International Journal of Robotics Research, 31(3): 360–375, 2012. ",
+        "bbox": [
+            173,
+            156,
+            825,
+            199
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Timothy P Lillicrap, Jonathan J Hunt, Alexander Pritzel, Nicolas Heess, Tom Erez, Yuval Tassa, David Silver, and Daan Wierstra. Continuous control with deep reinforcement learning. arXiv preprint arXiv:1509.02971, 2015. ",
+        "bbox": [
+            174,
+            209,
+            825,
+            252
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Libin Liu and Jessica Hodgins. Learning to schedule control fragments for physics-based characters using deep q-learning. ACM Transactions on Graphics (TOG), 36(3):29, 2017. ",
+        "bbox": [
+            174,
+            262,
+            821,
+            291
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Libin Liu and Jessica Hodgins. Learning basketball dribbling skills using trajectory optimization and deep reinforcement learning. ACM Transactions on Graphics (TOG), 37(4):142, 2018. ",
+        "bbox": [
+            171,
+            301,
+            823,
+            332
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Libin Liu, KangKang Yin, Michiel van de Panne, Tianjia Shao, and Weiwei Xu. Sampling-based contact-rich motion control. In ACM Transactions on Graphics (TOG), volume 29, pp. 128. ACM, 2010. ",
+        "bbox": [
+            174,
+            340,
+            825,
+            383
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Libin Liu, KangKang Yin, Michiel van de Panne, and Baining Guo. Terrain runner: control, parameterization, composition, and planning for highly dynamic motions. ACM Transactions on Graphics (TOG), 31(6):154, 2012. ",
+        "bbox": [
+            173,
+            393,
+            825,
+            436
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Libin Liu, KangKang Yin, and Baining Guo. Improving sampling-based motion control. In Computer Graphics Forum, volume 34, pp. 415–423. Wiley Online Library, 2015. ",
+        "bbox": [
+            173,
+            446,
+            821,
+            477
+        ],
+        "page_idx": 11
+    },
+    {
+        "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,
+            486,
+            825,
+            529
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Remi Munos, Tom Stepleton, Anna Harutyunyan, and Marc Bellemare. Safe and efficient off-policy ´ reinforcement learning. In Advances in Neural Information Processing Systems, pp. 1054–1062, 2016. ",
+        "bbox": [
+            174,
+            540,
+            823,
+            582
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Gerhard Neumann, Christian Daniel, Alexandros Paraschos, Andras Kupcsik, and Jan Peters. Learning modular policies for robotics. Frontiers in computational neuroscience, 8:62, 2014. ",
+        "bbox": [
+            173,
+            593,
+            823,
+            622
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "OpenAI. Openai five. journal=https://blog.openai.com/openai-five/, 2018. ",
+        "bbox": [
+            171,
+            632,
+            776,
+            647
+        ],
+        "page_idx": 11
+    },
+    {
+        "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,
+            657,
+            825,
+            700
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Xue Bin Peng, Pieter Abbeel, Sergey Levine, and Michiel van de Panne. Deepmimic: Example-guided deep reinforcement learning of physics-based character skills. arXiv preprint arXiv:1804.02717, 2018. ",
+        "bbox": [
+            173,
+            710,
+            825,
+            753
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy optimization algorithms. arXiv preprint arXiv:1707.06347, 2017. ",
+        "bbox": [
+            171,
+            762,
+            825,
+            792
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Luis Sentis and Oussama Khatib. Synthesis of whole-body behaviors through hierarchical control of behavioral primitives. International Journal of Humanoid Robotics, 2(04):505–518, 2005. ",
+        "bbox": [
+            171,
+            803,
+            825,
+            832
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Karen Simonyan, Andrea Vedaldi, and Andrew Zisserman. Deep inside convolutional networks: Visualising image classification models and saliency maps. arXiv preprint arXiv:1312.6034, 2013. ",
+        "bbox": [
+            171,
+            842,
+            823,
+            872
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Richard S Sutton, Doina Precup, and Satinder Singh. Between mdps and semi-mdps: A framework for temporal abstraction in reinforcement learning. Artificial intelligence, 112(1-2):181– 211, 1999. ",
+        "bbox": [
+            174,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yuval Tassa, Yotam Doron, Alistair Muldal, Tom Erez, Yazhe Li, Diego de Las Casas, David Budden, Abbas Abdolmaleki, Josh Merel, Andrew Lefrancq, et al. Deepmind control suite. arXiv preprint arXiv:1801.00690, 2018. ",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Emanuel Todorov, Tom Erez, and Yuval Tassa. Mujoco: A physics engine for model-based control. In Intelligent Robots and Systems (IROS), 2012 IEEE/RSJ International Conference on, pp. 5026– 5033. IEEE, 2012. ",
+        "bbox": [
+            174,
+            155,
+            823,
+            196
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Greg Wayne, Chia-Chun Hung, David Amos, Mehdi Mirza, Arun Ahuja, Agnieszka GrabskaBarwinska, Jack Rae, Piotr Mirowski, Joel Z Leibo, Adam Santoro, et al. Unsupervised predictive memory in a goal-directed agent. arXiv preprint arXiv:1803.10760, 2018. ",
+        "bbox": [
+            174,
+            207,
+            825,
+            250
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "APPENDICES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            282,
+            117
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A ADDITIONAL TRAINING DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            142,
+            482,
+            157
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Following Espeholt et al. (2018), all training was done using a distributed actor-learner architecture. Many asynchronous actors interact with the environment to produce trajectories of $\\left( { { s _ { t } } , { a _ { t } } , { r _ { t } } , { s _ { t + 1 } } } \\right)$ tuples of a fixed rollout length, $N$ . In contrast to Espeholt et al. (2018), each trajectory was stored in a replay buffer. The learner sampled trajectories of length $N$ at random and performed updates. Each actor retrieved parameters from the learner at a fixed time interval. The learner ran on a single Pascal 100 or Volta 100 GPU. The plots presented use the steps processed by the learner on the $\\mathbf { X }$ -axis. This is the number of transition retrieved from the replay buffer, which is equivalent to the number of gradient updates $\\mathbf { X }$ batch size x rollout length. ",
+        "bbox": [
+            173,
+            178,
+            825,
+            289
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We performed all optimization with Adam (Kingma & Ba, 2014) and used hyperparameter sweeps to select learning rates and batch sizes. ",
+        "bbox": [
+            174,
+            295,
+            823,
+            324
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/6f5dee1c8d17cafe61f21a9a3fe33393dc32f771c5e253f3ebc4affd951e9014.jpg",
+        "table_caption": [
+            "Table 1: Parameters for training the agent on different environments/tasks. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Task</td><td colspan=\"6\"></td></tr><tr><td></td><td>unroll</td><td>LSTM state size</td><td> value MLP</td><td>gamma</td><td>replay size</td><td></td></tr><tr><td>Go To Target</td><td>10</td><td>128</td><td>(128,1)</td><td>0.99</td><td>106</td><td></td></tr><tr><td>Walls / Gaps</td><td>20</td><td>128</td><td>(128,1)</td><td>0.99</td><td>104</td><td></td></tr><tr><td>Forage</td><td>50</td><td>256</td><td>(200,200,1)</td><td>0.995</td><td>104</td><td></td></tr><tr><td>Heterogeneous Forage</td><td>200</td><td>256</td><td>(200,200,1)</td><td>0.99</td><td>105</td><td></td></tr></table>",
+        "bbox": [
+            191,
+            343,
+            807,
+            449
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A.1 SELECTED LOW-LEVEL POLICIES TRAINED FROM MOTION CAPTURE ",
+        "bbox": [
+            174,
+            520,
+            686,
+            534
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "For the switching controller and control fragments approach we used a standard set of four policies trained from motion capture which imitated stand, run, left and right turn behaviors. In the switching controller, pretrained transitions were created in the reference data. For the control fragments approach, we were able to augment the set without any additional work and the selected policies are described in Table 2. ",
+        "bbox": [
+            174,
+            547,
+            825,
+            617
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/3f8ac1c36a36c43d13050ea06e31633d0ee10e2c1cfd9af62e74330fd4cfe2b2.jpg",
+        "table_caption": [
+            "Table 2: Selected motion-capture clips for control fragments controller. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Task</td><td>Selected policies</td><td>Num.control fragments</td></tr><tr><td></td><td></td><td></td></tr><tr><td>Go To Target</td><td>stand,run,left turn, right turn</td><td>105</td></tr><tr><td>Walls Forage</td><td>stand,run,left turn,right turn stand, run,left turn, right turn,</td><td>105 183</td></tr><tr><td></td><td>2 walk and turns</td><td></td></tr><tr><td>Heterogeneous Forage</td><td>stand,run,left turn,right turn, 2 turns and 2 about-face</td><td>359</td></tr><tr><td>Gaps</td><td>stand, run,left turn, right turn, 8 jumps</td><td>359</td></tr></table>",
+        "bbox": [
+            217,
+            635,
+            779,
+            779
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A.2 HETEROGENEOUS FORAGE TASK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            852,
+            446,
+            867
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "In the heterogeneous forage task, the humanoid is spawned in a room with 6 balls, 3 colored red and 3 colored green. Each episode, one color is selected at random and assigned a positive value $( + 3 0 )$ or a negative value (-10) and the agent must sample a ball and then only collect the positive ones. ",
+        "bbox": [
+            176,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A.3 HIGH-LEVEL CONTROLLER TRAINING DETAILS",
+        "text_level": 1,
+        "bbox": [
+            176,
+            104,
+            540,
+            117
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "The architecture of the high-level controller consisted of proprioceptive encoder and an optional image encoder which, along with prior reward and action, were passed to an LSTM. This encoding core was shared with both the actor and critic. The details of the encoder are depicted in Fig. A.1. ",
+        "bbox": [
+            174,
+            128,
+            825,
+            171
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/42f07898632084501e84aeba11404b8492ee92bd9cc485cfca2da2af62e2b933.jpg",
+        "image_caption": [
+            "Figure A.1: Complete diagram of high-level agent architecture with encoders. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            245,
+            183,
+            758,
+            472
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "A.3.1 STEERING CONTROLLER TRAINING DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            526,
+            539,
+            541
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "The steering controller policy head took as input the outputs of the LSTM in Fig. A.1. The policy head was an LSTM, with a state size of 128, followed by a linear layer. The linear layer produced the parameters for a 1-D Gaussian. The $\\mu$ parameters were constrained by a tanh and the $\\sigma$ parameters were clipped between [0.1, 1]. ",
+        "bbox": [
+            173,
+            551,
+            825,
+            608
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "The policy was trained with a SVG(0) update (Heess et al., 2015). A state-action value / Q function was implemented as an MLP with dimensions in Table 1 and trained with a Retrace target. Target networks were used for Q and updated every 100 training iterations. ",
+        "bbox": [
+            176,
+            613,
+            823,
+            656
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "The policy was also updated by an additional entropy cost at each time step, which was added to the policy update with a weight of $1 e ^ { - 5 }$ . ",
+        "bbox": [
+            176,
+            662,
+            823,
+            691
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "A.3.2 SWITCHING CONTROLLER TRAINING DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            705,
+            549,
+            719
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "The switching controller policy head took as input the outputs of the LSTM in Fig. A.1. The policy head was an LSTM, with a state size of 128, followed by a linear layer to produce the logits of the multinomial distribution. ",
+        "bbox": [
+            176,
+            729,
+            823,
+            772
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "The policy was updated with a policy gradient using $N$ -step empirical returns with bootstrapping to compute an advantage, where $N$ was equivalent to the rollout length in Table 1. The value-function (trained via V-Trace) was used as a baseline. ",
+        "bbox": [
+            176,
+            779,
+            823,
+            821
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "The policy was also updated by an additional entropy cost at each time step, which was added to the policy update with a weight of .01. ",
+        "bbox": [
+            173,
+            828,
+            823,
+            857
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "A.3.3 DETAILS OF QUERY-BASED ACTION SELECTION APPROACH",
+        "text_level": 1,
+        "bbox": [
+            174,
+            872,
+            637,
+            886
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "We train a policy to produce a continuous feature vector (i.e. the query-action), so the selector is parameterized by a diagonal multivariate Gaussian action model. The semantics of the query-action ",
+        "bbox": [
+            174,
+            895,
+            820,
+            924
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "will correspond to the features in the control fragment feature-key vectors, which were partial state observations (velocity, orientation, and end-effector relative positions) of the control fragment’s nominal start or end pose. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            146
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/cd6c61e928dee70f58a1eb5aa865ca84638ea0db9f7f842e70489fae05b108b5.jpg",
+        "image_caption": [
+            "Figure A.2: Illustration of query-based control fragment selection in which a query feature vector is produced, compared with key feature vectors for all control fragments, and the Q-value of selecting each control fragment in the current state is used to determine which control fragment is executed. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            299,
+            157,
+            697,
+            275
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "In this approach, the Q function was trained with 1 step returns. So, for samples $\\left( { { s _ { t } } , { a _ { t } } , { r _ { t } } , { s _ { t + 1 } } } \\right)$ from replay: ",
+        "bbox": [
+            173,
+            342,
+            821,
+            371
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "equation",
+        "img_path": "images/37cd84b1c6ba58de2657080f8a580f5c5371c0fcc0e52e6b6687572a09df302b.jpg",
+        "text": "$$\n\\begin{array} { l } { q _ { t a r g e t } = \\displaystyle r _ { t } + \\gamma \\mathbb { E } _ { a \\sim \\pi ( \\cdot | h _ { t + 1 } ) } [ Q ( h _ { t + 1 } , a ) ] } \\\\ { \\ell _ { c r i t i c } = \\displaystyle \\frac { 1 } { 2 } | | Q ( h _ { t } , a _ { t } ) - q _ { t a r g e t } | | _ { 2 } ^ { 2 } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            361,
+            376,
+            637,
+            429
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "The total loss is summed across minibatches sampled from replay. Note that for the query-based approach we have query actions which are in the same space as but generally distinct from the reference keys of the control fragments which are selected after the sampling procedure. ",
+        "bbox": [
+            174,
+            431,
+            825,
+            474
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "The high-level policy emits query actions, which are rectified to reference keys by a nearest lookup (i.e. the selected actions). This leads to two, slightly different high-level actions in the same space. This leads to the question of what is the appropriate action on which to perform both policy updates and value function updates. ",
+        "bbox": [
+            173,
+            481,
+            825,
+            537
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "To handle this, it proved most stable to compute targets and loss terms for both the query-actions and selected actions for each state from replay. In this way, a single Q function represented the value of query-actions and selected actions. This was technically an approximation as the training of the Q-function pools these two kinds of action input. Finally, the policy update used the SVG(0)-style update (Heess et al., 2015): ",
+        "bbox": [
+            173,
+            544,
+            825,
+            614
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "equation",
+        "img_path": "images/42abac6810a816e347f36c343e68ec5b5b36e8c0338c9f40256932215df11745.jpg",
+        "text": "$$\n\\ell _ { a c t o r } = - \\mathbb { E } _ { \\xi \\sim \\mathcal { N } ( 0 , 1 ) } Q ( h _ { t } , a ( h _ { t } , \\xi ) )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            375,
+            621,
+            620,
+            640
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/456f1796b93b9f6866c69ba2dd351ab7b81930826d3bf9c2a7775b48bf9b00e1.jpg",
+        "image_caption": [
+            "Figure A.3: Visualization (using PCA) of the actions produced by the trained query-based policy (on go-to-target). Query actions are the continuous actions generated by the policy. Reference keys are the feature vectors associated with the control fragments (here, features of the final state of the nominal trajectory of the fragment). Selected actions are the actions produced by the sampling mechanism and they are overlain to emphasize the control reference keys actually selected. The most prominent feature of this visualization is the lack of precision in the query actions. Note that 45/105 control fragments were selected by the trained policy. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            200,
+            671,
+            464,
+            866
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "We hypothesize that the limited success of this approach is perhaps partly due to the impreciseness in their selectivity (see Fig A.3). After finding these approaches were not working very well, an additional analysis of a trained discrete-selection agent, not shown here, found that the second most preferred control fragment (in a given state) was not usually the control fragment with the most similar reference key. This implies that the premise of the query-based approach, namely that similar fragments should be preferentially confused/explored may not be as well-justified in this case as we speculated, when we initially conceived of trying it. That analysis notwithstanding, we remain optimistic this approach may end up being more useful than we found it to be here. ",
+        "bbox": [
+            174,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "A.4 END-TO-END CONTROLLER TRAINING DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            190,
+            545,
+            205
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "End-to-end training on each task was performed in a similar fashion to training the low-level controllers. Using the same architecture as in A.1, the policy was trained to output the 56-dimensional action for the position-controlled humanoid. As in the low-level training, the policy was trained with a SVG(0) update (Heess et al., 2015) and Q was trained with a Retrace target. The episode was terminated when the humanoid was in an irrecoverable state and when the head fell below a fixed height. ",
+        "bbox": [
+            173,
+            215,
+            825,
+            300
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "B SCALING AND FRAGMENT LENGTH ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            321,
+            500,
+            337
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "We compared performance as a function of the number of fragments as a well as the length of fragments. If using a fixed number of behaviors and cutting them into control fragments of various lengths, two features are coupled: the length of the fragments vs. how many fragments there are. One can imagine a trade-off – more fragments might make exploration harder, but shorter temporal commitment to a fragment may ultimately lead to more precise control. To partially decouple the number of fragments from their length, we also compared performance with functionally redundant but larger sets of control fragments. ",
+        "bbox": [
+            173,
+            352,
+            825,
+            449
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/6b289bd44fedf7a27aa9a2f095746ea297dc362f63ca3f305019122c845ad17a.jpg",
+        "image_caption": [
+            "Figure A.4: A. Training was most stable with shorter fragment length (1 / .03 sec or 3 / .09 sec. B. Increasing the number of fragments, by duplicating the original set, did not hurt training performance. C. Additional functionally redundant policies (i.e. 4 vs 8 behaviors, cut into many control fragments) improved training speed, while additional extraneous policies were easily ignored. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            464,
+            820,
+            625
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "Ultimately, it appears that from a strict task-performance perspective, shorter control fragments tend to perform best as they allow greatest responsiveness. That being said, the visual appearance of the behavior tends to be smoother for longer control fragments. Control fragments of length 3 (.09 sec) seemed to trade-off behavioral coherence against performance favorably. Hypothetically, longer control fragments might also shape the action-space and exploration distribution favorably. We see a suggestion of this with longer-fragment curves ascending earlier. ",
+        "bbox": [
+            173,
+            713,
+            825,
+            796
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/a09f591112df1799327368396e89430b347dc52e552aded2dedf0cdb7036349f.jpg",
+        "image_caption": [
+            "Figure A.5: Transition density between control fragments for a trained agent on Forage. The background colors reflect density of transitions within a clip/behavior class (darker is denser), and single fragment transition densities are overlain as circles where size indicates the density of that particular transition. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            138,
+            820,
+            637
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "image",
+        "img_path": "images/5ad7e4fe5a33b6cfba79dcdb2a7f0b6c8e1c1dedd1459d43c5898d4b665d2803.jpg",
+        "image_caption": [
+            "Figure A.6: We depict a timeseries of the behavior of a trained high-level policy on Forage. In this particular trained agent, it frequently transitions to a particular stand fragment which it has learned to rely on. Green vertical lines depict reward acquisition. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            299,
+            820,
+            667
+        ],
+        "page_idx": 18
+    }
+]

parse/train/HJlTpCEKvS/HJlTpCEKvS.md

@@ -0,0 +1,324 @@
+# WHICH TASKS SHOULD BE LEARNED TOGETHER IN MULTI-TASK LEARNING?
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Many computer vision applications require solving multiple tasks in real-time. A neural network can be trained to solve multiple tasks simultaneously using multitask learning. This saves computation at inference time as only a single network needs to be evaluated. Unfortunately, this often leads to inferior overall performance as task objectives can compete, which consequently poses the question: which tasks should and should not be learned together in one network when employing multi-task learning? We systematically study task cooperation and competition and propose a framework for assigning tasks to a few neural networks such that cooperating tasks are computed by the same neural network, while competing tasks are computed by different networks. Our framework offers a timeaccuracy trade-off and can produce better accuracy using less inference time than not only a single large multi-task neural network but also many single-task networks.
+
+# 1 INTRODUCTION
+
+Many applications, especially robotics and autonomous vehicles, are chiefly interested in using multi-task learning to reduce the inference time and computational complexity required to estimate many characteristics of visual input. For example, an autonomous vehicle may need to detect the location of pedestrians, determine a per-pixel depth, and predict objects’ trajectories, all within tens of milliseconds. In multi-task learning, multiple tasks are solved at the same time, typically with a single neural network. In addition to reduced inference time, solving a set of tasks jointly rather than independently can, in theory, have other benefits such as improved prediction accuracy, increased data efficiency, and reduced training time.
+
+Unfortunately, the quality of predictions are often observed to suffer when a network is tasked with making multiple predictions. This is because learning objectives can have complex and unknown dynamics and may compete. In fact, multi-task performance can suffer so much that smaller independent networks are often superior (as we will see in the experiments section). We refer to any situation in which the competing priorities of the network cause poor task performance as crosstalk.
+
+On the other hand, when task objectives do not interfere much with each other, performance on both tasks can be maintained or even improved when jointly trained. Intuitively, this loss or gain of quality seems to depend on the relationship between the jointly trained tasks.
+
+Prior work has studied the relationship between tasks for transfer learning (Zamir et al. (2018)). However, we find that transfer relationships are not highly predictive of multi-task relationships. In addition to studying multi-task relationships, we attempt to determine how to produce good prediction accuracy under a limited inference time budget by assigning competing tasks to separate networks and cooperating tasks to the same network.
+
+More concretely, this leads to the following problem: Given a set of tasks, $\tau$ , and a computational budget $b$ (e.g., maximum allowable inference time), what is the optimal way to assign tasks to networks with combined cost $\leq b$ such that a combined measure of task performances is maximized?
+
+To this end, we develop a computational framework for choosing the best tasks to group together in order to have a small number of separate deep neural networks that completely cover the task set and that maximize task performance under a given computational budget. We make the intriguing observation that the inclusion of an additional task in a network can potentially improve the accuracy of the other tasks, even though the performance of the added task might be poor. This can be viewed as regularizing or guiding the loss of one task by adding an additional loss, as often employed in curriculum learning or network regularization Bengio et al. (2009). Achieving this, of course, depends on picking the proper regularizing task – our system can take advantage of this phenomenon, as schematically shown in Figure 1.
+
+![](images/6448c3fb14124b29746bb1a89bf07a2714b08ad13a7c8ec0b39edfa17bbeec5c.jpg)  
+Figure 1: Given five tasks to solve, there are many ways that they can be split into task groups for multitask learning. How do we find the best one? We propose a computational framework that, for instance, suggests the following grouping to achieve the lowest total loss, using a computational budget of 2.5 units: train network A to solve Semantic Segmentation, Depth Estimation, and Surface Normal Prediction; train network B to solve Keypoint Detection, Edge Detection, and Surface Normal Prediction; train network C with a less computationally expensive encoder to solve Surface Normal Prediction alone; including Surface Normals as an output in the first two networks were found advantageous for improving the other outputs, while the best Normals were predicted by the third network. This task grouping outperforms all other feasible ones, including learning all five tasks in one large network or using five dedicated smaller networks.
+
+This paper has two main contributions. In Section 3, we outline a framework for systematically assigning tasks to networks in order to achieve the best total prediction accuracy with a limited inference-time budget. We then analyze the resulting accuracy and show that selecting the best assignment of tasks to groups is critical for good performance. Secondly, in Section 6, we analyze situations in which multi-task learning helps and when it doesn’t, quantify the compatibilities of various task combinations for multi-task learning, compare them to the transfer learning task affinities, and discuss the implications. Moreover, we analyze the factors that influence multi-task affinities.
+
+# 2 PRIOR WORK
+
+Multi-Task Learning: See Ruder (2017) for a good overview of multi-task learning. The authors identify two clusters of contemporary techniques that we believe cover the space well, hard parameter sharing and soft parameter sharing. In brief, the primary difference between the majority of the existing works and our study is that we wish to understand the relationships between tasks and find compatible groupings of tasks for any given set of tasks, rather than designing a neural network architecture to solve a particular fixed set of tasks well.
+
+A known contemporary example of hard parameter sharing in computer vision is UberNet (Kokkinos (2017)). The authors tackle 7 computer vision problems using hard parameter sharing. The authors focus on reducing the computational cost of training for hard parameter sharing, but experience a rapid degradation in performance as more tasks are added to the network. Hard parameter sharing is also used in many other works such as (Thrun (1996); Caruana (1997); Nekrasov et al. (2018); Dvornik et al. (2017); Kendall et al. (2018); Bilen & Vedaldi (2016); Pentina & Lampert (2017); Doersch & Zisserman (2017); Zamir et al. (2016); Long et al. (2017); Mercier et al. (2018); d. Miranda et al. (2012); Zhou et al. (2018); Rudd et al. (2016)).
+
+Other works, such as (Sener & Koltun (2018)) and (Chen et al. (2018b)), aim to dynamically reweight each task’s loss during training. The former work finds weights that provably lead to a Pareto-optimal solution, while the latter attempts to find weights that balance the influence of each task on network weights. Finally, (Bingel & Søgaard (2017)) studies task interaction for NLP.
+
+In soft or partial parameter sharing, either there is a separate set of parameters per task, or a significant fraction of the parameters are unshared. The models are tied together either by information sharing or by requiring parameters to be similar. Examples include (Dai et al. (2016); Duong et al. (2015); Misra et al. (2016); Tessler et al. (2017); Yang & Hospedales (2017); Lu et al. (2017)).
+
+The canonical example of soft parameter sharing can be seen in (Duong et al. (2015)). The authors are interested in designing a deep dependency parser for languages such as Irish that do not have much treebank data available. They tie the weights of two networks together by adding an L2 distance penalty between corresponding weights and show substantial improvement.
+
+Another example of soft parameter sharing is Cross-stitch Networks (Misra et al. (2016)). Starting with separate networks for two tasks, the authors add ‘cross-stitch units’ between them, which allow each network to peek at the other network’s hidden layers. This approach reduces but does not eliminate task interfearence, and the overall performance is less sensitive to the relative loss weights.
+
+Unlike our method, none of the aforementioned works attempt to discover good groups of tasks to train together. Also, soft parameter sharing does not reduce inference time, a major goal of ours.
+
+Transfer Learning: Transfer learning (Pratt (1993); Helleputte & Dupont (2009); Silver & Bennett (2008); Finn et al. (2016); Mihalkova et al. (2007); Niculescu-Mizil & Caruana (2007); Luo et al. (2017); Razavian et al. (2014); Pan & Yang (2010); Mallya & Lazebnik (2018); Fernando et al. (2017); Rusu et al. (2016)) is similar to multi-task learning in that solutions are learned for multiple tasks. Unlike multi-task learning, however, transfer learning methods often assume that a model for a source task is given and then adapt that model to a target task. Transfer learning methods generally neither seek any benefit for source tasks nor a reduction in inference time as their main objective.
+
+Neural Architecture Search (NAS): Many recent works search the space of deep learning architectures to find ones that perform well (Zoph & Le, 2017; Liu et al., 2018; Pham et al., 2018; Xie et al., 2019; Elsken et al., 2019; Zhou et al., 2019; Baker et al., 2017; Real et al., 2018). This is related to our work as we search the space of task groupings. Just as with NAS, the found task groupings often perform better than human-engineered ones.
+
+Task Relationships: Our work is most related to Taskonomy (Zamir et al. (2018)), where the authors studied the relationships between visual tasks for transfer learning and introduced a dataset with over 4 million images and corresponding labels for 26 tasks. This was followed by a number of recent works, which further analyzed task relationships (Pal & Balasubramanian (2019); Dwivedi & Roig. (2019); Achille et al. (2019); Wang et al. (2019)) for transfer learning. While they extract relationships between these tasks for transfer learning, we are interested in the multi-task learning setting. Interestingly, we find notable differences between transfer task affinity and multi-task affinity. Their method also differs in that they are interested in labeled-data efficiency and not inference-time efficiency. Finally, the transfer quantification approach taken by Taskonomy (readout functions) is only capable of finding relationships between the high-level bottleneck representations developed for each task, whereas structural similarities between tasks at all levels are potentially relevant for multi-task learning.
+
+# 3 TASK GROUPING FRAMEWORK
+
+Our goal is to find an assignment of tasks to networks that results in the best overall loss. Our strategy is to select from a large set of candidate networks to include in our final solution.
+
+We define the problem as follows: We want to minimize the overall loss on a set of tasks $\tau =$ $\{ t _ { 1 } , t _ { 2 } , . . . , t _ { k } \}$ given a limited inference time budget, $b$ , which is the total amount of time we have to complete all tasks. Each neural network that solves some subset of $\tau$ and that could potentially be a part of the final solution is denoted by $n$ . It has an associated inference time cost, $c _ { n }$ , and a loss for each task, $\mathcal { L } ( n , t _ { i } )$ (which is $\infty$ for each task the network does not attempt to solve). A solution $\pmb { S }$ is a set of networks that together solve all tasks. The computational cost of a solution is $\begin{array} { r } { \mathrm { c o s t } ( { \pmb S } ) = \sum _ { n \in { \pmb S } } c _ { n } } \end{array}$ . The loss of a solution on a task, $\boldsymbol { \mathcal { L } } ( S , t _ { i } )$ , is the lowest loss on that task among the solution’s networks1, $\begin{array} { r } { \mathcal { L } ( S , t _ { i } ) = \operatorname* { m i n } _ { n \in S } \mathcal { L } ( n , t _ { i } ) } \end{array}$ . The overall performance for a solution is $\begin{array} { r } { \mathbf { \mathcal { L } } ( S ) = \sum _ { t _ { i } \in \mathcal { T } } \mathcal { L } ( S , t _ { i } ) } \end{array}$ .
+
+We want to find the solution with the lowest overall loss and a cost that is under our budget, $\boldsymbol { S } _ { b } =$ argmin $\begin{array}{c} S { \mathrm { : c o s t } } ( S ) { \le } b  \end{array} . \mathcal { L } ( S )$ .
+
+# 3.1 WHICH CANDIDATE NETWORKS TO CONSIDER?
+
+For a given task set $\tau$ , we wish to determine not just how well each pair of tasks performs when trained together, but also how well each combination of tasks performs together so that we can capture higher-order task relationships. To that end, our candidate set of networks contains all $2 ^ { | \mathcal { T } | } - 1$ possible groupings: $\binom { | \mathcal { T } | } { 1 }$ networks with one task, $\binom { | \mathcal { T } | } { 2 }$ networks with two tasks, $\binom { | \mathcal { T } | } { 3 }$ networks with three tasks, etc. For the five tasks we use in our experiments, this is 31 networks, of which five are single-task networks.
+
+The size of the networks is another design choice, and to somewhat explore its effects we also include 5 single task networks each with half of the computational cost of a standard network. This brings our total up to 36 networks.
+
+# 3.2 NETWORK SELECTION
+
+Consider the situation in which we have an initial candidate set $C _ { 0 } = \{ n _ { 1 } , n _ { 2 } , . . . , n _ { m } \}$ of fullytrained networks that each solve some subset of our task set $\tau$ . Our goal is to choose a subset of $C _ { 0 }$ that solve all the tasks with total inference time under budget $b$ and the lowest overall loss. More formally, we want to find a solution $\begin{array} { r } { S _ { b } = \operatorname * { a r g m i n } _ { S \subseteq C _ { 0 } : \operatorname { c o s t } ( S ) \leq b } { \mathcal { L } } ( S ) } \end{array}$ .
+
+It can be shown that solving this problem is NP-hard in general (reduction from SET-COVER). However, many techniques exist that can optimally solve most reasonably-sized instances of problems like these in acceptable amounts of time. All of these techniques produce the same solutions. We chose to use a branch-and-bound-like algorithm for finding our optimal solutions (shown as Algorithm 1 in the Appendix), but in principle the exact same solutions could be achieved by other optimization methods, such as encoding the problem as a binary integer program (BIP) and solving it in a way similar to Taskonomy (Zamir et al. (2018)).
+
+Most contemporary MTL works use fewer than 4 unique task types, but in principal, the NP-hard nature of the optimization problem does limit the number of candidate solutions that can be considered. However, using synthetic inputs, we found that our branch-and-bound like approach requires less time than network training for all $2 ^ { | \mathcal { T } | } - 1 + | \mathcal { T } |$ candidates for fewer than ten tasks. Scaling beyond that would require approximations or stronger optimization techniques.
+
+# 3.3 APPROXIMATIONS FOR REDUCING TRAINING TIME COMPLEXITY
+
+This section describes two techniques for reducing the training time required to obtain a collection of networks as input to the network selection algorithm. Our goal is to produce task groupings with results similar to the ones produced by the complete search, but with less training time burden. Both techniques involve predicting the performance of a network without actually training it to convergence. The first technique involves training each of the networks for a short amount of time, and the second involves inferring how networks trained on more than two tasks will perform based on how networks trained on two tasks perform.
+
+# 3.3.1 EARLY STOPPING PRIOR TO CONVERGENCE
+
+We found a moderately high correlation (Pearson’s $r = 0 . 4 9$ ) between the validation loss of our neural networks after a pass through just $20 \%$ of our data and the final test loss of the fully trained networks. This implies that the task relationship trends stabilize early. We fine that we can get decent results by running network selection on the lightly trained networks, and then simply training the chosen networks to convergence.
+
+For our setup, this technique reduces the training time burden by about $\mathbf { 2 0 x }$ over fully training all candiate networks and would require fewer than 150 GPU hours to execute. This is only $3 5 \%$ training-time overhead. Obviously, this technique does come with a prediction accuracy penalty. Because the correlation between early network performance and final network performance is not perfect, the decisions made by network selection are no longer guaranteed to be optimal once networks are trained to convergence. We call this approximation the Early Stopping Approximation (ESA) and present the results of using this technique in Section 5.
+
+# 3.3.2 PREDICT HIGHER-ORDER FROM LOWER-ORDER
+
+Do the performances of a network trained with tasks $A$ and $B$ , another trained with tasks $A$ and $C$ , and a third trained with tasks $B$ and $C$ tell us anything about the performance of a network trained on tasks $A , B$ , and $C 2$ As it turns out, the answer is yes. Although this ignores complex task interactions and nonlinearities, a simple average of the first-order networks’ accuracies was a good indicator of the accuracy of a higher-order network. Experimentally, this prediction strategy has an average max ratio error of only $5 . 2 \%$ on our candidate networks.
+
+Using this strategy, we can predict the performance of all networks with three or more tasks using the performance of all of the fully trained two task networks. First, simply train all networks with two or fewer tasks to convergence. Then predict the performance of higher-order networks. Finally, run network selection on both groups.
+
+With our setup (see Section 4), this strategy saves training time by only about $50 \%$ , compared with $9 5 \%$ for the early stopping approximation, and it still comes with a prediction quality penalty. However, this technique requires only a quadratic number of networks to be trained rather than an exponential number, and would therefore win out when the number of tasks is large.
+
+We call this strategy the Higher Order Approximation (HOA), and present its results in Section 5.
+
+# 4 EXPERIMENTAL SETUP
+
+We perform our evaluation using the Taskonomy dataset (Zamir et al. (2018)), which is currently the largest multi-task dataset in vision with diverse tasks. The data was obtained from 3D scans of about 600 buildings. There are 4,076,375 examples, which we divided into 3,974,199 training instances, 52,000 validation instances, and 50,176 test instances. There was no overlap in the buildings that appeared in the training and test sets. All data labels were normalized $( \bar { x } = 0 , \sigma = 1 _ { \cdot }$ ).
+
+Our framework is agnostic to the particular set of tasks. We have chosen to perform the study using five tasks in Taskonomy: Semantic Segmentation, Depth Estimation, Surface Normal Prediction, Keypoint Detection, and Edge Detection, so that one semantic task, two 3D tasks, and two 2D tasks are included. These tasks were chosen to be representative of major task categories, but also to have enough overlap in order to test the hypothesis that similar tasks will train well together. Crossentropy loss was used for Semantic Segmentation, while an $L 1$ loss was used for all other tasks.
+
+Network Architecture: The proposed framework can work with any network architecture. In our experiments, all of the networks used a standard encoder-decoder architecture with a modified Xception (Chollet (2017)) encoder. Our choice of architecture is not critical and was chosen for reasonably fast inference time performance. The Xception network encoder was simplified to have 17 layers and the middle flow layers were reduced to having 512 rather than 728 channels. All maxpooling layers were replaced by $2 \times 2$ convolution layers with a stride of 2 (similar to Chen et al. (2018a)). The full-size encoder had about 4 million parameters. All networks had an input image size of $2 5 6 \times 2 5 6$ . We measure inference time in units of the time taken to do inference for one of our full-size encoders. We call this a Standard Network Time (SNT). This corresponds to 2.28 billion multiply-adds and about 4 ms/image on a single Nvidia RTX 2080 Ti.
+
+Our decoders were designed to be lightweight and have four transposed convolutional layers (Noh et al. (2015)) and four separable convolutional layers (Chollet (2017)). Every decoder has about 116,000 parameters. All training was done using PyTorch (Paszke et al. (2017)) with Apex for fp16 acceleration (Micikevicius et al. (2017)).
+
+Trained Networks: As described in Section 3.1, we trained 31 networks with full sized encoders and standard decoders. 26 were multi-task networks and 5 were single task networks. Another five single-task networks were trained, each having a half-size encoder and a standard decoder. These 36 networks were included in network optimization as $C _ { 0 }$ . 20 smaller, single-task networks of various sizes were also trained to be used in the baselines and the analysis of Section 6, but not used for network selection. In order to produce our smaller models, we shrunk the number of channels in every layer of the encoder such that it had the appropriate number of parameters and flops.
+
+The training loss we used was the unweighted mean of the losses for the included tasks. Networks were trained with an initial learning rate of 0.2, which was reduced by half every time the training loss stopped decreasing. Networks were trained until their validation loss stopped improving, typically requiring only 4-8 passes through the dataset. The network with the highest validation loss (checked after each epoch of $20 \%$ of our data) was saved.
+
+The performance scores used for network selection were calculated on the validation set. We computed solutions for inference time budgets from 1 to 5 at increments of 0.5. Each solution chosen was evaluated on the test set.
+
+# 4.1 BASELINES
+
+We compare our results with conventional methods, such as five single-task networks and a single network with all tasks trained jointly.
+
+We also compare with two multi-task methods in the literature. The first one is Sener & Koltun (2018). We found that their algorithm under-weighted the Semantic Segmentation task too aggressively, leading to poor performance on the task and poor performance overall compared to a simple sum of task losses. We speculate that this is because semantic segmentation’s loss behaves differently from the other losses. Next we compared to GradNorm (Chen et al. (2018b)). The results here were also slightly worse than classical MTL with uniform task weights. In any event, these techniques are orthogonal to ours and can be used in conjunction for situations in which they lead to better solutions than simply summing losses.
+
+Finally, we compare our results to two control baselines illustrative of the importance of making good choices about which tasks to train together, ‘Random’ and ‘Pessimal.’ ‘Random’ is a solution consisting of valid random task groupings that solve our five tasks. The reported values are the average of a thousand random trials. ‘Pessimal’ is a solution in which we choose the networks that lead to the worst overall performance, though the solution’s performance on each task is still the best among its networks.
+
+Each baseline was evaluated with multiple encoder sizes so that all models’ results could be compared at many inference time budgets.
+
+# 5 TASK GROUPING EVALUATION
+
+![](images/02b7a48646178dc1eaa4711b44fc953ab060496da4cecf8e3a2af01b550e62e0.jpg)  
+Figure 2: The task groups picked by each of our techniques for integer budgets between 1 and 5. Networks are shown as $\bigcirc$ (full-size) or $^ { \circ }$ (half-size). Networks are connected to the tasks for which they compute predictions. s: Semantic Segmentation, d: Depth Estimation, n: Surface Normal Prediction, k: Keypoint Detection, e: Edge Detection. Dotted edges represent unused decoders. For example, the highlighted solution consists of two half-size networks and a full-size network. The full-size network solves Depth Estimation, Surface Normal Prediction, and Keypoint Detection. One half-size network solves Semantic Segmentation and the other solves Edge Detection. The total loss for all five tasks is 0.455. The groupings for fractional budgets are shown in the appendix.
+
+Figure 2 shows the task groups that were chosen for each technique, and Figure 3 shows the performance of these groups along with those of our baselines. We can see that each of our methods outperforms our traditional baselines for every computational budget.
+
+When the computational budget is only 1 SNT, all of our methods must select the same model—a traditional multi-task network with a 1 SNT encoder and five decoders. This strategy outperforms GradNorm, Sener & Koltun (2018), and individual training. However, solutions that utilize multiple networks outperform this traditional strategy for every budget $> 1 . 5 \AA$ —better performance can always be achieved by grouping tasks according to their compatibility.
+
+![](images/e28813e368d11f8dfa5ca1401089d7905ef527ad419262ec8382bc4277dba5a7.jpg)  
+Figure 4: Qualitative results for our baselines (left) and our techniques (right). All solutions allowed 2.5 SNT.
+
+When the computational budget is effectively unlimited (5 SNT), our optimal method picks five networks, each of which is used to make predictions for a separate task. However, three of the networks are trained with three tasks each, while only two are trained with one task each. This shows that the representations learned through multi-task learning were found to be best for three of our tasks (s, d, and e), whereas two of our tasks (n and k) are best solved individually.
+
+We also see that our optimal technique using 2.5 SNT and our Higher Order Ap
+
+![](images/d0265993941cadd0d77b1e9478821dc5365fc45ef6b8a21ca3360e3102ffb185.jpg)  
+Figure 3: The performance/inference time trade-off for various methods. Data presented tabularly in Table 7.
+
+proximation using 3.5 SNT can both outperform five individual networks (which uses 5 SNT).
+
+In order to determine how these task groupings generalize to other architectures, we retrained our best solution for 3 SNT using resnet18 (He et al. (2016)). The results in Table 1 suggest that good task groupings for one architecture are likely to be good in another, though to a lesser extent. Task affinities seem to be somewhat architecture-dependent, so for the very best results, task selection must be run for each architecture choice.
+
+Table 1: The performance of our best 3 SNT solution found using Xception but evaluated on ResNet18.   
+
+<table><tr><td>resnet18</td><td>Total Loss</td></tr><tr><td>All-in-one (triple-size resnet18) Five Individual (resnet18s .6-size each)</td><td>0.50925 0.53484</td></tr><tr><td>nKE, SDn,N(3 standard resnet18&#x27;s)</td><td>0.50658</td></tr></table>
+
+Figure 4 allows qualitative comparison between our methods and our baselines. We can see clear visual issues with each of our baselines that are not present in our methods. Both of our approximate methods produce predictions similar to the optimal task grouping.
+
+# 6 ANALYSES OF TASK RELATIONSHIPS
+
+The data generated by the above evaluation presents an opportunity to analyze how tasks interact in a multi-task setting, and allows us to compare with some of the vast body of research in transfer learning, such as Taskonomy (Zamir et al. (2018)).
+
+Table 2: The first-order multi-task learning relationships between tasks. The table lists the performance of every task when trained as a pair with every other task. For instance, when Depth is trained with SemSeg, SemSeg performs $4 . 1 7 \%$ better than when SemSeg is trained alone on a half-size network.   
+
+<table><tr><td></td><td></td><td colspan="6">Relative Performance On</td></tr><tr><td></td><td></td><td>SemSeg</td><td>Depth</td><td>Normals</td><td>Keypoints</td><td>Edges</td><td>Average</td></tr><tr><td></td><td>SemSeg</td><td>1</td><td>-5.41%</td><td>-11.29%</td><td>-4.32%</td><td>-34.64%</td><td>-13.92%</td></tr><tr><td>Ylrrrria</td><td>Depth</td><td>4.17%</td><td></td><td>-3.55%</td><td>3.49%</td><td>3.76%</td><td>1.97%</td></tr><tr><td></td><td>Normals</td><td>8.50%</td><td>2.48%</td><td></td><td>1.37%</td><td>12.33%</td><td>6.17%</td></tr><tr><td></td><td>Keypoints</td><td>4.82%</td><td>1.38%</td><td>-0.02%</td><td>1</td><td>-5.26%</td><td>0.23%</td></tr><tr><td></td><td>Edges</td><td>3.07%</td><td>-0.92%</td><td>-4.42%</td><td>1.37%</td><td></td><td>-0.23%</td></tr><tr><td></td><td>Average</td><td>5.14%</td><td>-0.62%</td><td>-4.82%</td><td>0.48%</td><td>-5.95%</td><td>-1.15%</td></tr></table>
+
+Table 3: The multi-task learning affinity between pairs of tasks. These values show the average change in the performance of two tasks when trained as a pair, relative to when they are trained separately.   
+
+<table><tr><td></td><td>Depth</td><td>Normals Keypoints</td><td></td><td>Edges</td></tr><tr><td>SemSeg</td><td>-0.62%</td><td>-1.39%</td><td>0.25%</td><td> -15.78%</td></tr><tr><td>Depth</td><td></td><td> -0.54%</td><td>2.43%</td><td>1.42%</td></tr><tr><td>Normals</td><td></td><td></td><td>0.67%</td><td>3.95%</td></tr><tr><td>Keypoints</td><td></td><td></td><td></td><td> -1.95%</td></tr></table>
+
+Table 4: The transfer learning affinities between pairs of tasks according to the authors of Taskonomy (Zamir et al. (2018)). Forward and backward transfer affinities are averaged.   
+
+<table><tr><td rowspan=1 colspan=5>Depth Normals KeypointsEdges</td></tr><tr><td rowspan=1 colspan=1>SemSeg</td><td rowspan=1 colspan=1>1.740</td><td rowspan=1 colspan=1>1.828</td><td rowspan=1 colspan=1>0.723</td><td rowspan=1 colspan=1>0.700</td></tr><tr><td rowspan=1 colspan=1>Depth</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>1.915</td><td rowspan=1 colspan=1>0.406</td><td rowspan=1 colspan=1>0.468</td></tr><tr><td rowspan=2 colspan=1>NormalsKeypoints</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>0.089</td><td rowspan=1 colspan=1>0.118</td></tr><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>0.232</td></tr></table>
+
+In order to determine the between task affinity for multi-task learning, we took the average of our first-order relationships matrix (Table 2) and its transpose. The result is shown in Table 3. The pair with the highest affinity by this metric are Surface Normal Prediction and 2D Edge Detection. Our two 3D tasks, Depth Estimation and Surface Normal Prediction, do not score highly on this similarity metric. This contrasts with the findings for transfer learning in Taskonomy (Table 4), in which they have the highest affinity. Our two 2D tasks also do not score highly. We speculate that the Normals task naturally preserves edges, while Depth and Normals (for example) don’t add much training signal to each other. See Section A.3 for more on factors that influence multi-task affinity.
+
+![](images/65f9aef382c36da74e4f67f37a68b3e938cefb3647f7e611ee89323cc67a8d82.jpg)  
+Multi-Task Affinity vs Transfer Affinity   
+Figure 5: Task affinities for multi-task learning vs. transfer learning. The correlation (Pearson’s $r _ { + }$ ) is $- 0 . 5 4$ , $p = 0 . 1 3$ . One outlier is removed.
+
+Figure 5 depicts the relationship between transfer learning affinities and multi-task affinities, which surprisingly seem to be negatively correlated in our high-data scenario. This suggests that it might be better to train dissimilar tasks together. This could be because dissimilar tasks are able to provide stronger and more meaningful regularization. More research is necessary to discover when and if this correlation and explanation hold.
+
+# 7 CONCLUSION
+
+We describe the problem of task compatibility as it pertains to multi-task learning. We provide an algorithm and computational framework for determining which tasks should be trained jointly and which tasks should be trained separately. Our solution can take advantage of situations in which joint training is beneficial to some tasks but not others in the same group. For many use cases, this framework is sufficient, but it can be costly at training time. Hence, we offer two strategies for coping with this issue and evaluate their performance. Our methods outperform single-task networks, a multi-task network with all tasks trained jointly, as well as other baselines. Finally, we use this opportunity to analyze how particular tasks interact in a multi-task setting and compare that with previous results on transfer learning task interactions.
+
+# REFERENCES
+
+Alessandro Achille, Michael Lam, Rahul Tewari, Avinash Ravichandran, Subhransu Maji, Charless Fowlkes, Stefano Soatto, and Pietro Perona. Task2Vec: Task Embedding for Meta-Learning. arXiv e-prints, art. arXiv:1902.03545, February 2019.
+
+Bowen Baker, Otkrist Gupta, Nikhil Naik, and Ramesh Raskar. Designing neural network architectures using reinforcement learning. International Conference on Learning Representations, 2017.
+
+Yoshua Bengio, Jerome Louradour, Ronan Collobert, and Jason Weston. Curriculum learning. In ˆ Proceedings of the 26th annual international conference on machine learning, pp. 41–48. ACM, 2009.
+
+Hakan Bilen and Andrea Vedaldi. Integrated perception with recurrent multi-task neural networks. In D. D. Lee, M. Sugiyama, U. V. Luxburg, I. Guyon, and R. Garnett (eds.), Advances in Neural Information Processing Systems 29, pp. 235– 243. Curran Associates, Inc., 2016. URL http://papers.nips.cc/paper/ 6393-integrated-perception-with-recurrent-multi-task-neural-networks. pdf.
+
+Joachim Bingel and Anders Søgaard. Identifying beneficial task relations for multi-task learning in deep neural networks. In Proceedings of the 15th Conference of the European Chapter of the Association for Computational Linguistics: Volume 2, Short Papers, pp. 164–169, Valencia, Spain, April 2017. Association for Computational Linguistics. URL https://www.aclweb. org/anthology/E17-2026.
+
+Rich Caruana. Multitask learning. Machine Learning, 28(1):41–75, Jul 1997. ISSN 1573-0565. doi: 10.1023/A:1007379606734. URL https://doi.org/10.1023/A:1007379606734.
+
+Liang-Chieh Chen, Yukun Zhu, George Papandreou, Florian Schroff, and Hartwig Adam. Encoderdecoder with atrous separable convolution for semantic image segmentation. In Computer Vision - ECCV 2018 - 15th European Conference, Munich, Germany, September 8-14, 2018, Proceedings, Part VII, pp. 833–851, 2018a. doi: 10.1007/978-3-030-01234-2\ 49. URL https://doi. org/10.1007/978-3-030-01234-2_49.
+
+Zhao Chen, Vijay Badrinarayanan, Chen-Yu Lee, and Andrew Rabinovich. Gradnorm: Gradient normalization for adaptive loss balancing in deep multitask networks. In Proceedings of the 35th International Conference on Machine Learning, ICML 2018, Stockholmsmassan, Stockholm,¨ Sweden, July 10-15, 2018, pp. 793–802, 2018b. URL http://proceedings.mlr.press/ v80/chen18a.html.
+
+Franc¸ois Chollet. Xception: Deep learning with depthwise separable convolutions. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 1251–1258, 2017.
+
+P. B. C. d. Miranda, R. B. C. Prudłncio, A. C. P. L. F. d. Carvalho, and C. Soares. Combining a multi-objective optimization approach with meta-learning for svm parameter selection. In 2012 IEEE International Conference on Systems, Man, and Cybernetics (SMC), pp. 2909–2914, Oct 2012. doi: 10.1109/ICSMC.2012.6378235.
+
+Jifeng Dai, Kaiming He, and Jian Sun. Instance-aware semantic segmentation via multi-task network cascades. 2016 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 3150– 3158, 2016.
+
+Carl Doersch and Andrew Zisserman. Multi-task self-supervised visual learning. In International Conference on Computer Vision, 2017.
+
+Long Duong, Trevor Cohn, Steven Bird, and Paul Cook. Low resource dependency parsing: Crosslingual parameter sharing in a neural network parser. In Proceedings of the 53rd Annual Meeting of the Association for Computational Linguistics and the 7th International Joint Conference on Natural Language Processing (Volume 2: Short Papers), pp. 845–850, July 2015.
+
+Nikita Dvornik, Konstantin Shmelkov, Julien Mairal, and Cordelia Schmid. BlitzNet: A real-time deep network for scene understanding. In IEEE International Conference on Computer Vision (ICCV), 2017.
+
+K. Dwivedi and G. Roig. Representation similarity analysis for efficient task taxonomy and transfer learning. In CVPR. IEEE Computer Society, 2019.
+
+Thomas Elsken, Jan Hendrik Metzen, and Frank Hutter. Efficient multi-objective neural architecture search via lamarckian evolution. In International Conference on Learning Representations, 2019. URL https://openreview.net/forum?id $=$ ByME42AqK7.
+
+Chrisantha Fernando, Dylan Banarse, Charles Blundell, Yori Zwols, David Ha, Andrei A. Rusu, Alexander Pritzel, and Daan Wierstra. Pathnet: Evolution channels gradient descent in super neural networks. CoRR, abs/1701.08734, 2017. URL http://arxiv.org/abs/1701. 08734.
+
+Chelsea Finn, Xin Yu Tan, Yan Duan, Trevor Darrell, Sergey Levine, and Pieter Abbeel. Deep spatial autoencoders for visuomotor learning. In Robotics and Automation (ICRA), 2016 IEEE International Conference on, pp. 512–519. IEEE, 2016.
+
+K. He, X. Zhang, S. Ren, and J. Sun. Deep residual learning for image recognition. In 2016 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 770–778, June 2016. doi: 10.1109/CVPR.2016.90.
+
+Thibault Helleputte and Pierre Dupont. Feature selection by transfer learning with linear regularized models. In Wray Buntine, Marko Grobelnik, Dunja Mladenic, and John Shawe-Taylor (eds.), ´ Machine Learning and Knowledge Discovery in Databases, pp. 533–547, Berlin, Heidelberg, 2009. Springer Berlin Heidelberg. ISBN 978-3-642-04180-8.
+
+Alex Kendall, Yarin Gal, and Roberto Cipolla. Multi-task learning using uncertainty to weigh losses for scene geometry and semantics. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2018.
+
+Iasonas Kokkinos. Ubernet: Training a universal convolutional neural network for low-, mid-, and high-level vision using diverse datasets and limited memory. In 2017 IEEE Conference on Computer Vision and Pattern Recognition, CVPR 2017, Honolulu, HI, USA, July 21-26, 2017, pp. 5454–5463, 2017. doi: 10.1109/CVPR.2017.579. URL https://doi.org/10.1109/ CVPR.2017.579.
+
+Chenxi Liu, Barret Zoph, Maxim Neumann, Jonathon Shlens, Wei Hua, Li-Jia Li, Li Fei-Fei, Alan Yuille, Jonathan Huang, and Kevin Murphy. Progressive neural architecture search. In Proceedings of the European Conference on Computer Vision (ECCV), pp. 19–34, 2018.
+
+Mingsheng Long, ZHANGJIE CAO, Jianmin Wang, and Philip S Yu. Learning multiple tasks with multilinear relationship networks. In I. Guyon, U. V. Luxburg, S. Bengio, H. Wallach, R. Fergus, S. Vishwanathan, and R. Garnett (eds.), Advances in Neural Information Processing Systems 30, pp. 1594–1603. Curran Associates, Inc., 2017. URL http://papers.nips.cc/paper/ 6757-learning-multiple-tasks-with-multilinear-relationship-networks. pdf.
+
+Yongxi Lu, Abhishek Kumar, Shuangfei Zhai, Yu Cheng, Tara Javidi, and Rogerio Schmidt Feris. ´ Fully-adaptive feature sharing in multi-task networks with applications in person attribute classification. In CVPR, pp. 1131–1140. IEEE Computer Society, 2017.
+
+Zelun Luo, Yuliang Zou, Judy Hoffman, and Li F Fei-Fei. Label efficient learning of transferable representations acrosss domains and tasks. In Advances in Neural Information Processing Systems, pp. 164–176, 2017.
+
+Arun Mallya and Svetlana Lazebnik. Piggyback: Adding multiple tasks to a single, fixed network by learning to mask. CoRR, abs/1801.06519, 2018. URL http://arxiv.org/abs/1801. 06519.
+
+Quentin Mercier, Fabrice Poirion, and Jean-Antoine Dsidri. A stochastic multiple gradient descent algorithm. European Journal of Operational Research, 271(3):808–817, 2018. doi: 10.1016/j.ejor.2018.05.06. URL https://ideas.repec.org/a/eee/ejores/ v271y2018i3p808-817.html.
+
+Paulius Micikevicius, Sharan Narang, Jonah Alben, Gregory Diamos, Erich Elsen, David Garcia, Boris Ginsburg, Michael Houston, Oleksii Kuchaiev, Ganesh Venkatesh, et al. Mixed precision training. arXiv preprint arXiv:1710.03740, 2017.
+
+Lilyana Mihalkova, Tuyen Huynh, and Raymond J Mooney. Mapping and revising markov logic networks for transfer learning. In AAAI, volume 7, pp. 608–614, 2007.
+
+Ishan Misra, Abhinav Shrivastava, Abhinav Gupta, and Martial Hebert. Cross-stitch networks for multi-task learning. 2016 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 3994–4003, 2016.
+
+Vladimir Nekrasov, Thanuja Dharmasiri, Andrew Spek, Tom Drummond, Chunhua Shen, and Ian D. Reid. Real-time joint semantic segmentation and depth estimation using asymmetric annotations. CoRR, abs/1809.04766, 2018. URL http://arxiv.org/abs/1809.04766.
+
+Alexandru Niculescu-Mizil and Rich Caruana. Inductive transfer for bayesian network structure learning. In Artificial Intelligence and Statistics, pp. 339–346, 2007.
+
+H. Noh, S. Hong, and B. Han. Learning deconvolution network for semantic segmentation. In 2015 IEEE International Conference on Computer Vision (ICCV), pp. 1520–1528, Dec 2015. doi: 10.1109/ICCV.2015.178.
+
+Arghya Pal and Vineeth N Balasubramanian. Zero-shot task transfer, 2019.
+
+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.
+
+Adam Paszke, Sam Gross, Soumith Chintala, Gregory Chanan, Edward Yang, Zachary DeVito, Zeming Lin, Alban Desmaison, Luca Antiga, and Adam Lerer. Automatic differentiation in pytorch. In NIPS-W, 2017.
+
+Anastasia Pentina and Christoph H. Lampert. Multi-task learning with labeled and unlabeled tasks. In Doina Precup and Yee Whye Teh (eds.), Proceedings of the 34th International Conference on Machine Learning, volume 70 of Proceedings of Machine Learning Research, pp. 2807–2816, International Convention Centre, Sydney, Australia, 06–11 Aug 2017. PMLR. URL http:// proceedings.mlr.press/v70/pentina17a.html.
+
+Hieu Pham, Melody Guan, Barret Zoph, Quoc V. Le, and Jeff Dean. Efficient neural architecture search via parameters sharing. 2018. URL http://proceedings.mlr.press/v80/ pham18a/pham18a.pdf.
+
+L. Y. Pratt. Discriminability-based transfer between neural networks. In S. J. Hanson, J. D. Cowan, and C. L. Giles (eds.), Advances in Neural Information Processing Systems 5, pp. 204–211. Morgan-Kaufmann, 1993. URL http://papers.nips.cc/paper/ 641-discriminability-based-transfer-between-neural-networks.pdf.
+
+Xiaojuan Qi, Renjie Liao, Zhengzhe Liu, Raquel Urtasun, and Jiaya Jia. Geonet: Geometric neural network for joint depth and surface normal estimation. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2018.
+
+Ali Sharif Razavian, Hossein Azizpour, Josephine Sullivan, and Stefan Carlsson. Cnn features off-the-shelf: An astounding baseline for recognition. In Proceedings of the 2014 IEEE Conference on Computer Vision and Pattern Recognition Workshops, CVPRW ’14, pp. 512– 519, Washington, DC, USA, 2014. IEEE Computer Society. ISBN 978-1-4799-4308-1. doi: 10.1109/CVPRW.2014.131. URL http://dx.doi.org.stanford.idm.oclc.org/ 10.1109/CVPRW.2014.131.
+
+Esteban Real, Alok Aggarwal, Yanping Huang, and Quoc V. Le. Regularized evolution for image classifier architecture search. 2018. URL https://arxiv.org/pdf/1802.01548.pdf.
+
+Ethan M. Rudd, Manuel Gunther, and Terrance E. Boult. MOON: A mixed objective optimization ¨ network for the recognition of facial attributes. In ECCV (5), volume 9909 of Lecture Notes in Computer Science, pp. 19–35. Springer, 2016.   
+Sebastian Ruder. An overview of multi-task learning in deep neural networks. CoRR, abs/1706.05098, 2017. URL http://arxiv.org/abs/1706.05098.   
+Andrei A. Rusu, Neil C. Rabinowitz, Guillaume Desjardins, Hubert Soyer, James Kirkpatrick, Koray Kavukcuoglu, Razvan Pascanu, and Raia Hadsell. Progressive neural networks. CoRR, abs/1606.04671, 2016. URL http://arxiv.org/abs/1606.04671.   
+Ozan Sener and Vladlen Koltun. Multi-task learning as multi-objective optimization. In S. Bengio, H. Wallach, H. Larochelle, K. Grauman, N. Cesa-Bianchi, and R. Garnett (eds.), Advances in Neural Information Processing Systems 31, pp. 525–536. Curran Associates, Inc., 2018. URL http://papers.nips.cc/paper/ 7334-multi-task-learning-as-multi-objective-optimization.pdf.   
+Daniel L Silver and Kristin P Bennett. Guest editors introduction: special issue on inductive transfer learning. Machine Learning, 73(3):215–220, 2008.   
+Chen Tessler, Shahar Givony, Tom Zahavy, Daniel J. Mankowitz, and Shie Mannor. A deep hierarchical approach to lifelong learning in minecraft. In Proceedings of the Thirty-First AAAI Conference on Artificial Intelligence, AAAI’17, pp. 1553–1561. AAAI Press, 2017. URL http:// dl.acm.org.stanford.idm.oclc.org/citation.cfm?id $=$ 3298239.3298465.   
+Sebastian Thrun. Is learning the n-th thing any easier than learning the first? In Advances in Neural Information Processing Systems, pp. 640–646. The MIT Press, 1996.   
+Aria Y Wang, Leila Wehbe, and Michael J Tarr. Neural taskonomy: Inferring the similarity of task-derived representations from brain activity. BioRxiv, pp. 708016, 2019.   
+Peng Wang, Xiaohui Shen, Bryan Russell, Scott Cohen, Brian Price, and Alan L Yuille. Surge: Surface regularized geometry estimation from a single image. In D. D. Lee, M. Sugiyama, U. V. Luxburg, I. Guyon, and R. Garnett (eds.), Advances in Neural Information Processing Systems 29, pp. 172–180. Curran Associates, Inc., 2016. URL http://papers.nips.cc/paper/ 6502-surge-surface-regularized-geometry-estimation-from-a-single-image. pdf.   
+Sirui Xie, Hehui Zheng, Chunxiao Liu, and Liang Lin. SNAS: stochastic neural architecture search. In International Conference on Learning Representations, 2019. URL https:// openreview.net/forum?id $=$ rylqooRqK7.   
+Yongxin Yang and Timothy Hospedales. Trace norm regularised deep multi-task learning. In 5th International Conference on Learning Representations Workshop, 2017.   
+Amir R. Zamir, Tilman Wekel, Pulkit Agrawal, Colin Wei, Jitendra Malik, and Silvio Savarese. Generic 3d representation via pose estimation and matching. In Bastian Leibe, Jiri Matas, Nicu Sebe, and Max Welling (eds.), Computer Vision – ECCV 2016, pp. 535–553, Cham, 2016. Springer International Publishing. ISBN 978-3-319-46487-9.   
+Amir R. Zamir, Alexander Sax, William B. Shen, Leonidas J. Guibas, Jitendra Malik, and Silvio Savarese. Taskonomy: Disentangling task transfer learning. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR). IEEE, 2018.   
+Zhenyu Zhang, Zhen Cui, Chunyan Xu, Yan Yan, Nicu Sebe, and Jian Yang. Pattern-affinitive propagation across depth, surface normal and semantic segmentation. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2019.   
+D. Zhou, J. Wang, B. Jiang, H. Guo, and Y. Li. Multi-task multi-view learning based on cooperative multi-objective optimization. IEEE Access, 6:19465–19477, 2018. ISSN 2169-3536. doi: 10. 1109/ACCESS.2017.2777888.
+
+Hongpeng Zhou, Minghao Yang, Jun Wang, and Wei Pan. BayesNAS: A Bayesian approach for neural architecture search. In Kamalika Chaudhuri and Ruslan Salakhutdinov (eds.), Proceedings of the 36th International Conference on Machine Learning, volume 97 of Proceedings of Machine Learning Research, pp. 7603–7613, Long Beach, California, USA, 09–15 Jun 2019. PMLR. URL http://proceedings.mlr.press/v97/zhou19e.html.
+
+Barret Zoph and Quoc V. Le. Neural architecture search with reinforcement learning. 2017. URL https://arxiv.org/abs/1611.01578.
+
+# A APPENDIX
+
+A.1 NETWORK SELECTION ALGORITHM
+
+<table><tr><td>Algorithm1 Get Best Networks</td></tr><tr><td>Input: Cr,a running set of candidate networks, each with an associated cost c E R and a perfor- mance score for each task the network solves. Initially,Cr = Co Input: Sr C Co,a running solution, initially O</td></tr><tr><td>Input: br ∈ R, the remaining time budget, initially b</td></tr><tr><td>1:function GETBESTNETWORKS(Cr,Sr, br)</td></tr><tr><td>2: Cr ←FILTER(Cr,Sr,br)</td></tr><tr><td>3: Cr ← SORT(Cr)</td></tr><tr><td>4: Best ←Sr</td></tr><tr><td>5: for n ∈ Cr do</td></tr><tr><td>6: Cr ←Cr\n</td></tr><tr><td>Si←SrU{n}</td></tr><tr><td>7: 8: bi←br-Cn 9:</td></tr><tr><td>Child ← GETBESTNETWORKS(Cr,Si,bi)</td></tr><tr><td>10: Best ←BETTER(Best,Child)</td></tr><tr><td>11: return Best</td></tr><tr><td>12: function FILTER(Cr,Sr, br)</td></tr><tr><td>13: Remove networks from Cr with Cn &gt; br.</td></tr><tr><td>14: Remove networks from Cr that cannot improve Sr&#x27;s performance on any task.</td></tr><tr><td>15: return Cr</td></tr><tr><td>16: function BETTER(S1, S2)</td></tr><tr><td>17: if C(Si)&lt;C(S2) then</td></tr><tr><td>18: return S1</td></tr><tr><td>19: else</td></tr><tr><td>20: return S2</td></tr></table>
+
+Algorithm 1 chooses the best subset of networks in our collection, subject to the inference time budget constraint. The algorithm recursively explores the space of solutions and prunes branches that cannot lead to optimal solutions. The recursion terminates when the budget is exhausted, at which point $C _ { r }$ becomes empty and the loop body does not execute.
+
+The sorting step on line 3 requires a heuristic upon which to sort. We found that ranking models based on how much they improve the current solution, $_ { s }$ , works well. It should be noted that this algorithm always produces an optimal solution, regardless of which sorting heuristic is used. However, better sorting heuristics reduce the running time because subsequent iterations will more readily detect and prune portions of the search space that cannot contain an optimal solution. In our setup, we tried variants of problems with 5 tasks and 36 networks, and all of them took less than a second to solve.
+
+The definition of the BETTER() function is application-specific. For our experiments, we prefer networks that have the lowest total loss across all five tasks. Other applications may have hard performance requirements for some of the tasks, and performance on one of these tasks cannot be sacrificed in order to achieve better performance on another task. Such application-specific constraints can be encoded in BETTER().
+
+# Average of five runs with 4 tasks each
+
+![](images/334b6a82ff346e4f0b00d8d5eb0b384afd57e483904a511e81c1993330394bb7.jpg)  
+Figure 6: Our experiments re-run on all 4-task subsets, then averaged.
+
+In order to determine how well network selection works for different task sets, we re-ran network selection on all five 4-task subsets of our task set. The performance average of all 5 sets is shown in Figure 6. We see that our techniques generalize at least to subsets of our studied tasks.
+
+The finding that Depth and Normals don’t cooperate is counter to much of the multitask learning literature such as Wang et al. (2016), Qi et al. (2018), and Zhang et al. (2019). However, the majority of these works use training sets with fewer than 100k instances, while we use nearly 4 mil
+
+Table 5: Positive task affinity between depth and normals in a low data setting.   
+
+<table><tr><td rowspan=1 colspan=1>100ktraininginstances</td><td rowspan=1 colspan=1>DepthTestLoss</td><td rowspan=1 colspan=1>NormalsTestLoss</td></tr><tr><td rowspan=1 colspan=1>Depth AloneNormals Alone</td><td rowspan=1 colspan=1>0.2651</td><td rowspan=1 colspan=1>=0.1398</td></tr><tr><td rowspan=1 colspan=1>Joint Depth + Normals</td><td rowspan=1 colspan=1>0.2525</td><td rowspan=1 colspan=1>0.1319</td></tr></table>
+
+lion training instances. Table 5 shows the loss obtained on our setup when we limit to only $1 0 0 \mathrm { k }$ training instances. The fact that task affinities can change depending on the amount of available training data demonstrates the necessity of using an empirical approach like ours for finding task affinities and groupings.
+
+A.4 TABULAR DATA   
+
+<table><tr><td></td><td>Ours Optimal</td><td>Single 20% pass 3.3.1</td><td>Higher Order 3.3.2</td></tr><tr><td>1</td><td>SDNKE</td><td>SDNKE</td><td>SDNKE</td></tr><tr><td>1.5</td><td>DNKE, S</td><td>SDNK,E</td><td>DNKE, S</td></tr><tr><td>2</td><td>nKE, SDN</td><td>SDke,NKE</td><td>DNK,E, S</td></tr><tr><td>2.5</td><td>nKE, SDn, N</td><td>SDke, nKE, N</td><td>DNK,E, Sn</td></tr><tr><td>3</td><td>nKE, SDn, N</td><td>SDne, sdke, NKE</td><td>DNK,E, Sn</td></tr><tr><td>3.5</td><td>nKE, Snk,Dnk, N</td><td>SDne, sdke, nKE, N</td><td>DnK,E, Sn, N</td></tr><tr><td>4</td><td>nKE, Snk,Dnk,N</td><td>SDne, sdke, nKE, N</td><td>Sn,DK,E, N</td></tr><tr><td>4.5</td><td>nKE,Snk,Dnk,N</td><td>sDne, sdke,nKE,N, Snk</td><td>Sn,E,K, Dn, N</td></tr><tr><td>5</td><td>nkE, Snk,Dnk,N,K</td><td>sDne, sdke, nKE,N, Snk</td><td>Sn,E, K,Dn, N</td></tr></table>
+
+Table 6: The task groups picked by each of our techniques for every budget choice between 1 and 5. Networks are shown as a list of letters corresponding to each task the network contains. S: Semantic Segmentation, D: Depth Estimation, N: Surface Normal Prediction, K: Keypoint Detection, E: Edge Detection. Capital letters denote that a solution used that network’s prediction for that task. Half-sized networks are shown in red.   
+
+<table><tr><td>Time Budget</td><td>1</td><td>1.5</td><td>2</td><td>2.5</td><td>3</td><td>3.5</td><td>4</td><td>4.5</td><td>5</td></tr><tr><td>Sener et al.</td><td>0.562</td><td></td><td>0.556</td><td>0.551</td><td></td><td></td><td>0.547</td><td></td><td></td></tr><tr><td>GradNorm</td><td>0.515</td><td></td><td></td><td></td><td></td><td></td><td>0.500</td><td></td><td></td></tr><tr><td>Pessimal Grouping</td><td>0.503</td><td>0.503</td><td>0.503</td><td>0.503</td><td>0.503</td><td>0.502</td><td>0.499</td><td></td><td>0.496 0.495</td></tr><tr><td>Traditional MTL</td><td>0.503</td><td></td><td>0.492</td><td>0.487</td><td></td><td></td><td>0.488</td><td></td><td></td></tr><tr><td>Random Groupings</td><td>0.503</td><td>0.483</td><td>0.475</td><td>0.471</td><td>0.467</td><td>0.464</td><td>0.462</td><td>0.460</td><td>0.459</td></tr><tr><td>Independent</td><td>0.515</td><td>0.501</td><td>0.477</td><td>0.465</td><td></td><td></td><td>0.454</td><td></td><td>0.448</td></tr><tr><td>Ours (ESA) 3.3.1</td><td>0.503</td><td>0.487</td><td>0.467</td><td>0.461</td><td>0.457</td><td>0.451</td><td>0.451</td><td>0.447</td><td>0.447</td></tr><tr><td>Ours (HOA) 3.3.2</td><td>0.503</td><td>0.461</td><td>0.455</td><td>0.451</td><td>0.449</td><td>0.445</td><td>0.444</td><td>0.445</td><td>0.442</td></tr><tr><td>Ours Optimal</td><td>0.503</td><td>0.461</td><td>0.452</td><td>0.446</td><td>0.442</td><td>0.439</td><td>0.436</td><td>0.436</td><td>0.435</td></tr></table>
+
+Table 7: The total test set loss on all five tasks for each method under each inference time budget. Lower is better. The data is the same as in Figures 3 and 2.
+
+<table><tr><td></td><td>SemSeg</td><td>Depth</td><td></td><td>Normals Keypoints</td><td>Edges</td></tr><tr><td>S</td><td>0.08039</td><td></td><td></td><td>一</td><td></td></tr><tr><td>D</td><td>1</td><td>0.1695</td><td></td><td></td><td></td></tr><tr><td>N</td><td>一</td><td>1</td><td>0.08591</td><td>一</td><td></td></tr><tr><td>K</td><td></td><td></td><td></td><td>0.0895</td><td>一</td></tr><tr><td>E</td><td></td><td></td><td>1</td><td>1</td><td>0.02783</td></tr><tr><td>SD</td><td>0.07858 0.1833</td><td></td><td>1</td><td>1</td><td>1</td></tr><tr><td>SN</td><td>0.074</td><td></td><td>0.0997</td><td>1</td><td></td></tr><tr><td>SK</td><td>0.07722</td><td></td><td></td><td>0.09718</td><td></td></tr><tr><td>SE</td><td>0.07897</td><td></td><td></td><td>1</td><td>0.04462</td></tr><tr><td>DN</td><td>1</td><td>0.1695</td><td>0.09275</td><td></td><td>一</td></tr><tr><td>DK</td><td></td><td>0.1706</td><td>一</td><td>0.09318</td><td>1</td></tr><tr><td>DE</td><td></td><td>0.1748</td><td></td><td>一</td><td>0.03192</td></tr><tr><td>NK</td><td></td><td></td><td>0.08968</td><td>0.09181</td><td></td></tr><tr><td>NE</td><td></td><td></td><td>0.09358</td><td></td><td>0.02908</td></tr><tr><td>KE</td><td></td><td></td><td></td><td>0.09185</td><td>0.03488</td></tr><tr><td>SDN</td><td>0.07498</td><td>0.1698</td><td>0.09575</td><td></td><td>1</td></tr><tr><td>SDK</td><td>0.07699</td><td>）0.1782</td><td></td><td>0.09704</td><td></td></tr><tr><td>SDE</td><td>0.07893</td><td>0.1863</td><td></td><td></td><td>0.04559</td></tr><tr><td>SNK</td><td>0.0722</td><td></td><td>0.09919</td><td>0.0961</td><td></td></tr><tr><td>SNE</td><td>0.07222</td><td></td><td>0.0982</td><td></td><td>0.03689</td></tr><tr><td>SKE</td><td>0.0766</td><td></td><td></td><td>0.09342</td><td>0.03508</td></tr><tr><td>DNK</td><td>1</td><td>0.1654</td><td>0.09358</td><td>0.09253</td><td>一</td></tr><tr><td>DNE</td><td></td><td>0.1708</td><td>0.09396</td><td>一</td><td>0.03286</td></tr><tr><td>DKE</td><td></td><td>0.1793</td><td></td><td>0.09073</td><td>0.02937</td></tr><tr><td>NKE</td><td></td><td></td><td>0.09626</td><td>0.09024</td><td>0.02609</td></tr><tr><td>SDNK</td><td>0.07762</td><td>0.1822</td><td>0.09869</td><td>0.1015</td><td>一</td></tr><tr><td>SDNE</td><td>0.07576</td><td>0.1735</td><td>0.09718</td><td>1</td><td>0.04513</td></tr><tr><td>SDKE</td><td>0.0795</td><td>0.1797</td><td></td><td>0.09272</td><td>0.04141</td></tr><tr><td>SNKE</td><td>0.07369</td><td></td><td>0.09944</td><td>0.09697</td><td>0.03312</td></tr><tr><td>DNKE</td><td></td><td>0.1708</td><td>0.09392</td><td>0.09334</td><td>0.02803</td></tr><tr><td>SDNKE</td><td>0.07854</td><td>0.1864</td><td>0.1</td><td>0.09814</td><td>0.04453</td></tr></table>
+
+Table 9: The test set performance of our 31 networks on each task that they solve.   
+
+<table><tr><td></td><td>SemSeg</td><td>Depth</td><td>Normals</td><td>sKeypoints</td><td>Edges</td></tr><tr><td>S</td><td>0.07662</td><td></td><td></td><td></td><td>1</td></tr><tr><td>D</td><td>1</td><td>0.1696</td><td></td><td></td><td></td></tr><tr><td>N</td><td></td><td>1</td><td>0.08555</td><td></td><td>1</td></tr><tr><td>K</td><td></td><td>一</td><td>1</td><td>0.08847</td><td>一</td></tr><tr><td>E</td><td></td><td>一</td><td></td><td>1</td><td>0.0275</td></tr><tr><td>SD</td><td>0.07419</td><td>0.1831</td><td>一</td><td></td><td>一</td></tr><tr><td>SN</td><td>0.07084</td><td>1</td><td>0.0994</td><td>1</td><td></td></tr><tr><td>SK</td><td>0.07369</td><td></td><td>1</td><td>0.09601</td><td></td></tr><tr><td>SE</td><td>0.07504</td><td></td><td></td><td>1</td><td>0.044</td></tr><tr><td>DN</td><td>1</td><td>0.1694 0.09249</td><td></td><td>1</td><td>1</td></tr><tr><td>DK</td><td></td><td>0.1713</td><td></td><td>0.08882</td><td>1</td></tr><tr><td>DE</td><td></td><td>0.1753</td><td></td><td></td><td>0.03145</td></tr><tr><td>NK</td><td></td><td>一</td><td>0.08934</td><td>0.09077</td><td></td></tr><tr><td>NE</td><td></td><td>1</td><td>0.09327</td><td></td><td>0.02865</td></tr><tr><td>KE</td><td></td><td></td><td></td><td>0.09077</td><td>0.0344</td></tr><tr><td>SDN</td><td>0.07193</td><td>0.17</td><td>0.09544</td><td>一</td><td>一</td></tr><tr><td>SDK</td><td>0.07311</td><td>0.1785</td><td></td><td>0.09591</td><td>一</td></tr><tr><td>SDE</td><td>0.07617</td><td>0.1865</td><td></td><td></td><td>0.04474</td></tr><tr><td>SNK</td><td>0.06933</td><td>一</td><td>0.09966</td><td>0.09302</td><td></td></tr><tr><td>SNE</td><td>0.06859</td><td></td><td>0.09796</td><td></td><td>0.03625</td></tr><tr><td>SKE</td><td>0.07323</td><td></td><td>1</td><td>0.09232</td><td>0.03463</td></tr><tr><td>DNK</td><td>1</td><td>0.1658</td><td>0.09318</td><td>0.09143</td><td>一</td></tr><tr><td>DNE</td><td></td><td>0.1706</td><td>0.09362</td><td></td><td>0.03239</td></tr><tr><td>DKE</td><td></td><td>0.1795</td><td></td><td>0.08968</td><td>0.02887</td></tr><tr><td>NKE</td><td></td><td></td><td>0.09596</td><td>0.08921</td><td>0.02566</td></tr><tr><td>SDNK</td><td>0.07338</td><td>0.1826</td><td>0.09836</td><td>0.1003</td><td></td></tr><tr><td>SDNE</td><td>0.07249</td><td>0.1739</td><td>0.09689</td><td>1</td><td>0.04441</td></tr><tr><td>SDKE</td><td>0.07634</td><td>0.1801</td><td></td><td>0.09157</td><td>0.04097</td></tr><tr><td>SNKE</td><td>0.07111</td><td></td><td>0.09941</td><td>0.09464</td><td>0.03328</td></tr><tr><td>DNKE</td><td></td><td>0.1704</td><td>0.09356</td><td>0.09226</td><td>0.02768</td></tr><tr><td>SDNKE</td><td>0.07603</td><td>0.186</td><td>0.09976</td><td>0.09704</td><td>0.04395</td></tr></table>

parse/train/HJlTpCEKvS/HJlTpCEKvS_content_list.json

@@ -0,0 +1,1721 @@
+[
+    {
+        "type": "text",
+        "text": "WHICH TASKS SHOULD BE LEARNED TOGETHER IN MULTI-TASK LEARNING? ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            823,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            184,
+            171,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            236,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Many computer vision applications require solving multiple tasks in real-time. A neural network can be trained to solve multiple tasks simultaneously using multitask learning. This saves computation at inference time as only a single network needs to be evaluated. Unfortunately, this often leads to inferior overall performance as task objectives can compete, which consequently poses the question: which tasks should and should not be learned together in one network when employing multi-task learning? We systematically study task cooperation and competition and propose a framework for assigning tasks to a few neural networks such that cooperating tasks are computed by the same neural network, while competing tasks are computed by different networks. Our framework offers a timeaccuracy trade-off and can produce better accuracy using less inference time than not only a single large multi-task neural network but also many single-task networks. ",
+        "bbox": [
+            233,
+            268,
+            764,
+            448
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            478,
+            336,
+            494
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Many applications, especially robotics and autonomous vehicles, are chiefly interested in using multi-task learning to reduce the inference time and computational complexity required to estimate many characteristics of visual input. For example, an autonomous vehicle may need to detect the location of pedestrians, determine a per-pixel depth, and predict objects’ trajectories, all within tens of milliseconds. In multi-task learning, multiple tasks are solved at the same time, typically with a single neural network. In addition to reduced inference time, solving a set of tasks jointly rather than independently can, in theory, have other benefits such as improved prediction accuracy, increased data efficiency, and reduced training time. ",
+        "bbox": [
+            174,
+            511,
+            825,
+            623
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Unfortunately, the quality of predictions are often observed to suffer when a network is tasked with making multiple predictions. This is because learning objectives can have complex and unknown dynamics and may compete. In fact, multi-task performance can suffer so much that smaller independent networks are often superior (as we will see in the experiments section). We refer to any situation in which the competing priorities of the network cause poor task performance as crosstalk. ",
+        "bbox": [
+            174,
+            630,
+            823,
+            700
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "On the other hand, when task objectives do not interfere much with each other, performance on both tasks can be maintained or even improved when jointly trained. Intuitively, this loss or gain of quality seems to depend on the relationship between the jointly trained tasks. ",
+        "bbox": [
+            176,
+            707,
+            823,
+            748
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Prior work has studied the relationship between tasks for transfer learning (Zamir et al. (2018)). However, we find that transfer relationships are not highly predictive of multi-task relationships. In addition to studying multi-task relationships, we attempt to determine how to produce good prediction accuracy under a limited inference time budget by assigning competing tasks to separate networks and cooperating tasks to the same network. ",
+        "bbox": [
+            174,
+            756,
+            823,
+            825
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "More concretely, this leads to the following problem: Given a set of tasks, $\\tau$ , and a computational budget $b$ (e.g., maximum allowable inference time), what is the optimal way to assign tasks to networks with combined cost $\\leq b$ such that a combined measure of task performances is maximized? ",
+        "bbox": [
+            176,
+            833,
+            825,
+            875
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "To this end, we develop a computational framework for choosing the best tasks to group together in order to have a small number of separate deep neural networks that completely cover the task set and that maximize task performance under a given computational budget. We make the intriguing observation that the inclusion of an additional task in a network can potentially improve the accuracy of the other tasks, even though the performance of the added task might be poor. This can be viewed as regularizing or guiding the loss of one task by adding an additional loss, as often employed in curriculum learning or network regularization Bengio et al. (2009). Achieving this, of course, depends on picking the proper regularizing task – our system can take advantage of this phenomenon, as schematically shown in Figure 1. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/6448c3fb14124b29746bb1a89bf07a2714b08ad13a7c8ec0b39edfa17bbeec5c.jpg",
+        "image_caption": [
+            "Figure 1: Given five tasks to solve, there are many ways that they can be split into task groups for multitask learning. How do we find the best one? We propose a computational framework that, for instance, suggests the following grouping to achieve the lowest total loss, using a computational budget of 2.5 units: train network A to solve Semantic Segmentation, Depth Estimation, and Surface Normal Prediction; train network B to solve Keypoint Detection, Edge Detection, and Surface Normal Prediction; train network C with a less computationally expensive encoder to solve Surface Normal Prediction alone; including Surface Normals as an output in the first two networks were found advantageous for improving the other outputs, while the best Normals were predicted by the third network. This task grouping outperforms all other feasible ones, including learning all five tasks in one large network or using five dedicated smaller networks. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            310,
+            83,
+            684,
+            198
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            337,
+            825,
+            421
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "This paper has two main contributions. In Section 3, we outline a framework for systematically assigning tasks to networks in order to achieve the best total prediction accuracy with a limited inference-time budget. We then analyze the resulting accuracy and show that selecting the best assignment of tasks to groups is critical for good performance. Secondly, in Section 6, we analyze situations in which multi-task learning helps and when it doesn’t, quantify the compatibilities of various task combinations for multi-task learning, compare them to the transfer learning task affinities, and discuss the implications. Moreover, we analyze the factors that influence multi-task affinities. ",
+        "bbox": [
+            174,
+            428,
+            825,
+            526
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 PRIOR WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            556,
+            318,
+            573
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Multi-Task Learning: See Ruder (2017) for a good overview of multi-task learning. The authors identify two clusters of contemporary techniques that we believe cover the space well, hard parameter sharing and soft parameter sharing. In brief, the primary difference between the majority of the existing works and our study is that we wish to understand the relationships between tasks and find compatible groupings of tasks for any given set of tasks, rather than designing a neural network architecture to solve a particular fixed set of tasks well. ",
+        "bbox": [
+            174,
+            595,
+            825,
+            679
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "A known contemporary example of hard parameter sharing in computer vision is UberNet (Kokkinos (2017)). The authors tackle 7 computer vision problems using hard parameter sharing. The authors focus on reducing the computational cost of training for hard parameter sharing, but experience a rapid degradation in performance as more tasks are added to the network. Hard parameter sharing is also used in many other works such as (Thrun (1996); Caruana (1997); Nekrasov et al. (2018); Dvornik et al. (2017); Kendall et al. (2018); Bilen & Vedaldi (2016); Pentina & Lampert (2017); Doersch & Zisserman (2017); Zamir et al. (2016); Long et al. (2017); Mercier et al. (2018); d. Miranda et al. (2012); Zhou et al. (2018); Rudd et al. (2016)). ",
+        "bbox": [
+            174,
+            686,
+            825,
+            799
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Other works, such as (Sener & Koltun (2018)) and (Chen et al. (2018b)), aim to dynamically reweight each task’s loss during training. The former work finds weights that provably lead to a Pareto-optimal solution, while the latter attempts to find weights that balance the influence of each task on network weights. Finally, (Bingel & Søgaard (2017)) studies task interaction for NLP. ",
+        "bbox": [
+            174,
+            804,
+            823,
+            861
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In soft or partial parameter sharing, either there is a separate set of parameters per task, or a significant fraction of the parameters are unshared. The models are tied together either by information sharing or by requiring parameters to be similar. Examples include (Dai et al. (2016); Duong et al. (2015); Misra et al. (2016); Tessler et al. (2017); Yang & Hospedales (2017); Lu et al. (2017)). ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The canonical example of soft parameter sharing can be seen in (Duong et al. (2015)). The authors are interested in designing a deep dependency parser for languages such as Irish that do not have much treebank data available. They tie the weights of two networks together by adding an L2 distance penalty between corresponding weights and show substantial improvement. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            160
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Another example of soft parameter sharing is Cross-stitch Networks (Misra et al. (2016)). Starting with separate networks for two tasks, the authors add ‘cross-stitch units’ between them, which allow each network to peek at the other network’s hidden layers. This approach reduces but does not eliminate task interfearence, and the overall performance is less sensitive to the relative loss weights. ",
+        "bbox": [
+            174,
+            166,
+            825,
+            223
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Unlike our method, none of the aforementioned works attempt to discover good groups of tasks to train together. Also, soft parameter sharing does not reduce inference time, a major goal of ours. ",
+        "bbox": [
+            173,
+            229,
+            821,
+            257
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Transfer Learning: Transfer learning (Pratt (1993); Helleputte & Dupont (2009); Silver & Bennett (2008); Finn et al. (2016); Mihalkova et al. (2007); Niculescu-Mizil & Caruana (2007); Luo et al. (2017); Razavian et al. (2014); Pan & Yang (2010); Mallya & Lazebnik (2018); Fernando et al. (2017); Rusu et al. (2016)) is similar to multi-task learning in that solutions are learned for multiple tasks. Unlike multi-task learning, however, transfer learning methods often assume that a model for a source task is given and then adapt that model to a target task. Transfer learning methods generally neither seek any benefit for source tasks nor a reduction in inference time as their main objective. ",
+        "bbox": [
+            174,
+            263,
+            825,
+            362
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Neural Architecture Search (NAS): Many recent works search the space of deep learning architectures to find ones that perform well (Zoph & Le, 2017; Liu et al., 2018; Pham et al., 2018; Xie et al., 2019; Elsken et al., 2019; Zhou et al., 2019; Baker et al., 2017; Real et al., 2018). This is related to our work as we search the space of task groupings. Just as with NAS, the found task groupings often perform better than human-engineered ones. ",
+        "bbox": [
+            174,
+            369,
+            825,
+            439
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Task Relationships: Our work is most related to Taskonomy (Zamir et al. (2018)), where the authors studied the relationships between visual tasks for transfer learning and introduced a dataset with over 4 million images and corresponding labels for 26 tasks. This was followed by a number of recent works, which further analyzed task relationships (Pal & Balasubramanian (2019); Dwivedi & Roig. (2019); Achille et al. (2019); Wang et al. (2019)) for transfer learning. While they extract relationships between these tasks for transfer learning, we are interested in the multi-task learning setting. Interestingly, we find notable differences between transfer task affinity and multi-task affinity. Their method also differs in that they are interested in labeled-data efficiency and not inference-time efficiency. Finally, the transfer quantification approach taken by Taskonomy (readout functions) is only capable of finding relationships between the high-level bottleneck representations developed for each task, whereas structural similarities between tasks at all levels are potentially relevant for multi-task learning. ",
+        "bbox": [
+            173,
+            445,
+            825,
+            613
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 TASK GROUPING FRAMEWORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            638,
+            464,
+            655
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our goal is to find an assignment of tasks to networks that results in the best overall loss. Our strategy is to select from a large set of candidate networks to include in our final solution. ",
+        "bbox": [
+            174,
+            675,
+            823,
+            703
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We define the problem as follows: We want to minimize the overall loss on a set of tasks $\\tau =$ $\\{ t _ { 1 } , t _ { 2 } , . . . , t _ { k } \\}$ given a limited inference time budget, $b$ , which is the total amount of time we have to complete all tasks. Each neural network that solves some subset of $\\tau$ and that could potentially be a part of the final solution is denoted by $n$ . It has an associated inference time cost, $c _ { n }$ , and a loss for each task, $\\mathcal { L } ( n , t _ { i } )$ (which is $\\infty$ for each task the network does not attempt to solve). A solution $\\pmb { S }$ is a set of networks that together solve all tasks. The computational cost of a solution is $\\begin{array} { r } { \\mathrm { c o s t } ( { \\pmb S } ) = \\sum _ { n \\in { \\pmb S } } c _ { n } } \\end{array}$ . The loss of a solution on a task, $\\boldsymbol { \\mathcal { L } } ( S , t _ { i } )$ , is the lowest loss on that task among the solution’s networks1, $\\begin{array} { r } { \\mathcal { L } ( S , t _ { i } ) = \\operatorname* { m i n } _ { n \\in S } \\mathcal { L } ( n , t _ { i } ) } \\end{array}$ . The overall performance for a solution is $\\begin{array} { r } { \\mathbf { \\mathcal { L } } ( S ) = \\sum _ { t _ { i } \\in \\mathcal { T } } \\mathcal { L } ( S , t _ { i } ) } \\end{array}$ . ",
+        "bbox": [
+            174,
+            709,
+            825,
+            840
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We want to find the solution with the lowest overall loss and a cost that is under our budget, $\\boldsymbol { S } _ { b } =$ argmin $\\begin{array}{c} S { \\mathrm { : c o s t } } ( S ) { \\le } b  \\end{array} . \\mathcal { L } ( S )$ . ",
+        "bbox": [
+            176,
+            844,
+            821,
+            875
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 WHICH CANDIDATE NETWORKS TO CONSIDER? ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            547,
+            117
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For a given task set $\\tau$ , we wish to determine not just how well each pair of tasks performs when trained together, but also how well each combination of tasks performs together so that we can capture higher-order task relationships. To that end, our candidate set of networks contains all $2 ^ { | \\mathcal { T } | } - 1$ possible groupings: $\\binom { | \\mathcal { T } | } { 1 }$ networks with one task, $\\binom { | \\mathcal { T } | } { 2 }$ networks with two tasks, $\\binom { | \\mathcal { T } | } { 3 }$ networks with three tasks, etc. For the five tasks we use in our experiments, this is 31 networks, of which five are single-task networks. ",
+        "bbox": [
+            174,
+            131,
+            825,
+            217
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The size of the networks is another design choice, and to somewhat explore its effects we also include 5 single task networks each with half of the computational cost of a standard network. This brings our total up to 36 networks. ",
+        "bbox": [
+            174,
+            224,
+            825,
+            266
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 NETWORK SELECTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            289,
+            370,
+            303
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Consider the situation in which we have an initial candidate set $C _ { 0 } = \\{ n _ { 1 } , n _ { 2 } , . . . , n _ { m } \\}$ of fullytrained networks that each solve some subset of our task set $\\tau$ . Our goal is to choose a subset of $C _ { 0 }$ that solve all the tasks with total inference time under budget $b$ and the lowest overall loss. More formally, we want to find a solution $\\begin{array} { r } { S _ { b } = \\operatorname * { a r g m i n } _ { S \\subseteq C _ { 0 } : \\operatorname { c o s t } ( S ) \\leq b } { \\mathcal { L } } ( S ) } \\end{array}$ . ",
+        "bbox": [
+            174,
+            315,
+            825,
+            375
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "It can be shown that solving this problem is NP-hard in general (reduction from SET-COVER). However, many techniques exist that can optimally solve most reasonably-sized instances of problems like these in acceptable amounts of time. All of these techniques produce the same solutions. We chose to use a branch-and-bound-like algorithm for finding our optimal solutions (shown as Algorithm 1 in the Appendix), but in principle the exact same solutions could be achieved by other optimization methods, such as encoding the problem as a binary integer program (BIP) and solving it in a way similar to Taskonomy (Zamir et al. (2018)). ",
+        "bbox": [
+            174,
+            380,
+            825,
+            478
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Most contemporary MTL works use fewer than 4 unique task types, but in principal, the NP-hard nature of the optimization problem does limit the number of candidate solutions that can be considered. However, using synthetic inputs, we found that our branch-and-bound like approach requires less time than network training for all $2 ^ { | \\mathcal { T } | } - 1 + | \\mathcal { T } |$ candidates for fewer than ten tasks. Scaling beyond that would require approximations or stronger optimization techniques. ",
+        "bbox": [
+            174,
+            484,
+            825,
+            556
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.3 APPROXIMATIONS FOR REDUCING TRAINING TIME COMPLEXITY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            577,
+            666,
+            592
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "This section describes two techniques for reducing the training time required to obtain a collection of networks as input to the network selection algorithm. Our goal is to produce task groupings with results similar to the ones produced by the complete search, but with less training time burden. Both techniques involve predicting the performance of a network without actually training it to convergence. The first technique involves training each of the networks for a short amount of time, and the second involves inferring how networks trained on more than two tasks will perform based on how networks trained on two tasks perform. ",
+        "bbox": [
+            174,
+            606,
+            825,
+            703
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.3.1 EARLY STOPPING PRIOR TO CONVERGENCE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            723,
+            534,
+            737
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We found a moderately high correlation (Pearson’s $r = 0 . 4 9$ ) between the validation loss of our neural networks after a pass through just $20 \\%$ of our data and the final test loss of the fully trained networks. This implies that the task relationship trends stabilize early. We fine that we can get decent results by running network selection on the lightly trained networks, and then simply training the chosen networks to convergence. ",
+        "bbox": [
+            174,
+            750,
+            825,
+            819
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For our setup, this technique reduces the training time burden by about $\\mathbf { 2 0 x }$ over fully training all candiate networks and would require fewer than 150 GPU hours to execute. This is only $3 5 \\%$ training-time overhead. Obviously, this technique does come with a prediction accuracy penalty. Because the correlation between early network performance and final network performance is not perfect, the decisions made by network selection are no longer guaranteed to be optimal once networks are trained to convergence. We call this approximation the Early Stopping Approximation (ESA) and present the results of using this technique in Section 5. ",
+        "bbox": [
+            174,
+            825,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.3.2 PREDICT HIGHER-ORDER FROM LOWER-ORDER",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            565,
+            118
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Do the performances of a network trained with tasks $A$ and $B$ , another trained with tasks $A$ and $C$ , and a third trained with tasks $B$ and $C$ tell us anything about the performance of a network trained on tasks $A , B$ , and $C 2$ As it turns out, the answer is yes. Although this ignores complex task interactions and nonlinearities, a simple average of the first-order networks’ accuracies was a good indicator of the accuracy of a higher-order network. Experimentally, this prediction strategy has an average max ratio error of only $5 . 2 \\%$ on our candidate networks. ",
+        "bbox": [
+            174,
+            128,
+            825,
+            212
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Using this strategy, we can predict the performance of all networks with three or more tasks using the performance of all of the fully trained two task networks. First, simply train all networks with two or fewer tasks to convergence. Then predict the performance of higher-order networks. Finally, run network selection on both groups. ",
+        "bbox": [
+            174,
+            219,
+            823,
+            275
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "With our setup (see Section 4), this strategy saves training time by only about $50 \\%$ , compared with $9 5 \\%$ for the early stopping approximation, and it still comes with a prediction quality penalty. However, this technique requires only a quadratic number of networks to be trained rather than an exponential number, and would therefore win out when the number of tasks is large. ",
+        "bbox": [
+            176,
+            282,
+            823,
+            338
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We call this strategy the Higher Order Approximation (HOA), and present its results in Section 5. ",
+        "bbox": [
+            173,
+            344,
+            808,
+            359
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTAL SETUP ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            382,
+            398,
+            397
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We perform our evaluation using the Taskonomy dataset (Zamir et al. (2018)), which is currently the largest multi-task dataset in vision with diverse tasks. The data was obtained from 3D scans of about 600 buildings. There are 4,076,375 examples, which we divided into 3,974,199 training instances, 52,000 validation instances, and 50,176 test instances. There was no overlap in the buildings that appeared in the training and test sets. All data labels were normalized $( \\bar { x } = 0 , \\sigma = 1 _ { \\cdot }$ ). ",
+        "bbox": [
+            174,
+            415,
+            825,
+            484
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Our framework is agnostic to the particular set of tasks. We have chosen to perform the study using five tasks in Taskonomy: Semantic Segmentation, Depth Estimation, Surface Normal Prediction, Keypoint Detection, and Edge Detection, so that one semantic task, two 3D tasks, and two 2D tasks are included. These tasks were chosen to be representative of major task categories, but also to have enough overlap in order to test the hypothesis that similar tasks will train well together. Crossentropy loss was used for Semantic Segmentation, while an $L 1$ loss was used for all other tasks. ",
+        "bbox": [
+            174,
+            491,
+            825,
+            575
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Network Architecture: The proposed framework can work with any network architecture. In our experiments, all of the networks used a standard encoder-decoder architecture with a modified Xception (Chollet (2017)) encoder. Our choice of architecture is not critical and was chosen for reasonably fast inference time performance. The Xception network encoder was simplified to have 17 layers and the middle flow layers were reduced to having 512 rather than 728 channels. All maxpooling layers were replaced by $2 \\times 2$ convolution layers with a stride of 2 (similar to Chen et al. (2018a)). The full-size encoder had about 4 million parameters. All networks had an input image size of $2 5 6 \\times 2 5 6$ . We measure inference time in units of the time taken to do inference for one of our full-size encoders. We call this a Standard Network Time (SNT). This corresponds to 2.28 billion multiply-adds and about 4 ms/image on a single Nvidia RTX 2080 Ti. ",
+        "bbox": [
+            173,
+            582,
+            825,
+            722
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Our decoders were designed to be lightweight and have four transposed convolutional layers (Noh et al. (2015)) and four separable convolutional layers (Chollet (2017)). Every decoder has about 116,000 parameters. All training was done using PyTorch (Paszke et al. (2017)) with Apex for fp16 acceleration (Micikevicius et al. (2017)). ",
+        "bbox": [
+            174,
+            728,
+            825,
+            784
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Trained Networks: As described in Section 3.1, we trained 31 networks with full sized encoders and standard decoders. 26 were multi-task networks and 5 were single task networks. Another five single-task networks were trained, each having a half-size encoder and a standard decoder. These 36 networks were included in network optimization as $C _ { 0 }$ . 20 smaller, single-task networks of various sizes were also trained to be used in the baselines and the analysis of Section 6, but not used for network selection. In order to produce our smaller models, we shrunk the number of channels in every layer of the encoder such that it had the appropriate number of parameters and flops. ",
+        "bbox": [
+            174,
+            790,
+            825,
+            888
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The training loss we used was the unweighted mean of the losses for the included tasks. Networks were trained with an initial learning rate of 0.2, which was reduced by half every time the training loss stopped decreasing. Networks were trained until their validation loss stopped improving, typically requiring only 4-8 passes through the dataset. The network with the highest validation loss (checked after each epoch of $20 \\%$ of our data) was saved. ",
+        "bbox": [
+            176,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The performance scores used for network selection were calculated on the validation set. We computed solutions for inference time budgets from 1 to 5 at increments of 0.5. Each solution chosen was evaluated on the test set. ",
+        "bbox": [
+            176,
+            152,
+            821,
+            194
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 BASELINES",
+        "text_level": 1,
+        "bbox": [
+            174,
+            215,
+            294,
+            229
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We compare our results with conventional methods, such as five single-task networks and a single network with all tasks trained jointly. ",
+        "bbox": [
+            178,
+            243,
+            823,
+            271
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We also compare with two multi-task methods in the literature. The first one is Sener & Koltun (2018). We found that their algorithm under-weighted the Semantic Segmentation task too aggressively, leading to poor performance on the task and poor performance overall compared to a simple sum of task losses. We speculate that this is because semantic segmentation’s loss behaves differently from the other losses. Next we compared to GradNorm (Chen et al. (2018b)). The results here were also slightly worse than classical MTL with uniform task weights. In any event, these techniques are orthogonal to ours and can be used in conjunction for situations in which they lead to better solutions than simply summing losses. ",
+        "bbox": [
+            174,
+            277,
+            825,
+            390
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Finally, we compare our results to two control baselines illustrative of the importance of making good choices about which tasks to train together, ‘Random’ and ‘Pessimal.’ ‘Random’ is a solution consisting of valid random task groupings that solve our five tasks. The reported values are the average of a thousand random trials. ‘Pessimal’ is a solution in which we choose the networks that lead to the worst overall performance, though the solution’s performance on each task is still the best among its networks. ",
+        "bbox": [
+            174,
+            396,
+            825,
+            479
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Each baseline was evaluated with multiple encoder sizes so that all models’ results could be compared at many inference time budgets. ",
+        "bbox": [
+            174,
+            487,
+            823,
+            515
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 TASK GROUPING EVALUATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            539,
+            460,
+            555
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/02b7a48646178dc1eaa4711b44fc953ab060496da4cecf8e3a2af01b550e62e0.jpg",
+        "image_caption": [
+            "Figure 2: The task groups picked by each of our techniques for integer budgets between 1 and 5. Networks are shown as $\\bigcirc$ (full-size) or $^ { \\circ }$ (half-size). Networks are connected to the tasks for which they compute predictions. s: Semantic Segmentation, d: Depth Estimation, n: Surface Normal Prediction, k: Keypoint Detection, e: Edge Detection. Dotted edges represent unused decoders. For example, the highlighted solution consists of two half-size networks and a full-size network. The full-size network solves Depth Estimation, Surface Normal Prediction, and Keypoint Detection. One half-size network solves Semantic Segmentation and the other solves Edge Detection. The total loss for all five tasks is 0.455. The groupings for fractional budgets are shown in the appendix. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            498,
+            569,
+            823,
+            770
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Figure 2 shows the task groups that were chosen for each technique, and Figure 3 shows the performance of these groups along with those of our baselines. We can see that each of our methods outperforms our traditional baselines for every computational budget. ",
+        "bbox": [
+            176,
+            803,
+            820,
+            844
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "When the computational budget is only 1 SNT, all of our methods must select the same model—a traditional multi-task network with a 1 SNT encoder and five decoders. This strategy outperforms GradNorm, Sener & Koltun (2018), and individual training. However, solutions that utilize multiple networks outperform this traditional strategy for every budget $> 1 . 5 \\AA$ —better performance can always be achieved by grouping tasks according to their compatibility. ",
+        "bbox": [
+            174,
+            851,
+            823,
+            921
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/e28813e368d11f8dfa5ca1401089d7905ef527ad419262ec8382bc4277dba5a7.jpg",
+        "image_caption": [
+            "Figure 4: Qualitative results for our baselines (left) and our techniques (right). All solutions allowed 2.5 SNT. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            200,
+            88,
+            790,
+            386
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "When the computational budget is effectively unlimited (5 SNT), our optimal method picks five networks, each of which is used to make predictions for a separate task. However, three of the networks are trained with three tasks each, while only two are trained with one task each. This shows that the representations learned through multi-task learning were found to be best for three of our tasks (s, d, and e), whereas two of our tasks (n and k) are best solved individually. ",
+        "bbox": [
+            174,
+            412,
+            450,
+            579
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We also see that our optimal technique using 2.5 SNT and our Higher Order Ap",
+        "bbox": [
+            174,
+            587,
+            452,
+            614
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/d0265993941cadd0d77b1e9478821dc5365fc45ef6b8a21ca3360e3102ffb185.jpg",
+        "image_caption": [
+            "Figure 3: The performance/inference time trade-off for various methods. Data presented tabularly in Table 7. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            473,
+            412,
+            813,
+            568
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "proximation using 3.5 SNT can both outperform five individual networks (which uses 5 SNT). ",
+        "bbox": [
+            166,
+            614,
+            790,
+            628
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In order to determine how these task groupings generalize to other architectures, we retrained our best solution for 3 SNT using resnet18 (He et al. (2016)). The results in Table 1 suggest that good task groupings for one architecture are likely to be good in another, though to a lesser extent. Task affinities seem to be somewhat architecture-dependent, so for the very best results, task selection must be run for each architecture choice. ",
+        "bbox": [
+            174,
+            636,
+            483,
+            747
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/631f386ef2c6331d1dcf8f4dda4f857d2ee923390c16b1de6d2510902b4ed89b.jpg",
+        "table_caption": [
+            "Table 1: The performance of our best 3 SNT solution found using Xception but evaluated on ResNet18. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>resnet18</td><td>Total Loss</td></tr><tr><td>All-in-one (triple-size resnet18) Five Individual (resnet18s .6-size each)</td><td>0.50925 0.53484</td></tr><tr><td>nKE, SDn,N(3 standard resnet18&#x27;s)</td><td>0.50658</td></tr></table>",
+        "bbox": [
+            496,
+            646,
+            833,
+            700
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            747,
+            614,
+            761
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Figure 4 allows qualitative comparison between our methods and our baselines. We can see clear visual issues with each of our baselines that are not present in our methods. Both of our approximate methods produce predictions similar to the optimal task grouping. ",
+        "bbox": [
+            174,
+            767,
+            826,
+            810
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "6 ANALYSES OF TASK RELATIONSHIPS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            842,
+            513,
+            857
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The data generated by the above evaluation presents an opportunity to analyze how tasks interact in a multi-task setting, and allows us to compare with some of the vast body of research in transfer learning, such as Taskonomy (Zamir et al. (2018)). ",
+        "bbox": [
+            174,
+            878,
+            825,
+            921
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/f1c7fbcf7f1bf900883474a3d92b68802174d93f50894692dac9b064e6dc84d6.jpg",
+        "table_caption": [
+            "Table 2: The first-order multi-task learning relationships between tasks. The table lists the performance of every task when trained as a pair with every other task. For instance, when Depth is trained with SemSeg, SemSeg performs $4 . 1 7 \\%$ better than when SemSeg is trained alone on a half-size network. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td></td><td colspan=\"6\">Relative Performance On</td></tr><tr><td></td><td></td><td>SemSeg</td><td>Depth</td><td>Normals</td><td>Keypoints</td><td>Edges</td><td>Average</td></tr><tr><td></td><td>SemSeg</td><td>1</td><td>-5.41%</td><td>-11.29%</td><td>-4.32%</td><td>-34.64%</td><td>-13.92%</td></tr><tr><td>Ylrrrria</td><td>Depth</td><td>4.17%</td><td></td><td>-3.55%</td><td>3.49%</td><td>3.76%</td><td>1.97%</td></tr><tr><td></td><td>Normals</td><td>8.50%</td><td>2.48%</td><td></td><td>1.37%</td><td>12.33%</td><td>6.17%</td></tr><tr><td></td><td>Keypoints</td><td>4.82%</td><td>1.38%</td><td>-0.02%</td><td>1</td><td>-5.26%</td><td>0.23%</td></tr><tr><td></td><td>Edges</td><td>3.07%</td><td>-0.92%</td><td>-4.42%</td><td>1.37%</td><td></td><td>-0.23%</td></tr><tr><td></td><td>Average</td><td>5.14%</td><td>-0.62%</td><td>-4.82%</td><td>0.48%</td><td>-5.95%</td><td>-1.15%</td></tr></table>",
+        "bbox": [
+            228,
+            101,
+            767,
+            194
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/6a61e427b6271135426ef1f04066ab8163539e5375012d30f73152ee64f7b436.jpg",
+        "table_caption": [
+            "Table 3: The multi-task learning affinity between pairs of tasks. These values show the average change in the performance of two tasks when trained as a pair, relative to when they are trained separately. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>Depth</td><td>Normals Keypoints</td><td></td><td>Edges</td></tr><tr><td>SemSeg</td><td>-0.62%</td><td>-1.39%</td><td>0.25%</td><td> -15.78%</td></tr><tr><td>Depth</td><td></td><td> -0.54%</td><td>2.43%</td><td>1.42%</td></tr><tr><td>Normals</td><td></td><td></td><td>0.67%</td><td>3.95%</td></tr><tr><td>Keypoints</td><td></td><td></td><td></td><td> -1.95%</td></tr></table>",
+        "bbox": [
+            174,
+            265,
+            488,
+            342
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/e762f22244c268a6267ce554b232b958eff0e0c7cea3ef731672ad40efc83c1d.jpg",
+        "table_caption": [
+            "Table 4: The transfer learning affinities between pairs of tasks according to the authors of Taskonomy (Zamir et al. (2018)). Forward and backward transfer affinities are averaged. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=5>Depth Normals KeypointsEdges</td></tr><tr><td rowspan=1 colspan=1>SemSeg</td><td rowspan=1 colspan=1>1.740</td><td rowspan=1 colspan=1>1.828</td><td rowspan=1 colspan=1>0.723</td><td rowspan=1 colspan=1>0.700</td></tr><tr><td rowspan=1 colspan=1>Depth</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>1.915</td><td rowspan=1 colspan=1>0.406</td><td rowspan=1 colspan=1>0.468</td></tr><tr><td rowspan=2 colspan=1>NormalsKeypoints</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>0.089</td><td rowspan=1 colspan=1>0.118</td></tr><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>0.232</td></tr></table>",
+        "bbox": [
+            509,
+            265,
+            794,
+            342
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In order to determine the between task affinity for multi-task learning, we took the average of our first-order relationships matrix (Table 2) and its transpose. The result is shown in Table 3. The pair with the highest affinity by this metric are Surface Normal Prediction and 2D Edge Detection. Our two 3D tasks, Depth Estimation and Surface Normal Prediction, do not score highly on this similarity metric. This contrasts with the findings for transfer learning in Taskonomy (Table 4), in which they have the highest affinity. Our two 2D tasks also do not score highly. We speculate that the Normals task naturally preserves edges, while Depth and Normals (for example) don’t add much training signal to each other. See Section A.3 for more on factors that influence multi-task affinity. ",
+        "bbox": [
+            174,
+            438,
+            483,
+            645
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/65f9aef382c36da74e4f67f37a68b3e938cefb3647f7e611ee89323cc67a8d82.jpg",
+        "image_caption": [
+            "Multi-Task Affinity vs Transfer Affinity ",
+            "Figure 5: Task affinities for multi-task learning vs. transfer learning. The correlation (Pearson’s $r _ { + }$ ) is $- 0 . 5 4$ , $p = 0 . 1 3$ . One outlier is removed. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            506,
+            438,
+            815,
+            571
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            169,
+            645,
+            761,
+            659
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Figure 5 depicts the relationship between transfer learning affinities and multi-task affinities, which surprisingly seem to be negatively correlated in our high-data scenario. This suggests that it might be better to train dissimilar tasks together. This could be because dissimilar tasks are able to provide stronger and more meaningful regularization. More research is necessary to discover when and if this correlation and explanation hold. ",
+        "bbox": [
+            173,
+            666,
+            825,
+            736
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "7 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            762,
+            318,
+            779
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We describe the problem of task compatibility as it pertains to multi-task learning. We provide an algorithm and computational framework for determining which tasks should be trained jointly and which tasks should be trained separately. Our solution can take advantage of situations in which joint training is beneficial to some tasks but not others in the same group. For many use cases, this framework is sufficient, but it can be costly at training time. Hence, we offer two strategies for coping with this issue and evaluate their performance. Our methods outperform single-task networks, a multi-task network with all tasks trained jointly, as well as other baselines. Finally, we use this opportunity to analyze how particular tasks interact in a multi-task setting and compare that with previous results on transfer learning task interactions. ",
+        "bbox": [
+            173,
+            797,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            287,
+            117
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Alessandro Achille, Michael Lam, Rahul Tewari, Avinash Ravichandran, Subhransu Maji, Charless Fowlkes, Stefano Soatto, and Pietro Perona. Task2Vec: Task Embedding for Meta-Learning. arXiv e-prints, art. arXiv:1902.03545, February 2019. ",
+        "bbox": [
+            176,
+            127,
+            821,
+            170
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Bowen Baker, Otkrist Gupta, Nikhil Naik, and Ramesh Raskar. Designing neural network architectures using reinforcement learning. International Conference on Learning Representations, 2017. ",
+        "bbox": [
+            174,
+            180,
+            825,
+            222
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yoshua Bengio, Jerome Louradour, Ronan Collobert, and Jason Weston. Curriculum learning. In ˆ Proceedings of the 26th annual international conference on machine learning, pp. 41–48. ACM, 2009. ",
+        "bbox": [
+            174,
+            233,
+            825,
+            276
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Hakan Bilen and Andrea Vedaldi. Integrated perception with recurrent multi-task neural networks. In D. D. Lee, M. Sugiyama, U. V. Luxburg, I. Guyon, and R. Garnett (eds.), Advances in Neural Information Processing Systems 29, pp. 235– 243. Curran Associates, Inc., 2016. URL http://papers.nips.cc/paper/ 6393-integrated-perception-with-recurrent-multi-task-neural-networks. pdf. ",
+        "bbox": [
+            173,
+            287,
+            869,
+            371
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Joachim Bingel and Anders Søgaard. Identifying beneficial task relations for multi-task learning in deep neural networks. In Proceedings of the 15th Conference of the European Chapter of the Association for Computational Linguistics: Volume 2, Short Papers, pp. 164–169, Valencia, Spain, April 2017. Association for Computational Linguistics. URL https://www.aclweb. org/anthology/E17-2026. ",
+        "bbox": [
+            173,
+            382,
+            826,
+            453
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Rich Caruana. Multitask learning. Machine Learning, 28(1):41–75, Jul 1997. ISSN 1573-0565. doi: 10.1023/A:1007379606734. URL https://doi.org/10.1023/A:1007379606734. ",
+        "bbox": [
+            173,
+            463,
+            825,
+            493
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Liang-Chieh Chen, Yukun Zhu, George Papandreou, Florian Schroff, and Hartwig Adam. Encoderdecoder with atrous separable convolution for semantic image segmentation. In Computer Vision - ECCV 2018 - 15th European Conference, Munich, Germany, September 8-14, 2018, Proceedings, Part VII, pp. 833–851, 2018a. doi: 10.1007/978-3-030-01234-2\\ 49. URL https://doi. org/10.1007/978-3-030-01234-2_49. ",
+        "bbox": [
+            173,
+            503,
+            825,
+            574
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Zhao Chen, Vijay Badrinarayanan, Chen-Yu Lee, and Andrew Rabinovich. Gradnorm: Gradient normalization for adaptive loss balancing in deep multitask networks. In Proceedings of the 35th International Conference on Machine Learning, ICML 2018, Stockholmsmassan, Stockholm,¨ Sweden, July 10-15, 2018, pp. 793–802, 2018b. URL http://proceedings.mlr.press/ v80/chen18a.html. ",
+        "bbox": [
+            173,
+            585,
+            825,
+            656
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Franc¸ois Chollet. Xception: Deep learning with depthwise separable convolutions. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 1251–1258, 2017. ",
+        "bbox": [
+            171,
+            666,
+            823,
+            696
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "P. B. C. d. Miranda, R. B. C. Prudłncio, A. C. P. L. F. d. Carvalho, and C. Soares. Combining a multi-objective optimization approach with meta-learning for svm parameter selection. In 2012 IEEE International Conference on Systems, Man, and Cybernetics (SMC), pp. 2909–2914, Oct 2012. doi: 10.1109/ICSMC.2012.6378235. ",
+        "bbox": [
+            173,
+            705,
+            825,
+            762
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jifeng Dai, Kaiming He, and Jian Sun. Instance-aware semantic segmentation via multi-task network cascades. 2016 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 3150– 3158, 2016. ",
+        "bbox": [
+            173,
+            773,
+            826,
+            816
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Carl Doersch and Andrew Zisserman. Multi-task self-supervised visual learning. In International Conference on Computer Vision, 2017. ",
+        "bbox": [
+            169,
+            827,
+            825,
+            857
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Long Duong, Trevor Cohn, Steven Bird, and Paul Cook. Low resource dependency parsing: Crosslingual parameter sharing in a neural network parser. In Proceedings of the 53rd Annual Meeting of the Association for Computational Linguistics and the 7th International Joint Conference on Natural Language Processing (Volume 2: Short Papers), pp. 845–850, July 2015. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Nikita Dvornik, Konstantin Shmelkov, Julien Mairal, and Cordelia Schmid. BlitzNet: A real-time deep network for scene understanding. In IEEE International Conference on Computer Vision (ICCV), 2017. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "K. Dwivedi and G. Roig. Representation similarity analysis for efficient task taxonomy and transfer learning. In CVPR. IEEE Computer Society, 2019. ",
+        "bbox": [
+            173,
+            156,
+            821,
+            185
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Thomas Elsken, Jan Hendrik Metzen, and Frank Hutter. Efficient multi-objective neural architecture search via lamarckian evolution. In International Conference on Learning Representations, 2019. URL https://openreview.net/forum?id $=$ ByME42AqK7. ",
+        "bbox": [
+            174,
+            195,
+            825,
+            239
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Chrisantha Fernando, Dylan Banarse, Charles Blundell, Yori Zwols, David Ha, Andrei A. Rusu, Alexander Pritzel, and Daan Wierstra. Pathnet: Evolution channels gradient descent in super neural networks. CoRR, abs/1701.08734, 2017. URL http://arxiv.org/abs/1701. 08734. ",
+        "bbox": [
+            173,
+            250,
+            825,
+            306
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Chelsea Finn, Xin Yu Tan, Yan Duan, Trevor Darrell, Sergey Levine, and Pieter Abbeel. Deep spatial autoencoders for visuomotor learning. In Robotics and Automation (ICRA), 2016 IEEE International Conference on, pp. 512–519. IEEE, 2016. ",
+        "bbox": [
+            174,
+            316,
+            825,
+            361
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "K. He, X. Zhang, S. Ren, and J. Sun. Deep residual learning for image recognition. In 2016 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 770–778, June 2016. doi: 10.1109/CVPR.2016.90. ",
+        "bbox": [
+            173,
+            369,
+            825,
+            412
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Thibault Helleputte and Pierre Dupont. Feature selection by transfer learning with linear regularized models. In Wray Buntine, Marko Grobelnik, Dunja Mladenic, and John Shawe-Taylor (eds.), ´ Machine Learning and Knowledge Discovery in Databases, pp. 533–547, Berlin, Heidelberg, 2009. Springer Berlin Heidelberg. ISBN 978-3-642-04180-8. ",
+        "bbox": [
+            173,
+            424,
+            825,
+            481
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alex Kendall, Yarin Gal, and Roberto Cipolla. Multi-task learning using uncertainty to weigh losses for scene geometry and semantics. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2018. ",
+        "bbox": [
+            174,
+            491,
+            825,
+            535
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Iasonas Kokkinos. Ubernet: Training a universal convolutional neural network for low-, mid-, and high-level vision using diverse datasets and limited memory. In 2017 IEEE Conference on Computer Vision and Pattern Recognition, CVPR 2017, Honolulu, HI, USA, July 21-26, 2017, pp. 5454–5463, 2017. doi: 10.1109/CVPR.2017.579. URL https://doi.org/10.1109/ CVPR.2017.579. ",
+        "bbox": [
+            173,
+            545,
+            825,
+            614
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Chenxi Liu, Barret Zoph, Maxim Neumann, Jonathon Shlens, Wei Hua, Li-Jia Li, Li Fei-Fei, Alan Yuille, Jonathan Huang, and Kevin Murphy. Progressive neural architecture search. In Proceedings of the European Conference on Computer Vision (ECCV), pp. 19–34, 2018. ",
+        "bbox": [
+            176,
+            626,
+            825,
+            670
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Mingsheng Long, ZHANGJIE CAO, Jianmin Wang, and Philip S Yu. Learning multiple tasks with multilinear relationship networks. In I. Guyon, U. V. Luxburg, S. Bengio, H. Wallach, R. Fergus, S. Vishwanathan, and R. Garnett (eds.), Advances in Neural Information Processing Systems 30, pp. 1594–1603. Curran Associates, Inc., 2017. URL http://papers.nips.cc/paper/ 6757-learning-multiple-tasks-with-multilinear-relationship-networks. pdf. ",
+        "bbox": [
+            173,
+            678,
+            859,
+            763
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yongxi Lu, Abhishek Kumar, Shuangfei Zhai, Yu Cheng, Tara Javidi, and Rogerio Schmidt Feris. ´ Fully-adaptive feature sharing in multi-task networks with applications in person attribute classification. In CVPR, pp. 1131–1140. IEEE Computer Society, 2017. ",
+        "bbox": [
+            174,
+            773,
+            826,
+            818
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Zelun Luo, Yuliang Zou, Judy Hoffman, and Li F Fei-Fei. Label efficient learning of transferable representations acrosss domains and tasks. In Advances in Neural Information Processing Systems, pp. 164–176, 2017. ",
+        "bbox": [
+            173,
+            828,
+            825,
+            871
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Arun Mallya and Svetlana Lazebnik. Piggyback: Adding multiple tasks to a single, fixed network by learning to mask. CoRR, abs/1801.06519, 2018. URL http://arxiv.org/abs/1801. 06519. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            922
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Quentin Mercier, Fabrice Poirion, and Jean-Antoine Dsidri. A stochastic multiple gradient descent algorithm. European Journal of Operational Research, 271(3):808–817, 2018. doi: 10.1016/j.ejor.2018.05.06. URL https://ideas.repec.org/a/eee/ejores/ v271y2018i3p808-817.html. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            160
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Paulius Micikevicius, Sharan Narang, Jonah Alben, Gregory Diamos, Erich Elsen, David Garcia, Boris Ginsburg, Michael Houston, Oleksii Kuchaiev, Ganesh Venkatesh, et al. Mixed precision training. arXiv preprint arXiv:1710.03740, 2017. ",
+        "bbox": [
+            173,
+            167,
+            823,
+            210
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Lilyana Mihalkova, Tuyen Huynh, and Raymond J Mooney. Mapping and revising markov logic networks for transfer learning. In AAAI, volume 7, pp. 608–614, 2007. ",
+        "bbox": [
+            173,
+            219,
+            823,
+            248
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ishan Misra, Abhinav Shrivastava, Abhinav Gupta, and Martial Hebert. Cross-stitch networks for multi-task learning. 2016 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 3994–4003, 2016. ",
+        "bbox": [
+            173,
+            256,
+            823,
+            299
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Vladimir Nekrasov, Thanuja Dharmasiri, Andrew Spek, Tom Drummond, Chunhua Shen, and Ian D. Reid. Real-time joint semantic segmentation and depth estimation using asymmetric annotations. CoRR, abs/1809.04766, 2018. URL http://arxiv.org/abs/1809.04766. ",
+        "bbox": [
+            173,
+            306,
+            825,
+            349
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alexandru Niculescu-Mizil and Rich Caruana. Inductive transfer for bayesian network structure learning. In Artificial Intelligence and Statistics, pp. 339–346, 2007. ",
+        "bbox": [
+            173,
+            357,
+            823,
+            387
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "H. Noh, S. Hong, and B. Han. Learning deconvolution network for semantic segmentation. In 2015 IEEE International Conference on Computer Vision (ICCV), pp. 1520–1528, Dec 2015. doi: 10.1109/ICCV.2015.178. ",
+        "bbox": [
+            174,
+            395,
+            825,
+            438
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Arghya Pal and Vineeth N Balasubramanian. Zero-shot task transfer, 2019. ",
+        "bbox": [
+            174,
+            445,
+            666,
+            462
+        ],
+        "page_idx": 10
+    },
+    {
+        "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": [
+            173,
+            469,
+            820,
+            498
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Adam Paszke, Sam Gross, Soumith Chintala, Gregory Chanan, Edward Yang, Zachary DeVito, Zeming Lin, Alban Desmaison, Luca Antiga, and Adam Lerer. Automatic differentiation in pytorch. In NIPS-W, 2017. ",
+        "bbox": [
+            176,
+            506,
+            823,
+            549
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Anastasia Pentina and Christoph H. Lampert. Multi-task learning with labeled and unlabeled tasks. In Doina Precup and Yee Whye Teh (eds.), Proceedings of the 34th International Conference on Machine Learning, volume 70 of Proceedings of Machine Learning Research, pp. 2807–2816, International Convention Centre, Sydney, Australia, 06–11 Aug 2017. PMLR. URL http:// proceedings.mlr.press/v70/pentina17a.html. ",
+        "bbox": [
+            174,
+            558,
+            825,
+            628
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Hieu Pham, Melody Guan, Barret Zoph, Quoc V. Le, and Jeff Dean. Efficient neural architecture search via parameters sharing. 2018. URL http://proceedings.mlr.press/v80/ pham18a/pham18a.pdf. ",
+        "bbox": [
+            174,
+            636,
+            825,
+            679
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "L. Y. Pratt. Discriminability-based transfer between neural networks. In S. J. Hanson, J. D. Cowan, and C. L. Giles (eds.), Advances in Neural Information Processing Systems 5, pp. 204–211. Morgan-Kaufmann, 1993. URL http://papers.nips.cc/paper/ 641-discriminability-based-transfer-between-neural-networks.pdf. ",
+        "bbox": [
+            173,
+            686,
+            825,
+            743
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Xiaojuan Qi, Renjie Liao, Zhengzhe Liu, Raquel Urtasun, and Jiaya Jia. Geonet: Geometric neural network for joint depth and surface normal estimation. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2018. ",
+        "bbox": [
+            176,
+            751,
+            821,
+            795
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ali Sharif Razavian, Hossein Azizpour, Josephine Sullivan, and Stefan Carlsson. Cnn features off-the-shelf: An astounding baseline for recognition. In Proceedings of the 2014 IEEE Conference on Computer Vision and Pattern Recognition Workshops, CVPRW ’14, pp. 512– 519, Washington, DC, USA, 2014. IEEE Computer Society. ISBN 978-1-4799-4308-1. doi: 10.1109/CVPRW.2014.131. URL http://dx.doi.org.stanford.idm.oclc.org/ 10.1109/CVPRW.2014.131. ",
+        "bbox": [
+            174,
+            803,
+            825,
+            887
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Esteban Real, Alok Aggarwal, Yanping Huang, and Quoc V. Le. Regularized evolution for image classifier architecture search. 2018. URL https://arxiv.org/pdf/1802.01548.pdf. ",
+        "bbox": [
+            173,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ethan M. Rudd, Manuel Gunther, and Terrance E. Boult. MOON: A mixed objective optimization ¨ network for the recognition of facial attributes. In ECCV (5), volume 9909 of Lecture Notes in Computer Science, pp. 19–35. Springer, 2016.   \nSebastian Ruder. An overview of multi-task learning in deep neural networks. CoRR, abs/1706.05098, 2017. URL http://arxiv.org/abs/1706.05098.   \nAndrei A. Rusu, Neil C. Rabinowitz, Guillaume Desjardins, Hubert Soyer, James Kirkpatrick, Koray Kavukcuoglu, Razvan Pascanu, and Raia Hadsell. Progressive neural networks. CoRR, abs/1606.04671, 2016. URL http://arxiv.org/abs/1606.04671.   \nOzan Sener and Vladlen Koltun. Multi-task learning as multi-objective optimization. In S. Bengio, H. Wallach, H. Larochelle, K. Grauman, N. Cesa-Bianchi, and R. Garnett (eds.), Advances in Neural Information Processing Systems 31, pp. 525–536. Curran Associates, Inc., 2018. URL http://papers.nips.cc/paper/ 7334-multi-task-learning-as-multi-objective-optimization.pdf.   \nDaniel L Silver and Kristin P Bennett. Guest editors introduction: special issue on inductive transfer learning. Machine Learning, 73(3):215–220, 2008.   \nChen Tessler, Shahar Givony, Tom Zahavy, Daniel J. Mankowitz, and Shie Mannor. A deep hierarchical approach to lifelong learning in minecraft. In Proceedings of the Thirty-First AAAI Conference on Artificial Intelligence, AAAI’17, pp. 1553–1561. AAAI Press, 2017. URL http:// dl.acm.org.stanford.idm.oclc.org/citation.cfm?id $=$ 3298239.3298465.   \nSebastian Thrun. Is learning the n-th thing any easier than learning the first? In Advances in Neural Information Processing Systems, pp. 640–646. The MIT Press, 1996.   \nAria Y Wang, Leila Wehbe, and Michael J Tarr. Neural taskonomy: Inferring the similarity of task-derived representations from brain activity. BioRxiv, pp. 708016, 2019.   \nPeng Wang, Xiaohui Shen, Bryan Russell, Scott Cohen, Brian Price, and Alan L Yuille. Surge: Surface regularized geometry estimation from a single image. In D. D. Lee, M. Sugiyama, U. V. Luxburg, I. Guyon, and R. Garnett (eds.), Advances in Neural Information Processing Systems 29, pp. 172–180. Curran Associates, Inc., 2016. URL http://papers.nips.cc/paper/ 6502-surge-surface-regularized-geometry-estimation-from-a-single-image. pdf.   \nSirui Xie, Hehui Zheng, Chunxiao Liu, and Liang Lin. SNAS: stochastic neural architecture search. In International Conference on Learning Representations, 2019. URL https:// openreview.net/forum?id $=$ rylqooRqK7.   \nYongxin Yang and Timothy Hospedales. Trace norm regularised deep multi-task learning. In 5th International Conference on Learning Representations Workshop, 2017.   \nAmir R. Zamir, Tilman Wekel, Pulkit Agrawal, Colin Wei, Jitendra Malik, and Silvio Savarese. Generic 3d representation via pose estimation and matching. In Bastian Leibe, Jiri Matas, Nicu Sebe, and Max Welling (eds.), Computer Vision – ECCV 2016, pp. 535–553, Cham, 2016. Springer International Publishing. ISBN 978-3-319-46487-9.   \nAmir R. Zamir, Alexander Sax, William B. Shen, Leonidas J. Guibas, Jitendra Malik, and Silvio Savarese. Taskonomy: Disentangling task transfer learning. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR). IEEE, 2018.   \nZhenyu Zhang, Zhen Cui, Chunyan Xu, Yan Yan, Nicu Sebe, and Jian Yang. Pattern-affinitive propagation across depth, surface normal and semantic segmentation. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2019.   \nD. Zhou, J. Wang, B. Jiang, H. Guo, and Y. Li. Multi-task multi-view learning based on cooperative multi-objective optimization. IEEE Access, 6:19465–19477, 2018. ISSN 2169-3536. doi: 10. 1109/ACCESS.2017.2777888. ",
+        "bbox": [
+            166,
+            97,
+            892,
+            926
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Hongpeng Zhou, Minghao Yang, Jun Wang, and Wei Pan. BayesNAS: A Bayesian approach for neural architecture search. In Kamalika Chaudhuri and Ruslan Salakhutdinov (eds.), Proceedings of the 36th International Conference on Machine Learning, volume 97 of Proceedings of Machine Learning Research, pp. 7603–7613, Long Beach, California, USA, 09–15 Jun 2019. PMLR. URL http://proceedings.mlr.press/v97/zhou19e.html. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Barret Zoph and Quoc V. Le. Neural architecture search with reinforcement learning. 2017. URL https://arxiv.org/abs/1611.01578. ",
+        "bbox": [
+            176,
+            185,
+            823,
+            213
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            242,
+            297,
+            257
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A.1 NETWORK SELECTION ALGORITHM ",
+        "bbox": [
+            176,
+            273,
+            467,
+            289
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/c9dc35b6ad0f4bbac691c7afd4e51526a980a3342851bb0f7077097b6f4f5a12.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Algorithm1 Get Best Networks</td></tr><tr><td>Input: Cr,a running set of candidate networks, each with an associated cost c E R and a perfor- mance score for each task the network solves. Initially,Cr = Co Input: Sr C Co,a running solution, initially O</td></tr><tr><td>Input: br ∈ R, the remaining time budget, initially b</td></tr><tr><td>1:function GETBESTNETWORKS(Cr,Sr, br)</td></tr><tr><td>2: Cr ←FILTER(Cr,Sr,br)</td></tr><tr><td>3: Cr ← SORT(Cr)</td></tr><tr><td>4: Best ←Sr</td></tr><tr><td>5: for n ∈ Cr do</td></tr><tr><td>6: Cr ←Cr\\n</td></tr><tr><td>Si←SrU{n}</td></tr><tr><td>7: 8: bi←br-Cn 9:</td></tr><tr><td>Child ← GETBESTNETWORKS(Cr,Si,bi)</td></tr><tr><td>10: Best ←BETTER(Best,Child)</td></tr><tr><td>11: return Best</td></tr><tr><td>12: function FILTER(Cr,Sr, br)</td></tr><tr><td>13: Remove networks from Cr with Cn &gt; br.</td></tr><tr><td>14: Remove networks from Cr that cannot improve Sr&#x27;s performance on any task.</td></tr><tr><td>15: return Cr</td></tr><tr><td>16: function BETTER(S1, S2)</td></tr><tr><td>17: if C(Si)&lt;C(S2) then</td></tr><tr><td>18: return S1</td></tr><tr><td>19: else</td></tr><tr><td>20: return S2</td></tr></table>",
+        "bbox": [
+            176,
+            303,
+            826,
+            712
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 chooses the best subset of networks in our collection, subject to the inference time budget constraint. The algorithm recursively explores the space of solutions and prunes branches that cannot lead to optimal solutions. The recursion terminates when the budget is exhausted, at which point $C _ { r }$ becomes empty and the loop body does not execute. ",
+        "bbox": [
+            174,
+            728,
+            823,
+            784
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The sorting step on line 3 requires a heuristic upon which to sort. We found that ranking models based on how much they improve the current solution, $_ { s }$ , works well. It should be noted that this algorithm always produces an optimal solution, regardless of which sorting heuristic is used. However, better sorting heuristics reduce the running time because subsequent iterations will more readily detect and prune portions of the search space that cannot contain an optimal solution. In our setup, we tried variants of problems with 5 tasks and 36 networks, and all of them took less than a second to solve. ",
+        "bbox": [
+            174,
+            791,
+            825,
+            888
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The definition of the BETTER() function is application-specific. For our experiments, we prefer networks that have the lowest total loss across all five tasks. Other applications may have hard performance requirements for some of the tasks, and performance on one of these tasks cannot be sacrificed in order to achieve better performance on another task. Such application-specific constraints can be encoded in BETTER(). ",
+        "bbox": [
+            174,
+            895,
+            823,
+            922
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            146
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Average of five runs with 4 tasks each ",
+        "text_level": 1,
+        "bbox": [
+            232,
+            141,
+            607,
+            160
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/334b6a82ff346e4f0b00d8d5eb0b384afd57e483904a511e81c1993330394bb7.jpg",
+        "image_caption": [
+            "Figure 6: Our experiments re-run on all 4-task subsets, then averaged. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            232,
+            152,
+            754,
+            299
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "In order to determine how well network selection works for different task sets, we re-ran network selection on all five 4-task subsets of our task set. The performance average of all 5 sets is shown in Figure 6. We see that our techniques generalize at least to subsets of our studied tasks. ",
+        "bbox": [
+            174,
+            358,
+            825,
+            401
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "The finding that Depth and Normals don’t cooperate is counter to much of the multitask learning literature such as Wang et al. (2016), Qi et al. (2018), and Zhang et al. (2019). However, the majority of these works use training sets with fewer than 100k instances, while we use nearly 4 mil",
+        "bbox": [
+            173,
+            128,
+            450,
+            227
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "table",
+        "img_path": "images/02051f66fcfa034366cdce5efed4b9bfc39c44c58a3a6c210e5cb13e879ba14c.jpg",
+        "table_caption": [
+            "Table 5: Positive task affinity between depth and normals in a low data setting. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>100ktraininginstances</td><td rowspan=1 colspan=1>DepthTestLoss</td><td rowspan=1 colspan=1>NormalsTestLoss</td></tr><tr><td rowspan=1 colspan=1>Depth AloneNormals Alone</td><td rowspan=1 colspan=1>0.2651</td><td rowspan=1 colspan=1>=0.1398</td></tr><tr><td rowspan=1 colspan=1>Joint Depth + Normals</td><td rowspan=1 colspan=1>0.2525</td><td rowspan=1 colspan=1>0.1319</td></tr></table>",
+        "bbox": [
+            467,
+            133,
+            823,
+            189
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "lion training instances. Table 5 shows the loss obtained on our setup when we limit to only $1 0 0 \\mathrm { k }$ training instances. The fact that task affinities can change depending on the amount of available training data demonstrates the necessity of using an empirical approach like ours for finding task affinities and groupings. ",
+        "bbox": [
+            174,
+            227,
+            825,
+            282
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "table",
+        "img_path": "images/903e56b1f82bd17ccb39c70181b4588c492135061c8d64282798518bbbc36f01.jpg",
+        "table_caption": [
+            "A.4 TABULAR DATA "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>Ours Optimal</td><td>Single 20% pass 3.3.1</td><td>Higher Order 3.3.2</td></tr><tr><td>1</td><td>SDNKE</td><td>SDNKE</td><td>SDNKE</td></tr><tr><td>1.5</td><td>DNKE, S</td><td>SDNK,E</td><td>DNKE, S</td></tr><tr><td>2</td><td>nKE, SDN</td><td>SDke,NKE</td><td>DNK,E, S</td></tr><tr><td>2.5</td><td>nKE, SDn, N</td><td>SDke, nKE, N</td><td>DNK,E, Sn</td></tr><tr><td>3</td><td>nKE, SDn, N</td><td>SDne, sdke, NKE</td><td>DNK,E, Sn</td></tr><tr><td>3.5</td><td>nKE, Snk,Dnk, N</td><td>SDne, sdke, nKE, N</td><td>DnK,E, Sn, N</td></tr><tr><td>4</td><td>nKE, Snk,Dnk,N</td><td>SDne, sdke, nKE, N</td><td>Sn,DK,E, N</td></tr><tr><td>4.5</td><td>nKE,Snk,Dnk,N</td><td>sDne, sdke,nKE,N, Snk</td><td>Sn,E,K, Dn, N</td></tr><tr><td>5</td><td>nkE, Snk,Dnk,N,K</td><td>sDne, sdke, nKE,N, Snk</td><td>Sn,E, K,Dn, N</td></tr></table>",
+        "bbox": [
+            207,
+            329,
+            785,
+            481
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "table",
+        "img_path": "images/f7343e0f8d2f3f39fd1026508cccff7954cf93308e9bc28e70fbc087579ed55c.jpg",
+        "table_caption": [
+            "Table 6: The task groups picked by each of our techniques for every budget choice between 1 and 5. Networks are shown as a list of letters corresponding to each task the network contains. S: Semantic Segmentation, D: Depth Estimation, N: Surface Normal Prediction, K: Keypoint Detection, E: Edge Detection. Capital letters denote that a solution used that network’s prediction for that task. Half-sized networks are shown in red. "
+        ],
+        "table_footnote": [
+            "Table 7: The total test set loss on all five tasks for each method under each inference time budget. Lower is better. The data is the same as in Figures 3 and 2. "
+        ],
+        "table_body": "<table><tr><td>Time Budget</td><td>1</td><td>1.5</td><td>2</td><td>2.5</td><td>3</td><td>3.5</td><td>4</td><td>4.5</td><td>5</td></tr><tr><td>Sener et al.</td><td>0.562</td><td></td><td>0.556</td><td>0.551</td><td></td><td></td><td>0.547</td><td></td><td></td></tr><tr><td>GradNorm</td><td>0.515</td><td></td><td></td><td></td><td></td><td></td><td>0.500</td><td></td><td></td></tr><tr><td>Pessimal Grouping</td><td>0.503</td><td>0.503</td><td>0.503</td><td>0.503</td><td>0.503</td><td>0.502</td><td>0.499</td><td></td><td>0.496 0.495</td></tr><tr><td>Traditional MTL</td><td>0.503</td><td></td><td>0.492</td><td>0.487</td><td></td><td></td><td>0.488</td><td></td><td></td></tr><tr><td>Random Groupings</td><td>0.503</td><td>0.483</td><td>0.475</td><td>0.471</td><td>0.467</td><td>0.464</td><td>0.462</td><td>0.460</td><td>0.459</td></tr><tr><td>Independent</td><td>0.515</td><td>0.501</td><td>0.477</td><td>0.465</td><td></td><td></td><td>0.454</td><td></td><td>0.448</td></tr><tr><td>Ours (ESA) 3.3.1</td><td>0.503</td><td>0.487</td><td>0.467</td><td>0.461</td><td>0.457</td><td>0.451</td><td>0.451</td><td>0.447</td><td>0.447</td></tr><tr><td>Ours (HOA) 3.3.2</td><td>0.503</td><td>0.461</td><td>0.455</td><td>0.451</td><td>0.449</td><td>0.445</td><td>0.444</td><td>0.445</td><td>0.442</td></tr><tr><td>Ours Optimal</td><td>0.503</td><td>0.461</td><td>0.452</td><td>0.446</td><td>0.442</td><td>0.439</td><td>0.436</td><td>0.436</td><td>0.435</td></tr></table>",
+        "bbox": [
+            214,
+            579,
+            781,
+            731
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "table",
+        "img_path": "images/12e72c4ae5cfdad12632aee0b1b09f8ae92a603ce55489ba0ba27448f954ba0d.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>SemSeg</td><td>Depth</td><td></td><td>Normals Keypoints</td><td>Edges</td></tr><tr><td>S</td><td>0.08039</td><td></td><td></td><td>一</td><td></td></tr><tr><td>D</td><td>1</td><td>0.1695</td><td></td><td></td><td></td></tr><tr><td>N</td><td>一</td><td>1</td><td>0.08591</td><td>一</td><td></td></tr><tr><td>K</td><td></td><td></td><td></td><td>0.0895</td><td>一</td></tr><tr><td>E</td><td></td><td></td><td>1</td><td>1</td><td>0.02783</td></tr><tr><td>SD</td><td>0.07858 0.1833</td><td></td><td>1</td><td>1</td><td>1</td></tr><tr><td>SN</td><td>0.074</td><td></td><td>0.0997</td><td>1</td><td></td></tr><tr><td>SK</td><td>0.07722</td><td></td><td></td><td>0.09718</td><td></td></tr><tr><td>SE</td><td>0.07897</td><td></td><td></td><td>1</td><td>0.04462</td></tr><tr><td>DN</td><td>1</td><td>0.1695</td><td>0.09275</td><td></td><td>一</td></tr><tr><td>DK</td><td></td><td>0.1706</td><td>一</td><td>0.09318</td><td>1</td></tr><tr><td>DE</td><td></td><td>0.1748</td><td></td><td>一</td><td>0.03192</td></tr><tr><td>NK</td><td></td><td></td><td>0.08968</td><td>0.09181</td><td></td></tr><tr><td>NE</td><td></td><td></td><td>0.09358</td><td></td><td>0.02908</td></tr><tr><td>KE</td><td></td><td></td><td></td><td>0.09185</td><td>0.03488</td></tr><tr><td>SDN</td><td>0.07498</td><td>0.1698</td><td>0.09575</td><td></td><td>1</td></tr><tr><td>SDK</td><td>0.07699</td><td>）0.1782</td><td></td><td>0.09704</td><td></td></tr><tr><td>SDE</td><td>0.07893</td><td>0.1863</td><td></td><td></td><td>0.04559</td></tr><tr><td>SNK</td><td>0.0722</td><td></td><td>0.09919</td><td>0.0961</td><td></td></tr><tr><td>SNE</td><td>0.07222</td><td></td><td>0.0982</td><td></td><td>0.03689</td></tr><tr><td>SKE</td><td>0.0766</td><td></td><td></td><td>0.09342</td><td>0.03508</td></tr><tr><td>DNK</td><td>1</td><td>0.1654</td><td>0.09358</td><td>0.09253</td><td>一</td></tr><tr><td>DNE</td><td></td><td>0.1708</td><td>0.09396</td><td>一</td><td>0.03286</td></tr><tr><td>DKE</td><td></td><td>0.1793</td><td></td><td>0.09073</td><td>0.02937</td></tr><tr><td>NKE</td><td></td><td></td><td>0.09626</td><td>0.09024</td><td>0.02609</td></tr><tr><td>SDNK</td><td>0.07762</td><td>0.1822</td><td>0.09869</td><td>0.1015</td><td>一</td></tr><tr><td>SDNE</td><td>0.07576</td><td>0.1735</td><td>0.09718</td><td>1</td><td>0.04513</td></tr><tr><td>SDKE</td><td>0.0795</td><td>0.1797</td><td></td><td>0.09272</td><td>0.04141</td></tr><tr><td>SNKE</td><td>0.07369</td><td></td><td>0.09944</td><td>0.09697</td><td>0.03312</td></tr><tr><td>DNKE</td><td></td><td>0.1708</td><td>0.09392</td><td>0.09334</td><td>0.02803</td></tr><tr><td>SDNKE</td><td>0.07854</td><td>0.1864</td><td>0.1</td><td>0.09814</td><td>0.04453</td></tr></table>",
+        "bbox": [
+            302,
+            251,
+            691,
+            708
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "table",
+        "img_path": "images/89df278f46fbbc0fe4c66fe616bb790f8d0a3ba4fbb71c1cf9fe27005c05b0ca.jpg",
+        "table_caption": [
+            "Table 9: The test set performance of our 31 networks on each task that they solve. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>SemSeg</td><td>Depth</td><td>Normals</td><td>sKeypoints</td><td>Edges</td></tr><tr><td>S</td><td>0.07662</td><td></td><td></td><td></td><td>1</td></tr><tr><td>D</td><td>1</td><td>0.1696</td><td></td><td></td><td></td></tr><tr><td>N</td><td></td><td>1</td><td>0.08555</td><td></td><td>1</td></tr><tr><td>K</td><td></td><td>一</td><td>1</td><td>0.08847</td><td>一</td></tr><tr><td>E</td><td></td><td>一</td><td></td><td>1</td><td>0.0275</td></tr><tr><td>SD</td><td>0.07419</td><td>0.1831</td><td>一</td><td></td><td>一</td></tr><tr><td>SN</td><td>0.07084</td><td>1</td><td>0.0994</td><td>1</td><td></td></tr><tr><td>SK</td><td>0.07369</td><td></td><td>1</td><td>0.09601</td><td></td></tr><tr><td>SE</td><td>0.07504</td><td></td><td></td><td>1</td><td>0.044</td></tr><tr><td>DN</td><td>1</td><td>0.1694 0.09249</td><td></td><td>1</td><td>1</td></tr><tr><td>DK</td><td></td><td>0.1713</td><td></td><td>0.08882</td><td>1</td></tr><tr><td>DE</td><td></td><td>0.1753</td><td></td><td></td><td>0.03145</td></tr><tr><td>NK</td><td></td><td>一</td><td>0.08934</td><td>0.09077</td><td></td></tr><tr><td>NE</td><td></td><td>1</td><td>0.09327</td><td></td><td>0.02865</td></tr><tr><td>KE</td><td></td><td></td><td></td><td>0.09077</td><td>0.0344</td></tr><tr><td>SDN</td><td>0.07193</td><td>0.17</td><td>0.09544</td><td>一</td><td>一</td></tr><tr><td>SDK</td><td>0.07311</td><td>0.1785</td><td></td><td>0.09591</td><td>一</td></tr><tr><td>SDE</td><td>0.07617</td><td>0.1865</td><td></td><td></td><td>0.04474</td></tr><tr><td>SNK</td><td>0.06933</td><td>一</td><td>0.09966</td><td>0.09302</td><td></td></tr><tr><td>SNE</td><td>0.06859</td><td></td><td>0.09796</td><td></td><td>0.03625</td></tr><tr><td>SKE</td><td>0.07323</td><td></td><td>1</td><td>0.09232</td><td>0.03463</td></tr><tr><td>DNK</td><td>1</td><td>0.1658</td><td>0.09318</td><td>0.09143</td><td>一</td></tr><tr><td>DNE</td><td></td><td>0.1706</td><td>0.09362</td><td></td><td>0.03239</td></tr><tr><td>DKE</td><td></td><td>0.1795</td><td></td><td>0.08968</td><td>0.02887</td></tr><tr><td>NKE</td><td></td><td></td><td>0.09596</td><td>0.08921</td><td>0.02566</td></tr><tr><td>SDNK</td><td>0.07338</td><td>0.1826</td><td>0.09836</td><td>0.1003</td><td></td></tr><tr><td>SDNE</td><td>0.07249</td><td>0.1739</td><td>0.09689</td><td>1</td><td>0.04441</td></tr><tr><td>SDKE</td><td>0.07634</td><td>0.1801</td><td></td><td>0.09157</td><td>0.04097</td></tr><tr><td>SNKE</td><td>0.07111</td><td></td><td>0.09941</td><td>0.09464</td><td>0.03328</td></tr><tr><td>DNKE</td><td></td><td>0.1704</td><td>0.09356</td><td>0.09226</td><td>0.02768</td></tr><tr><td>SDNKE</td><td>0.07603</td><td>0.186</td><td>0.09976</td><td>0.09704</td><td>0.04395</td></tr></table>",
+        "bbox": [
+            302,
+            267,
+            691,
+            722
+        ],
+        "page_idx": 17
+    }
+]

parse/train/HyunpgbR-/HyunpgbR-.md

@@ -0,0 +1,370 @@
+# STRUCTURED EXPLORATION VIA HIERARCHICAL VARIATIONAL POLICY NETWORKS
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Reinforcement learning in environments with large state-action spaces is challenging, as exploration can be highly inefficient. Even if the dynamics are simple, the optimal policy can be combinatorially hard to discover. In this work, we propose a hierarchical approach to structured exploration to improve the sample efficiency of on-policy exploration in large state-action spaces. The key idea is to model a stochastic policy as a hierarchical latent variable model, which can learn low-dimensional structure in the state-action space, and to define exploration by sampling from the low-dimensional latent space. This approach enables lower sample complexity, while preserving policy expressivity. In order to make learning tractable, we derive a joint learning and exploration strategy by combining hierarchical variational inference with actor-critic learning. The benefits of our learning approach are that 1) it is principled, 2) simple to implement, 3) easily scalable to settings with many actions and 4) easily composable with existing deep learning approaches. We demonstrate the effectiveness of our approach on learning a deep centralized multi-agent policy, as multi-agent environments naturally have an exponentially large state-action space. In this setting, the latent hierarchy implements a form of multi-agent coordination during exploration and execution (MACE). We demonstrate empirically that MACE can more efficiently learn optimal policies in challenging multi-agent games with a large number $( \sim 2 0 )$ of agents, compared to conventional baselines. Moreover, we show that our hierarchical structure leads to meaningful agent coordination.
+
+# 1 INTRODUCTION
+
+Reinforcement learning in environments with large state-action spaces is challenging, as exploration can be highly inefficient in high-dimensional spaces. Hence, even if the environment dynamics are simple, the optimal policy can be combinatorially hard to discover. However, for many large-scale environments, the high-dimensional state-action space has (often hidden or implicit) low-dimensional structure which can be exploited.
+
+Many natural examples are in collaborative multi-agent problems, whose state-action space is exponentially large in the number of agents, but have a low-dimensional coordination structure. Consider a simple variant of the Hare-Hunters problem (see Figure 1). In this game, $N = 2$ identical hunters need to capture $M = 2$ identical static prey within $T$ time-steps, and exactly $H = 1$ hunter is needed to capture each prey. $T$ is set such that no hunter can capture both preys. There are two equivalent solutions: hunter 1 captures prey 1 and hunter 2 captures prey 2, or vice versa. There are also two suboptimal choices: both hunters choose the same prey.
+
+![](images/c262eb1189a74a0fc8fe497bdf4533ad17564d721f022c0d67a4aa8db0173b0d.jpg)  
+Figure 1: Equivalent solutions in a 2-hunter 2- prey game.
+
+Hence, the hunters must coordinate over a (large) number of time-steps to maximize their reward.   
+This implies the solution space has low-dimensional structure that can be used to accelerate training.
+
+In this work, we propose a principled approach to structured exploration to improve sample complexity in large state-action spaces, by learning deep hierarchical policies with a latent structure. As a highlevel intuition, consider a tabular multi-agent policy, which maps discrete (joint) states to action probabilities. For $N$ agents with $S$ states and $A$ actions each, this policy has ${ \bf \bar { \cal O } } ( ( { \cal S } \cdot { \cal A } ) ^ { N } )$ weights. However, the low-dimensional coordination structure can be captured by a factorized, low-rank matrix, where the factorization can be learned and, for instance, only has $O ( N K ( S + A ) )$ weights. Similarly, our approach both 1) learns a low-dimensional factorization of the policy distribution and 2) defines exploration by also sampling from the low-dimensional latent space. For instance, in the multi-agent setting, we can learn a centralized multi-agent policy with a latent structure that encodes coordination between agents and biases exploration towards policies that encode “good” coordination.
+
+The key ideas of our approach are: 1) to utilize a shared stochastic latent variable model that defines the structured exploration policy, and 2) to employ a principled variational method to learn the posterior distribution over the latents jointly with the optimal policy. Our approach has several desirable properties. First we do not incorporate any form of prior domain knowledge, but rather discover the coordination structure purely from empirical experience during learning. Second, our variational learning method enables fully differentiable end-to-end training of the entire policy class. Finally, by utilizing a hierarchical policy class, our approach can easily scale to large action spaces (e.g. a large number of coordinating agents). Our approach can also be seen as a deep hierarchical generalization of Thompson sampling, which is a historically popular way to capture correlations between actions (e.g. in the bandit setting (Agrawal & Goyal, 2012)).
+
+To summarize, our contributions in this work are as follows:
+
+• We introduce a structured probabilistic policy class that uses a hierarchy of stochastic latent variables.   
+• We propose an efficient and principled algorithm using variational methods to train the policy end-to-end. To validate our learning framework, we introduce several synthetic multi-agent environments that explicitly require team coordination, and feature competitive pressures that are characteristic of many coordinated decision problems.   
+• We empirically verify that our approach improves sample complexity on coordination games with a large number $N \sim 2 0$ ) of agents.   
+• We show that learned latent structures correlate with meaningful coordination patterns.
+
+# 2 COOPERATIVE MULTI-AGENT REINFORCEMENT LEARNING
+
+We use multi-agent environments to show the efficacy of our approach to structured exploration, as they naturally exhibit exponentially large state-action spaces. In this work we focus on efficiently learning a centralized policy: a joint policy model for all agents, in the full-information setting. More generally, multi-agent problems can be generalized along many dimensions, e.g. one can learn decentralized policies in partial-information settings. For an overview, see Busoniu et al. (2008).
+
+In multi-agent RL, agents sequentially interact within an environment defined by the tuple: ${ \mathcal { E } } \equiv$ $( \mathbf { S } , \mathbf { A } , \mathbf { r } , \bar { f _ { P } } )$ . Each agent $i$ starts in an initial state $s _ { 0 } ^ { i }$ , and at each time $t$ observes a state $\mathbf { s } _ { t } \in \mathbf { S }$ and executes an action $a _ { t } ^ { i }$ chosen by a (stochastic) policy $a _ { t } ^ { i } \sim P \left( a _ { t } ^ { i } | \mathbf { s } _ { t } \right)$ . Each agent then receives a reward $r ^ { i } \left( \mathbf { s } _ { t } , \mathbf { a } _ { t } \right)$ , and the environment transitions to a new state $\mathbf { s } _ { t + 1 }$ with probability $f _ { P } \left( \mathbf { s } _ { t + 1 } \big | \mathbf { s } _ { t } , \mathbf { a } _ { t } \right)$ We define the joint state and actions as $\mathbf { s } _ { t } = \{ s _ { t } ^ { i } \in \mathbf { S } \}$ and $\mathbf { a } _ { t } = \{ a _ { t } ^ { i } \in \bar { \mathbf { A } } \bar { } \}$ , where $i \in \mathcal { T }$ indexes the agents. Note that the rewards for each agent $r ^ { i }$ can depend on the full joint state and actions.
+
+In this work, we restrict to fully cooperative MDPs that are fully observable, deterministic and episodic. Each agent can see the full state s, $f _ { P }$ is deterministic and each episode $\boldsymbol { \tau } = \left( \mathbf { s } _ { t } , \mathbf { a } _ { t } \right) _ { 0 \leq t \leq T }$ ends when the agent encounters a terminal state and the MDP resets.
+
+In the fully cooperative case, the goal for each agent is to learn its optimal policy $P ^ { * } \left( a _ { t } ^ { i } | \mathbf { s } _ { t } , \pmb \theta \right)$ that maximizes the total reward $\begin{array} { r } { R ( \tau ) = \sum _ { i } R ^ { i } ( \tau ) = \sum _ { i } \sum _ { t } r ^ { i } ( { \bf s } _ { t } , { \bf a } _ { t } ) } \end{array}$ :
+
+$$
+\operatorname* { m a x } _ { \pmb { \theta } } J ( \pmb { \theta } ) = \operatorname* { m a x } _ { \pmb { \theta } } \sum _ { i \in \mathcal { I } } J ^ { i } ( \pmb { \theta } ) , J ^ { i } ( \pmb { \theta } ) = \mathbb { E } \left[ \left. R ^ { i } \left( \tau \right) \right| \mathbf { a } _ { t } \sim P ( \mathbf { a } _ { t } | \mathbf { s } _ { t } ; \pmb { \theta } ) \right]
+$$
+
+To optimize, we can apply gradient descent with policy gradient estimators $\scriptstyle { \hat { g } } _ { \theta }$ (Williams (1992))
+
+$$
+g _ { \theta } = \nabla _ { \theta } J \left( \theta \right) = \mathbb { E } \left[ \nabla _ { \theta } \log P ( \mathbf { a } _ { t } | \mathbf { s } _ { t } ; \theta ) R ( \tau ) | \mathbf { a } _ { t } , \mathbf { s } _ { t } \right] \approx \frac { 1 } { M } \sum _ { k = 1 } ^ { M } \sum _ { t } \nabla _ { \theta } \log P ( \mathbf { a } _ { t } ^ { k } | \mathbf { s } _ { t } ^ { k } ; \theta ) R ( \tau ^ { k } ) ,
+$$
+
+![](images/3bf752868df2d590bcfe77fa15be68b612a392b010471c3f46cd1ced42a48bf4.jpg)  
+Figure 2: Structured latent variable model of the multi-agent policy (actor, left) and instance of the multi-agent actor-critic interacting in the environment $\mathcal { E }$ (right). The joint policy contains two stacked layers of stochastic latent variables (red), and deterministically receives states and computes actions (green). Global variables $\lambda$ are shared across agents. On the right, a neural network instance of the actor-critic uses the reparametrization trick and receives the environment state, samples actions from the policy for all agents and computes value functions $V ^ { \bullet }$ .
+
+where we sample $M$ rollouts $\tau ^ { k }$ by sampling actions from the policy that is being learned.
+
+A central issue in reinforcement learning is the exploration-exploitation trade-off: how can agents sample rollouts and learn efficiently? In particular, when the state-action space is exponentially large, discovering good (coordinated) policies when each agent samples independently becomes combinatorially intractable as $N$ grows. Hence, exploration in large state-action spaces poses a significant challenge.
+
+# 2.1 MACE: JOINT COORDINATION AND EXPLORATION
+
+We now formulate our multi-agent objective (1) using a hierarchical policy class that enables structured exploration. Our approach, MACE (“Multi-Agent Coordinated Exploration”), builds upon two complementary approaches:
+
+• Encode structured exploration by sampling actions that are correlated between agents. The correlation between actions encodes coordination. • Use a variational approach to derive and optimize a lower bound on the objective (1).
+
+Hierarchical Latent Model. To encode coordination between agents, we assume the individual policies have shared structure, encoded by a latent variable $\lambda _ { t } \in \mathbb { R } ^ { n }$ for all $t$ , where $n$ is the dimension of the latent space. This leads to a hierarchical policy model $\begin{array} { r } { P ( \mathbf { a } _ { t } , \lambda _ { t } | \mathbf { s } _ { t } ) } \end{array}$ , as shown in Figure 2. We first write the joint policy for a single time-step as:
+
+$$
+P ( \mathbf { a } _ { t } | \mathbf { s } _ { t } ) = \int d \lambda _ { t } P ( \mathbf { a } _ { t } , \lambda _ { t } | \mathbf { s } _ { t } ) = \int d \lambda _ { t } \prod _ { i = 1 } ^ { N } P ( a _ { t } ^ { i } , \lambda _ { t } | \mathbf { s } _ { t } ) = \int d \lambda _ { t } \prod _ { i = 1 } ^ { N } P ( a _ { t } ^ { i } | \lambda _ { t } , \mathbf { s } _ { t } ) P ( \lambda _ { t } | \mathbf { s } _ { t } ) ,
+$$
+
+where we introduced the conditional priors $P ( \lambda _ { t } | \mathbf { s } _ { t } )$ . The latent variables $\lambda _ { t }$ introduce dependencies among the $\mathbf { a } _ { t }$ , hence this policy is more flexible compared to standard fully factorized policies (Ranganath et al. (2015)). Note that this approach supports centralized learning and decentralized execution, by sharing a random seed amongst agents to sample $\lambda _ { t }$ and actions $\mathbf { a } _ { t }$ during execution.
+
+Computing the integral in the optimal policy (3) is hard, because the unknown distribution $P ( a _ { t } ^ { i } | \lambda _ { t } , \mathbf { s } _ { t } )$ can be highly complex. Hence, to make learning (3) tractable, we will use a variational approach.
+
+Hierarchical Variational Lower Bound. We next derive a tractable learning algorithm using variational methods. Instead of directly optimizing (1), we cast it as a probabilistic inference problem, as in Levine & Koltun (2013); Vlassis et al. (2009), and instead optimize a lower bound. To do so, we assume that the total reward $R ^ { i }$ for each $i$ to be non-negative and bounded. Hence, we can view the total reward $R ( \tau )$ as a random variable, whose unnormalized distribution is defined as $P ( R | \tau ) = R$ . We can then rewrite (1) as a maximum likelihood problem:
+
+$$
+\operatorname* { m a x } _ { \pmb { \theta } } \mathbb { E } _ { \pi ( \mathbf { s } _ { t } ; \pmb { \theta } ) } \left[ R \right] = \operatorname* { m a x } _ { \pmb { \theta } } \mathbb { E } _ { \pi ( \mathbf { s } _ { t } ; \pmb { \theta } ) } \left[ P ( R | \tau ) \right]
+$$
+
+Hence, the RL objective is equivalent to a maximal likelihood problem:
+
+$$
+\operatorname* { m a x } _ { \theta } \mathbb { E } _ { \pi ( s _ { t } ; \theta ) } \left[ P ( R | \tau ) \right] = \operatorname* { m a x } _ { \theta } \int d \tau P ( R | \tau ) P ( \tau ; \theta ) \Leftrightarrow \operatorname* { m a x } _ { \theta } \int d \tau \log P ( R | \tau ) P ( \tau ; \theta ) .
+$$
+
+In MACE we introduce a latent variable $\lambda _ { t }$ in the probability of a rollout $\tau$ , using (3):
+
+$$
+P ( \tau ; \pmb { \theta } ) = P ( \mathbf { s } _ { 0 } ) \int d \lambda _ { 0 : T } \prod _ { t = 0 } ^ { T } P ( \mathbf { s } _ { t + 1 } | \mathbf { s } _ { t } , \mathbf { a } _ { t } ) P ( \mathbf { a } _ { t } , \lambda _ { t } | \mathbf { s } _ { t } ; \pmb { \theta } ) , \quad \int d \lambda _ { 0 : T } \equiv \prod _ { t = 0 } ^ { T } \int d \lambda _ { t } ,
+$$
+
+where computing the policy distribution $P ( \mathbf { a } _ { t } , \lambda _ { t } | \mathbf { s } _ { t } ; \pmb \theta )$ is intractable, which makes the maximization in Equation (5) hard. Hence, we derive a lower bound on the log-likelihood $\log P ( R | \tau ) P ( \tau ; \pmb \theta )$ in Equation (5), using a variational approach. Specifically, we use an approximate factorized variational distribution $Q _ { R }$ that is weighted by the total reward $R$ :
+
+$$
+Q _ { R } ( \lambda _ { 0 : T } | \tau ; \phi ) = P ( R | \tau ) P ( \mathbf { s } _ { 0 } ) \prod _ { t = 0 } ^ { T } P ( \mathbf { s } _ { t + 1 } | \mathbf { s } _ { t } , \mathbf { a } _ { t } ) Q ( \lambda _ { t } | \mathbf { s } _ { t } ; \phi ) ,
+$$
+
+where $\phi$ are the parameters for the variational distribution $Q _ { R }$ . Using Jensen’s inequality (Hoffman et al., 2013) and (3) to factorize $P ( \mathbf { a } _ { t } , \lambda _ { t } | \mathbf { s } _ { t } ; \pmb \theta )$ , we can derive:
+
+$$
+\log P ( R | \tau ) P ( \tau ; \pmb \theta ) \geq \underbrace { \int d \lambda _ { 0 : T } Q _ { R } ( \lambda _ { 0 : T } | \tau ; \phi ) \sum _ { t = 0 } ^ { T } \left( \log P ( \mathbf a _ { t } | \lambda _ { t } , \pmb s _ { t } ; \pmb \theta ) + \log \frac { P ( \lambda _ { t } | \pmb s _ { t } ) } { Q ( \lambda _ { t } | \pmb s _ { t } , \phi ) } \right) } _ { \mathrm { E L B O } ( Q _ { R } , \pmb \theta , \phi ) } ,
+$$
+
+where the right-hand side is called the evidence lower bound (ELBO), which we can maximize as a proxy for (4). For more details on the derivation, see the Appendix.
+
+The standard choice for the prior $P ( \lambda _ { t } | \mathbf { s } _ { t } )$ is to use maximum-entropy standard-normal priors: $P ( \lambda _ { t } | \mathbf { s } _ { t } ) = \mathcal { N } ( \mathbf { 0 } , \mathbf { 1 } )$ . We can then optimize (8) using e.g. stochastic gradient ascent. Formally, the MACE policy gradient is:
+
+$$
+\begin{array} { r l } { g _ { \theta } \approx g _ { \theta , Q } = \nabla _ { \theta } \mathrm { E } \mathrm { L } \mathrm { B O } ( Q _ { R } , \theta , \phi ) } & { = \displaystyle \int d \tau d \lambda _ { 0 : T } Q _ { R } ( \lambda _ { 0 : T } | \tau ; \phi ) \sum _ { t ^ { \prime } = 0 } ^ { T } \nabla _ { \theta } \log P ( \mathbf { a } _ { t ^ { \prime } } | \lambda _ { t ^ { \prime } } , \mathbf { s } _ { t ^ { \prime } } ; \theta ) , } \end{array}
+$$
+
+which is an approximation of the true policy gradient (2). This gradient can be estimated using sampled roll-outs $\tau ^ { k }$ of the policy $P ^ { \pi }$ :
+
+$$
+\boldsymbol { g } _ { \theta , Q } \approx \widehat { \boldsymbol { g } } _ { \theta , Q } = \frac { 1 } { M } \sum _ { k = 1 } ^ { M } \sum _ { t = 0 } ^ { T } \nabla _ { \theta } \log P \left( \mathbf { a } _ { t } ^ { k } | \boldsymbol { \lambda } _ { t } ^ { k } , \mathbf { s } _ { t } ^ { k } ; \theta \right) \boldsymbol { R } ( \boldsymbol { \tau } ^ { k } ) .
+$$
+
+During a rollout $\tau ^ { k }$ , we sample $\lambda \sim Q$ , observe rewards $R \sim P ( R | \tau )$ and transitions $s _ { t + 1 } \sim$ $P ( s _ { t + 1 } | . )$ , and use these to compute (10). We can similarly compute $g _ { \phi , Q } = \nabla _ { \phi } \mathrm { E L B O } ( Q _ { R } , \pmb \theta , \phi )$ , the gradient for the variational posterior $Q _ { R }$ .
+
+Actor-Critic and Bias-Variance. Estimating policy gradients $g _ { \pmb { \theta } }$ using empirical rewards can suffer from high variance and instabilities. It is thus useful to consider more general objectives $F ^ { i }$ :
+
+$$
+J ^ { i } ( \pmb { \theta } ) = \mathbb { E } \left[ F ^ { i } \left( \tau \right) \middle | \mathbf { a } _ { t } \sim P ^ { \pi _ { t } } ( \mathbf { a } _ { t } | \mathbf { s } _ { t } ; \pmb { \theta } ) \right] ,
+$$
+
+such that the variance in $\hat { g }$ is reduced.1 In practice, we find that using (10) with more general $F$ , such as generalized advantages (Schulman et al. (2015)), performs quite well.
+
+# 3 EXPERIMENTAL VALIDATION
+
+# 3.1 MULTI-AGENT ENVIRONMENTS
+
+To validate our approach, we created two grid-world games, depicted in Figure 2, inspired by the classic Predator-Prey and Stag-Hunt games (Shoham & Leyton-Brown (2008)). In both games, the world is periodic and the initial positions of the hunters and prey are randomized. Also, we consider two instances for both games: either the prey are moving or fixed.
+
+Hare-Hunters. Predator-Prey is a classic test environment for multi-agent learning, where 4 predators try to capture a prey by boxing it in. We consider a variation defined by the settings $( N , \bar { M } , H , T )$ : $N$ hunters and $M$ prey. Each prey can be captured by exactly $H$ hunters: to capture the prey, a hunter gets next to it, after which the hunter is frozen. Once a prey has had $H$ hunters next to it, it is frozen and cannot be captured by another hunter. The terminal rewards used are:
+
+$$
+R ^ { i } = { \left\{ \begin{array} { l l } { 1 , } & { { \mathrm { i f ~ } } a l l { \mathrm { ~ p r e y ~ a r e ~ c a p t u r e d ~ } } H { \mathrm { ~ t i m e s ~ b e f o r e ~ t h e ~ t i m e ~ l i m i t ~ } } T } \\ { 0 , } & { { \mathrm { o t h e r w i s e } } } \end{array} \right. }
+$$
+
+The challenge of the game is for the agents to inactivate all prey within a finite time $T$ . Due to the time limit, the optimal strategy is for the agents to distribute targets efficiently, which can be challenging due to the combinatorially large number of possible hunter-to-prey assignments.
+
+Stag-Hunters. The Stag-Hunt is another classic multi-agent game designed to study coordination. In this game, hunters have a choice: either they capture a hare for low reward, or, together with another hunter, capture a stag for a high reward. We extend this to the multi-agent $( N , M , H , T )$ -setting: $N$ hunters hunt $M$ prey $M / 2$ stags and $M / 2$ hares). Each stag has $H$ hit-points, while hares and hunters have 1 hit-point. Capturing is as in Hare-Hunters. The spatial domain is similar to the Hare-Hunters game and we also use a time limit $T$ . The terminal reward is now defined as:
+
+$$
+R ^ { i } = \left\{ \begin{array} { l l } { 1 , } & { \mathrm { i f ~ } i \mathrm { ~ c a p t u r e d ~ a l i v e ~ s t a g ~ t h a t ~ b e c a m e ~ i n a c t i v e ~ b e f o r e ~ t h e ~ t i r } } \\ { 0 . 1 , } & { \mathrm { i f ~ } i \mathrm { ~ c a p t u r e d ~ a ~ l i v e ~ h a r e ~ b e f o r e ~ t h e ~ t i m e ~ l i m i t ~ } T } \\ { 0 , } & { \mathrm { o t h e r w i s e } } \end{array} \right.
+$$
+
+The challenge for the agents here is to discover that choosing to capture the same prey can yield substantially higher reward, but this requires coordinating with another hunter.
+
+# 3.2 NEURAL COORDINATION MODEL
+
+For experiments, we instantiated our multi-agent policy class (as in Figure 2) with deep neural networks. For simplicity, we only used reactive policies without memory, although it is straightforward to apply MACE to policies with memory (e.g. LSTMs). The model takes a joint state $\mathbf { s } _ { t }$ as input and computes features $\phi ( \mathbf { s } )$ using a 2-layer convolutional neural network. To compute the latent variable $\boldsymbol { \bar { \lambda } } \in \mathbb { R } ^ { d }$ , we use the reparametrization trick (Kingma & Welling, 2013) to learn the variational distribution (e.g. $Q ( \lambda | \mathbf { s } ) )$ , sampling $\lambda$ via $\epsilon \sim \mathcal { N } ( \mathbf { 0 } , \mathbf { 1 } )$ and distribution parameters $\mu , \sigma$ (omitting $t$ ):
+
+$$
+\mu ( \mathbf { s } ) = W _ { \mu } \phi ( \mathbf { s } ) + b _ { \mu } , \quad \log \sigma ( \mathbf { s } ) ^ { 2 } = W _ { \sigma } \phi ( \mathbf { s } ) + b _ { \sigma } , \quad \lambda = \mu ( \mathbf { s } ) + \sigma ( \mathbf { s } ) \odot \epsilon .
+$$
+
+Given $\lambda$ , the model then computes the policies $P ( a ^ { i } | \lambda , \mathbf { s } )$ and value functions $V ^ { i } ( \mathbf { s } )$ as (omitting $t$ ):
+
+$$
+P ( a ^ { i } | \lambda , \mathbf { s } ) = \mathsf { s o f t m a x } \left( W _ { \pi } ^ { i } [ \lambda ~ \phi ( \mathbf { s } ) ] + b _ { \pi } ^ { i } \right) , \quad V ^ { i } ( \mathbf { s } ) = W _ { V } ^ { i } \phi ( \mathbf { s } ) + b _ { V } ^ { i } ,
+$$
+
+where softma $\begin{array} { r } { \mathrm {  ~ \psi ~ } _ { \mathrm { { L } } } ( { \bf x } ) = \exp { \bf x } / \sum _ { j } \exp { x ^ { j } } } \end{array}$ . In this way, the model can be trained end-to-end.
+
+Training. We used A3C (Mnih et al. (2016)) with KL-controlled policy gradients (10), generalized advantage as $F$ (Schulman et al. (2015)). and policy-entropy regularization. For all experiments, we performed a hyper-parameter search and report the best 5 runs seen (see the Appendix for details).
+
+Baselines. We compared MACE against two natural baselines:
+
+• Shared (shared actor-critic): agents share a deterministic hidden layer, but maintain individual weights $\theta ^ { i }$ for their (stochastic) policy $P ( a | \lambda , \mathbf { s } ; \theta ^ { i } )$ and value function $V ^ { i } ( \mathbf { s } ; \pmb \theta )$ . The key difference is that this model does not sample from the shared hidden layer. Cloned (actor-critic): a model where each agent uses an identical policy and value function with shared weights. There is shared information between the agents, and actions are sampled according to the agents’ own policies.
+
+![](images/8c625582e478131ef08cee9b51e68833035d058c1f7f3710cae17327dc35d10f.jpg)  
+Figure 3: Train-time cumulative terminal reward for $N$ agents in $( N , M , 1 , T )$ Hare-Hunters (upper, $T = 2 0 0 0$ ) and Stag-Hunters (lower, $T = 1 0 0 0 \mathrm { \Omega }$ ) on a $5 0 \times 5 0$ gridworld, for 10-vs-10 or 20-vs-20 agents; randomly moving or fixed preys. Average, minimal and maximal rewards for the best 5 runs for each model are shown. MACE accumulates increasingly higher rewards compared to the baselines, by 1) achieving higher terminal reward per episode and 2) finishing episodes faster (see Figure 4). For 10-10 Stag-Hunters with frozen prey, average reward per-episode is 4.64 (Cloned), 6.22 (Shared), 6.61 (MACE) after 1 million samples. For more, see the Appendix.
+
+![](images/aec18be8f5d63baf9f187247eb4654208234a495ff59631db08019cecf6a51ef.jpg)  
+Figure 4: Train-time episode lengths during 1 million steps for 10-vs-10 Hare-Hunters (left) and Stag-Hunters (right), with fixed preys. MACE (orange) finishes an episode successfully before the time limit more often than the baselines (Cloned (blue) and Shared (yellow)).
+
+# 4 QUANTITATIVE ANALYSIS
+
+Above, we defined a variational approach to train hierarchical multi-agent policies using structured exploration. We now validate the efficacy of our approach by showing our method scales to environments with a large number of agents. We ran experiments for both Hare-Hunters and Stag-Hunters for $N = M = 1 0 , 2 0$ in a spatial domain of $5 0 \times 5 0$ grid cells.
+
+Sample complexity. In Table 1 we show the achieved rewards after a fixed number of training samples, and Figure 3 showcases the corresponding learning curves. We see that MACE achieves up to $1 0 \times$ reward compared to the baselines. Figure 4 shows the corresponding distribution of training episode lengths. We see that MACE solves game instances more than $2 0 \%$ faster than baselines in $5 0 \%$ $( 1 0 \% )$ of Hare-Hunters (Stag-Hunters) episodes. In particular, MACE learns to coordinate for higher reward more often: it achieves the highest average reward per-episode (e.g. for 10-10 Stag-Hunters with frozen prey, average rewards are 4.64 (Cloned), 6.22 (Shared), 6.61 (MACE)). Hence, MACE coordinates successfully more often to capture the stags. Together, these results show MACE enables more efficient learning.
+
+Using the ELBO. A salient difference between (10) and (2) is the KL-regularization, which stems from the derivation of the ELBO. Since we use a more general objective $F$ , c.f. (11), we also investigated the impact of using the KL-regularized policy gradient (10) versus the standard (2). To this end, we ran several instances of the above experiments both with and without KL-regularization. We found that without KL-regularization, training is unstable and prone to mode collapse: the variance $\sigma$ of the variational distribution can go to 0. This reflects in essentially 0 achieved reward: the model does not solve the game for any reasonable hyperparameter settings.
+
+<table><tr><td>Preys are</td><td colspan="2">Frozen</td><td colspan="2">Moving</td><td colspan="2">Frozen</td><td colspan="2">Moving</td></tr><tr><td>Samples (x100k)</td><td>5</td><td>10</td><td>5</td><td>10</td><td>5</td><td>10</td><td>5</td><td>10</td></tr><tr><td>Hare-Hunters</td><td colspan="4">10-vs-10</td><td colspan="4">20-vs-20</td></tr><tr><td>Cloned</td><td>85.0</td><td>178.3</td><td>465.0</td><td>912.5</td><td>20.0</td><td>70.0</td><td>706.7</td><td>1401.7</td></tr><tr><td>Shared</td><td>65.0</td><td>155.0</td><td>457.5</td><td>923.8</td><td>65.0</td><td>105.0</td><td>491.4</td><td>962.9</td></tr><tr><td>MACE</td><td>240.0</td><td>580.0</td><td>662.7</td><td>1381.8</td><td>200.0</td><td>393.3</td><td>1260.0</td><td>2344.0</td></tr><tr><td>Stag-Hunters</td><td colspan="4">10-vs-10</td><td colspan="4">20-vs-20</td></tr><tr><td>Cloned</td><td>1229.2</td><td>2482.9</td><td>2079.4</td><td>4171.2</td><td>3224.5</td><td>6219.9</td><td>5934.5</td><td>11429.2</td></tr><tr><td>Shared</td><td>1214.5</td><td>2423.7</td><td>2005.7</td><td>4144.3</td><td>3150.7</td><td>6379.8</td><td>6344.4</td><td>12196.8</td></tr><tr><td>MACE</td><td>1515.2</td><td>3047.3</td><td>2275.7</td><td>4610.7</td><td>3799.3</td><td>7158.1</td><td>6880.7</td><td>13358.6</td></tr></table>
+
+Table 1: Total terminal reward (averaged over 5 best runs) for $N$ agents for set # of training samples.
+
+![](images/536755bac36a6771a5643f7c332f3df07d3eaa41b7ad473c0c311052fb85c88d.jpg)  
+Figure 5: Predators (red) and prey (green) during training for 2v2 Hare-Hunters for 100 episodes. Arrows show where agents move to in the next frame. Top: at the start, predators explore via $\lambda$ , but do not succeed before the time limit $T$ (red dot). Bottom: after convergence agents succeed consistently (green dot) before the time limit (purple dot) and $\lambda$ encodes the two strategies from Figure 1. Highlighted $\lambda$ -components correlate with rollout under a 2-sided $t$ -test at $\alpha = 0 . 1$ significance.
+
+Impact of dynamics and $T$ . Inspecting training performance, we see the relative difficulty of capturing moving or randomly moving prey. Capturing moving prey is easier to learn than capturing fixed preys, as comparing rewards in Table 1 shows. This shows a feature of the game dynamics: the expected distance between a hunter and an uncaptured prey are lower when the preys are randomly moving, resulting in an easier game. Comparing Hare-Hunters and Stag-Hunters, we also see the impact of the time limit $T$ . Since we use terminal rewards only, as $T$ gets larger, the reward becomes very sparse and models need more samples to discover good policies.
+
+# 5 MODEL INSPECTION
+
+Beyond training benefits, we now demonstrate empirical evidence that suggest efficacy and meaningfulness of our approach to structured exploration. We start by inspecting the behavior of the latent variable $\lambda$ for a simple $N = M = 2$ Hare-Hunters game, which enables semantic inspection of the learned policies, as in Figure 5. We make a number of observations. First, $\lambda$ is relevant: many components are statistically significantly correlated with the agents’ actions. This suggests the model does indeed use the latent $\lambda$ : it (partly) controls the coordination between agents.2 Second, the latent $\lambda$ shows strong correlation during all phases of training. This suggests that the model indeed is performing a form of structured exploration. Third, the components of $\lambda$ are correlated with semantic meaningful behavior. We show a salient example in the bottom 2 rows in Figure 5: the correlated components of $\lambda$ are disjoint and each component correlates with both agents. The executed policies are exactly the two equivalent ways to assign 2 hunters to 2 preys, as illustrated in Figure 1.
+
+![](images/cdc1d6ab373edf1e5fc1d2b8bc82e1de03d08d996b8c46e0e7bd4bf4d5f0fbc6.jpg)  
+Figure 6: Visualization of MACE for a $( 1 0 , 1 0 , 1 , 1 0 0 0 )$ Hare-Hunters game in a $3 0 \times 3 0$ world. Left: components of the latent code $\lambda$ that significantly correlate with sampled actions (computed as in Figure 5). Right: Three episode snapshots: at the start, middle and end. Red: predators; green: prey. Arrows indicate where agents move to in the next snapshot. The hunters solve the game (green dot) before the time limit $T = 1 0 0 0$ (purple dot), by distributing targets amongst themselves.
+
+Coordination with a large $N$ . In the large $N = M = 1 0$ case, the dynamics of the agent collective are a generalization of the $N = M = 2$ case. There are now redundancies in multi-agent hunter-prey assignments that are analogous to the $N = M = 2$ case that are prohibitively complex to analyze due to combinatorial complexity. However our experiments strongly suggest (see e.g. Figure 6) the latent code is again correlated with the agents’ behavior during all phases of training, showing that $\lambda$ induces meaningful multi-agent coordination.
+
+# 6 RELATED WORK
+
+Deep Structured Inference. Recent works have focused on learning structured representations using expressive distributions, which enable more powerful probabilistic inference. For instance, Johnson et al. (2016) has proposed combining neural networks with graphical models, while Ranganath et al. (2015) learn hierarchical latent distributions. Our work builds upon these approaches to learn structured policies in the reinforcement learning setting. In the multi-agent setting, the RL problem has also been considered as an inference problem in e.g. (Liu et al., 2015; Wu et al., 2013; Liu et al., 2016).
+
+Variational methods in RL. Neumann (2011); Furmston & Barber (2010) discuss variational approaches for RL problems, but did not consider end-to-end trainable models. Levine & Koltun (2013) used variational methods for guided policy search. Houthooft et al. (2016) learned exploration policies via information gain using variational methods. However, these only consider 1 agent.
+
+Coordination in RL. Multi-agent coordination has been studied in the RL community (e.g. Guestrin et al. (2002); Kapetanakis & Kudenko (2002); Chalkiadakis & Boutilier (2003)), for instance, as a method to reduce the instability of multiple agents learning simultaneously using RL. The benefit of coordination was already demonstrated in simple multi-agent settings in e.g. Tan (1993). The shared latent variable $\lambda$ of our structured policy can also be interpreted as a learned correlation device (see Bernstein (2005) for an example in the decentralized setting), which can be used to e.g. break ties between alternatives or induce coordination between agents. More generally, they can be used to achieve correlated equilibria (Greenwald & Hall, 2003), a more general solution concept than Nash equilibria. However, previous methods learned hand-crafted models and do not scale well to complex state spaces and many agents. In contrast, our method learns coordination end-to-end via on-policy methods, learns the multi-agent exploration policy and scales well to many agents via its simple hierarchical structure.
+
+Communication Models. Recently, end-to-end learning of communication models has been studied for shared broadcast channels (Sukhbaatar et al. (2016)), sequential communication (Peng et al. (2017)), heuristic multi-agent exploration Usunier et al. (2016) and bit-channels (Foerster et al. (2016)). These works show that non-trivial communication protocols can be learned through backpropagation or heuristic stabilization methods, but often do not scale well to a large number of agents. Our hierarchical approach is complementary, learns via variational methods, and can scale to large $N$ .
+
+Multi-task learning. Hierarchical models have been studied for multi-task learning, e.g. Daume III (2014) learns latent hierarchies via EM in a supervised learning setting. Instead, we study flexible end-to-end trainable latent hierarchies in the reinforcement learning setting.
+
+# 7 DISCUSSION
+
+In a sense, we studied the simplest setting that can benefit from structured exploration, in order to isolate the contribution of our work. Our hierarchical model and variational approach are a simple way to implement multi-agent coordination, and easily combine with existing actor-critic methods. Moving forward, there are many ways to expand on our work. Firstly, for complex (partial-information) environments, instead of using reactive policies with simple priors $P \sim \mathcal { N } ( \bar { 0 } , 1 )$ , memoryfull policies with flexible priors (Chen et al., 2016) may be needed. Secondly, our approach is complementary to richer forms of communication between agents. Our hierarchical structure can be interpreted as a broadcast channel, where agents are passive receivers of the message $\lambda$ . Richer communication protocols could be encoded by policies with more complex inter-agent structure. It would be interesting to investigate how to learn these richer structures.
+
+# REFERENCES
+
+Shipra Agrawal and Navin Goyal. Analysis of thompson sampling for the multi-armed bandit problem. In Conference on Learning Theory, pp. 39–1, 2012.
+
+Daniel S Bernstein. Bounded policy iteration for decentralized pomdps. In In Proceedings of the Nineteenth International Joint Conference on Artificial Intelligence. Citeseer, 2005.
+
+Lucian Busoniu, Robert Babuska, and Bart De Schutter. A comprehensive survey of multiagent reinforcement learning. IEEE Transactions on Systems, Man, And Cybernetics-Part C: Applications and Reviews, 38 (2), 2008, 2008.
+
+Georgios Chalkiadakis and Craig Boutilier. Coordination in Multiagent Reinforcement Learning: A Bayesian Approach. In International Joint Conference on Autonomous Agents and Multiagent Systems, AAMAS ’03, New York, NY, USA, 2003.
+
+Xi Chen, Diederik P. Kingma, Tim Salimans, Yan Duan, Prafulla Dhariwal, John Schulman, Ilya Sutskever, and Pieter Abbeel. Variational Lossy Autoencoder. arXiv:1611.02731 [cs, stat], November 2016. URL http://arxiv.org/abs/1611.02731. arXiv: 1611.02731.
+
+Hal Daume III. Bayesian Multitask Learning with Latent Hierarchies. arXiv:1408.2032 [cs, stat], August 2014. arXiv: 1408.2032.
+
+Jakob N. Foerster, Yannis M. Assael, Nando de Freitas, and Shimon Whiteson. Learning to Communicate with Deep Multi-Agent Reinforcement Learning. arXiv:1605.06676 [cs], May 2016. arXiv: 1605.06676.
+
+T. Furmston and D. Barber. Variational methods for reinforcement learning. Journal of Machine Learning Research, 9:241–248, December 2010. ISSN 1533-7928.
+
+Amy Greenwald and Keith Hall. Correlated q-learning. In Proceedings of the 20th International Conference on Machine Learning (ICML-03), pp. 242–249, 2003.
+
+Carlos Guestrin, Michail Lagoudakis, and Ronald Parr. Coordinated reinforcement learning. In ICML, 2002.
+
+Matthew D. Hoffman, David M. Blei, Chong Wang, and John Paisley. Stochastic variational inference. Journal of Machine Learning Research, 14:1303–1347, 2013. URL http://jmlr. org/papers/v14/hoffman13a.html.
+
+Rein Houthooft, Xi Chen, Yan Duan, John Schulman, Filip De Turck, and Pieter Abbeel. VIME: Variational Information Maximizing Exploration. arXiv:1605.09674 [cs, stat], May 2016. arXiv: 1605.09674.
+
+M. J. Johnson, D. Duvenaud, A. B. Wiltschko, S. R. Datta, and R. P. Adams. Composing graphical models with neural networks for structured representations and fast inference. ArXiv e-prints, March 2016.
+
+Spiros Kapetanakis and Daniel Kudenko. Reinforcement Learning of Coordination in Cooperative Multi-agent Systems. In Eighteenth National Conference on Artificial Intelligence, pp. 326– 331, Menlo Park, CA, USA, 2002. American Association for Artificial Intelligence. ISBN 9780262511292.
+
+Diederik P Kingma and Max Welling. Auto-encoding variational bayes. arXiv preprint arXiv:1312.6114, 2013.
+
+Sergey Levine and Vladlen Koltun. Variational Policy Search via Trajectory Optimization. In C. J. C. Burges, L. Bottou, M. Welling, Z. Ghahramani, and K. Q. Weinberger (eds.), Advances in Neural Information Processing Systems 26, pp. 207–215. Curran Associates, Inc., 2013.
+
+Miao Liu, Christopher Amato, Xuejun Liao, Lawrence Carin, and Jonathan P How. Stick-breaking policy learning in dec-pomdps. In IJCAI, pp. 2011–2018, 2015.
+
+Miao Liu, Christopher Amato, Emily P Anesta, John Daniel Griffith, and Jonathan P How. Learning for decentralized control of multiagent systems in large, partially-observable stochastic environments. 2016.
+
+Volodymyr Mnih, Adri Puigdomnech Badia, Mehdi Mirza, Alex Graves, Timothy P. Lillicrap, Tim Harley, David Silver, and Koray Kavukcuoglu. Asynchronous Methods for Deep Reinforcement Learning. arXiv:1602.01783 [cs], February 2016. arXiv: 1602.01783.
+
+Gerhard Neumann. Variational inference for policy search in changing situations. In International Conference on Machine Learning, ICML 2011, pp. 817–824, Bellevue, Washington, USA, June 2011.
+
+Peng Peng, Quan Yuan, Ying Wen, Yaodong Yang, Zhenkun Tang, Haitao Long, and Jun Wang. Multiagent Bidirectionally-Coordinated Nets for Learning to Play StarCraft Combat Games. arXiv:1703.10069 [cs], March 2017. arXiv: 1703.10069.
+
+Rajesh Ranganath, Dustin Tran, and David M. Blei. Hierarchical Variational Models. arXiv:1511.02386 [cs, stat], November 2015. arXiv: 1511.02386.
+
+John Schulman, Philipp Moritz, Sergey Levine, Michael Jordan, and Pieter Abbeel. High-Dimensional Continuous Control Using Generalized Advantage Estimation. arXiv:1506.02438 [cs], June 2015. arXiv: 1506.02438.
+
+Yoav Shoham and Kevin Leyton-Brown. Multiagent Systems: Algorithmic, Game-Theoretic, and Logical Foundations. Cambridge University Press, New York, NY, USA, 2008. ISBN 9780521899437.
+
+Sainbayar Sukhbaatar, Arthur Szlam, and Rob Fergus. Learning Multiagent Communication with Backpropagation. arXiv:1605.07736 [cs], May 2016. arXiv: 1605.07736.
+
+Ming Tan. Multi-Agent Reinforcement Learning: Independent vs. Cooperative Agents. In In Proceedings of the Tenth International Conference on Machine Learning, pp. 330–337. Morgan Kaufmann, 1993.
+
+Nicolas Usunier, Gabriel Synnaeve, Zeming Lin, and Soumith Chintala. Episodic Exploration for Deep Deterministic Policies: An Application to StarCraft Micromanagement Tasks. arXiv:1609.02993 [cs], September 2016. arXiv: 1609.02993.
+
+Nikos Vlassis, Marc Toussaint, Georgios Kontes, and Savas Piperidis. Learning model-free robot control by a Monte Carlo EM algorithm. Autonomous Robots, 27(2):123–130, August 2009. ISSN 0929-5593, 1573-7527.
+
+Ronald J Williams. Simple statistical gradient-following algorithms for connectionist reinforcement learning. Machine learning, 8(3-4):229–256, 1992.
+
+Feng Wu, Shlomo Zilberstein, and Nicholas R Jennings. Monte-carlo expectation maximization for decentralized pomdps. In Proceedings of the Twenty-Third international joint conference on Artificial Intelligence, pp. 397–403. AAAI Press, 2013.
+
+# 8 SUPPLEMENTARY MATERIAL
+
+8.1 HIERARCHICAL VARIATIONAL LOWER BOUND.
+
+We show details on how to derive a tractable learning method to the multi-agent reinforcement learning problem with a centralized controller:
+
+$$
+R = \sum _ { i } R ^ { i } , \quad \operatorname* { m a x } _ { \theta } \mathbb { E } _ { \pi ( \mathbf { s } _ { t } ; \theta ) } \left[ R \right] .
+$$
+
+Instead of directly optimizing (16), we cast it as a probabilistic inference problem, as in Levine & Koltun (2013); Vlassis et al. (2009), and optimize a lower bound.
+
+To do so, we assume that the total reward $R ^ { i }$ for each $i$ to be non-negative and bounded. Hence, we can view the total reward $R ( \tau )$ as a random variable, whose unnormalized distribution is defined as
+
+$$
+P ( R | \tau ) = R .
+$$
+
+We can then rewrite (16) as a maximum likelihood problem:
+
+$$
+\operatorname* { m a x } _ { \pmb { \theta } } \mathbb { E } _ { \pi ( \mathbf { s } _ { t } ; \pmb { \theta } ) } \left[ R \right] = \operatorname* { m a x } _ { \pmb { \theta } } \mathbb { E } _ { \pi ( \mathbf { s } _ { t } ; \pmb { \theta } ) } \left[ P ( R | \tau ) \right]
+$$
+
+Hence, the RL objective is equivalent to a maximal likelihood problem:
+
+$$
+\operatorname* { m a x } _ { \theta } \mathbb { E } _ { \pi ( s _ { t } ; \theta ) } \left[ P ( R | \tau ) \right] = \operatorname* { m a x } _ { \theta } \int d \tau \underbrace { P ( R | \tau ) P ( \tau ; \theta ) } _ { P ( R , \tau ; \theta ) } \Leftrightarrow \operatorname* { m a x } _ { \theta } \int d \tau \log P ( R | \tau ) P ( \tau ; \theta ) ,
+$$
+
+where the probability of a rollout $\tau$ features a marginalization over the latent variables $\lambda _ { t }$ :
+
+$$
+\begin{array} { l } { { \displaystyle P ( \tau ; \pmb \theta ) = P ( { \bf s } _ { 0 } ) \prod _ { t = 0 } ^ { T } P ( { \bf s } _ { t + 1 } \vert { \bf s } _ { t } , { \bf a } _ { t } ) P ( { \bf a } _ { t } \vert { \bf s } _ { t } ; \pmb \theta ) } } \\ { { \displaystyle ~ = P ( { \bf s } _ { 0 } ) \int d \lambda _ { 0 : T } \prod _ { t = 0 } ^ { T } P ( { \bf s } _ { t + 1 } \vert { \bf s } _ { t } , { \bf a } _ { t } ) P ( { \bf a } _ { t } , \lambda _ { t } \vert { \bf s } _ { t } ; \pmb \theta ) , } } \\ { { \displaystyle \int d \lambda _ { 0 : T } \equiv \prod _ { t = 0 } ^ { T } \int d \lambda _ { t } } } \end{array}
+$$
+
+Here, we used the hierarchical decomposition for the policy:
+
+$$
+\begin{array} { l } { { \displaystyle P ( { \bf a } _ { t } | { \bf s } _ { t } ; \theta ) = \int d \lambda _ { t } P ( { \bf a } _ { t } , \lambda _ { t } | { \bf s } _ { t } ; \theta ) } } \\ { ~ } \\ { { \displaystyle ~ = \int d \lambda _ { t } \prod _ { i = 1 } ^ { N } P ( a _ { t } ^ { i } , \lambda _ { t } | { \bf s } _ { t } ; \theta ) } } \\ { { \displaystyle ~ = \int d \lambda _ { t } \prod _ { i = 1 } ^ { N } P ( a _ { t } ^ { i } | \lambda _ { t } , { \bf s } _ { t } ; \theta ) P ( \lambda _ { t } | { \bf s } _ { t } ) } , } \end{array}
+$$
+
+This policy distribution is intractable to learn exactly, as it involves margalization over $\lambda _ { t }$ and an unknown flexible distribution $P ( a _ { t } ^ { i } | \lambda _ { t } , \mathbf { s } _ { t } )$ . Hence the maximization in Equation (19) is hard. Hence, we follow the variational approach and get a lower bound on the log-likelihood $\log P ( R , \tau ; \pmb \theta )$ in Equation (19). For this, we use an approximate variational distribution $Q _ { R } \big ( \lambda _ { 0 : T } | \tau ; \phi \big )$ and Jensen’s inequality (Hoffman et al., 2013):
+
+$$
+\begin{array} { l } { { \displaystyle \log P ( R , \tau ; \theta ) \geq \int d \lambda _ { 0 : T } Q _ { R } ( \lambda _ { 0 : T } | \tau ; \phi ) \log \left( \frac { P ( R , \tau ; \theta ) } { Q _ { R } ( \lambda _ { 0 : T } | \tau ; \phi ) } \right) ~ } } \\ { { \displaystyle ~ = \int d \lambda _ { 0 : T } Q _ { R } ( \lambda _ { 0 : T } | \tau ; \phi ) \log \left( \frac { P ( R | \tau ) P ( \mathbf { s } _ { 0 } ) \prod _ { t = 0 } ^ { T } P ( \mathbf { s } _ { t + 1 } | \mathbf { s } _ { t } , \mathbf { a } _ { t } ) P ( \mathbf { a } _ { t } , \lambda _ { t } | \mathbf { s } _ { t } ; \theta ) } { Q _ { R } ( \lambda _ { 0 : T } | \tau ; \phi ) } \right) , } } \end{array}
+$$
+
+where in the last line we used (20). By inspecting the quotient in (26), we see that the optimal $Q _ { R }$ is a factorized distribution weighted by the total reward $R$ :
+
+$$
+Q _ { R } ( \lambda _ { 0 : T } | \tau ; \phi ) = P ( R | \tau ) P ( \mathbf { s } _ { 0 } ) \prod _ { t = 0 } ^ { T } P ( \mathbf { s } _ { t + 1 } | \mathbf { s } _ { t } , \mathbf { a } _ { t } ) Q ( \lambda _ { t } | \mathbf { s } _ { t } ; \phi ) .
+$$
+
+We see that (26) simplifies to:
+
+$$
+\begin{array} { r l } & { \int d \lambda _ { u x : U } Q _ { K } ( \lambda _ { u x } | \tau ; \phi ) \log ( \frac { P ( R ( | T | \gamma ) P ( s _ { 1 } ) \prod _ { t ^ { \prime } = 0 } ^ { T } P ( s _ { t + 1 } ) P ( s _ { t + 1 } , \lambda _ { t } , \phi ) ) } { P ( R ( \prod _ { t ^ { \prime } } P ( s _ { t } ) \prod _ { t ^ { \prime } = 0 } ^ { T } P ( s _ { t } ) \prod _ { t ^ { \prime } = 0 } ^ { T } P ( s _ { t + 1 } | s _ { t } , \lambda _ { t } , \phi ) Q ( \lambda _ { t } | s _ { t } ; \phi ) ) } ) } \\ & { = \int d \lambda _ { u x : U } Q _ { K } ( \lambda _ { u x } | \tau ; \phi ) \log ( \displaystyle \prod _ { t = 0 } ^ { T } \frac { P ( a _ { t } , \lambda _ { t } | s _ { t } , \xi ) } { Q ( \lambda _ { t } | s _ { t } , \phi ) } ) } \\ & { = \int d \lambda _ { u x : U } Q _ { K } ( \lambda _ { u x } | \tau ; \phi ) \displaystyle \sum _ { t = 0 } ^ { T } ( \log \frac { P ( a _ { t } , \lambda _ { t } | s _ { t } , \xi ) } { Q ( \lambda _ { t } | s _ { t } , \phi ) } ) } \\ & { = \int d \lambda _ { u x : U } Q _ { K } ( \lambda _ { u x } | \tau ; \phi ) \displaystyle \sum _ { t = 0 } ^ { T } ( \log \frac { P ( a _ { t } | \lambda _ { t } | s _ { t } , \lambda _ { t } , \phi ) } { Q ( \lambda _ { t } | s _ { t } , \phi ) } ) } \\ & { = \int d \lambda _ { u x : U } Q _ { K } ( \lambda _ { u x } | \tau ; \phi ) \displaystyle \sum _ { t = 0 } ^ { T } ( \log \frac { P ( a _ { t } | \lambda _ { t } | s _ { t } , \lambda _ { t } , \phi ) P ( \lambda _ { t } | s _ { t } ) } { Q ( \lambda _ { t } | s _ { t } , \phi ) } ) } \\ &  = \displaystyle \int d \lambda _ { u x : U } Q _ { K } ( \lambda _ { u x } | \tau ; \phi ) \displaystyle \sum _ { t ^ { \prime } = 0 } ^ { T } ( \log P ( \lambda _ { t } | \lambda _ { t } , \xi ) \end{array}
+$$
+
+The right-hand side in Equation (32) is called the evidence lower bound (ELBO), which we can maximize as a proxy for (16). The standard choice is to use maximum-entropy standard-normal priors: $P ( \lambda _ { t } | \mathbf { s } _ { t } ) \bar { { \mathbf { \psi } } } = \dot { N } ( \mathbf { 0 } , \mathbf { 1 } )$ . We can then optimize (32) using e.g. stochastic gradient ascent.
+
+# 8.2 TRAINING
+
+Training method. We used the A3C method with 5-20 threads for all our experiments. Each thread performed SGD with (??). The loss for the value function at each state $\mathbf { s } _ { t }$ is the standard $L _ { 2 }$ -loss between the observed total rewards for each agent $i$ and its value estimate:
+
+$$
+\alpha \sum _ { t } \sum _ { i } \left( V ^ { i } ( \mathbf { s } _ { t } ) - R ^ { i } ( \mathbf { s } _ { t } , \mathbf { a } _ { t } ) \right) ^ { 2 } .
+$$
+
+In addition, in line with other work using actor-critic methods, we found that adding a small entropy regularization on the policy can sometimes positively influence performance, but this does not seem to be always required for our testbeds. The entropy regularization is:
+
+$$
+H ( P ) = - \beta \sum _ { t } \sum _ { { \bf { a } } _ { t } } P ( { \bf { a } } _ { t } | { \bf { s } } _ { t } ; \pmb { \theta } ) \log P ( { \bf { a } } _ { t } | { \bf { s } } _ { t } ; \pmb { \theta } ) .
+$$
+
+A3C additionally defines training minibatches in terms of a fixed number of environment steps $L$ : a smaller $L$ gives faster training with higher variance and a higher $L$ vice versa.
+
+Hyperparameter search. For experiments, we performed a random search over hyperparameters:
+
+Table 2: Search range of hyper-parameters.   
+
+<table><tr><td>Hyperparameter</td><td></td><td>Search range</td></tr><tr><td>Learning-rate</td><td>n</td><td>[10-6,10-1]</td></tr><tr><td>Discount</td><td>Y</td><td>[0.9, 0.99]</td></tr><tr><td>GAE discount</td><td>T</td><td>[0.9, 0.99]</td></tr><tr><td>Value loss</td><td>α</td><td>[0.1, 0.5]</td></tr><tr><td>Policy entropy</td><td>β</td><td>[0, 0.01]</td></tr></table>
+
+# 8.3 RESULTS
+
+![](images/3bd9a5038376aaf9032942966b648affa0a551b69109db2c38107e8dad165be0.jpg)  
+Figure 7: Train-time cumulative terminal reward in $( N , M , 1 , 1 0 0 0 )$ Hare-Hunters (upper) and Stag-Hunters (lower) on a $5 0 \times 5 0$ gridworld, for 10-vs-10 or 20-vs-20 agents; randomly moving or fixed preys. Average, minimal and maximal rewards for the best 5 runs for each model are shown. MACE accumulates increasingly higher rewards compared to the baselines.

parse/train/HyunpgbR-/HyunpgbR-_content_list.json

@@ -0,0 +1,1824 @@
+[
+    {
+        "type": "text",
+        "text": "STRUCTURED EXPLORATION VIA HIERARCHICAL VARIATIONAL POLICY NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            99,
+            785,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            171,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            234,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Reinforcement learning in environments with large state-action spaces is challenging, as exploration can be highly inefficient. Even if the dynamics are simple, the optimal policy can be combinatorially hard to discover. In this work, we propose a hierarchical approach to structured exploration to improve the sample efficiency of on-policy exploration in large state-action spaces. The key idea is to model a stochastic policy as a hierarchical latent variable model, which can learn low-dimensional structure in the state-action space, and to define exploration by sampling from the low-dimensional latent space. This approach enables lower sample complexity, while preserving policy expressivity. In order to make learning tractable, we derive a joint learning and exploration strategy by combining hierarchical variational inference with actor-critic learning. The benefits of our learning approach are that 1) it is principled, 2) simple to implement, 3) easily scalable to settings with many actions and 4) easily composable with existing deep learning approaches. We demonstrate the effectiveness of our approach on learning a deep centralized multi-agent policy, as multi-agent environments naturally have an exponentially large state-action space. In this setting, the latent hierarchy implements a form of multi-agent coordination during exploration and execution (MACE). We demonstrate empirically that MACE can more efficiently learn optimal policies in challenging multi-agent games with a large number $( \\sim 2 0 )$ of agents, compared to conventional baselines. Moreover, we show that our hierarchical structure leads to meaningful agent coordination. ",
+        "bbox": [
+            233,
+            267,
+            766,
+            558
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            585,
+            336,
+            602
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Reinforcement learning in environments with large state-action spaces is challenging, as exploration can be highly inefficient in high-dimensional spaces. Hence, even if the environment dynamics are simple, the optimal policy can be combinatorially hard to discover. However, for many large-scale environments, the high-dimensional state-action space has (often hidden or implicit) low-dimensional structure which can be exploited. ",
+        "bbox": [
+            174,
+            617,
+            823,
+            686
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Many natural examples are in collaborative multi-agent problems, whose state-action space is exponentially large in the number of agents, but have a low-dimensional coordination structure. Consider a simple variant of the Hare-Hunters problem (see Figure 1). In this game, $N = 2$ identical hunters need to capture $M = 2$ identical static prey within $T$ time-steps, and exactly $H = 1$ hunter is needed to capture each prey. $T$ is set such that no hunter can capture both preys. There are two equivalent solutions: hunter 1 captures prey 1 and hunter 2 captures prey 2, or vice versa. There are also two suboptimal choices: both hunters choose the same prey. ",
+        "bbox": [
+            174,
+            694,
+            647,
+            819
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/c262eb1189a74a0fc8fe497bdf4533ad17564d721f022c0d67a4aa8db0173b0d.jpg",
+        "image_caption": [
+            "Figure 1: Equivalent solutions in a 2-hunter 2- prey game. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            658,
+            695,
+            823,
+            760
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Hence, the hunters must coordinate over a (large) number of time-steps to maximize their reward.   \nThis implies the solution space has low-dimensional structure that can be used to accelerate training. ",
+        "bbox": [
+            176,
+            819,
+            825,
+            847
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this work, we propose a principled approach to structured exploration to improve sample complexity in large state-action spaces, by learning deep hierarchical policies with a latent structure. As a highlevel intuition, consider a tabular multi-agent policy, which maps discrete (joint) states to action probabilities. For $N$ agents with $S$ states and $A$ actions each, this policy has ${ \\bf \\bar { \\cal O } } ( ( { \\cal S } \\cdot { \\cal A } ) ^ { N } )$ weights. However, the low-dimensional coordination structure can be captured by a factorized, low-rank matrix, where the factorization can be learned and, for instance, only has $O ( N K ( S + A ) )$ weights. Similarly, our approach both 1) learns a low-dimensional factorization of the policy distribution and 2) defines exploration by also sampling from the low-dimensional latent space. For instance, in the multi-agent setting, we can learn a centralized multi-agent policy with a latent structure that encodes coordination between agents and biases exploration towards policies that encode “good” coordination. ",
+        "bbox": [
+            174,
+            854,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            826,
+            186
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The key ideas of our approach are: 1) to utilize a shared stochastic latent variable model that defines the structured exploration policy, and 2) to employ a principled variational method to learn the posterior distribution over the latents jointly with the optimal policy. Our approach has several desirable properties. First we do not incorporate any form of prior domain knowledge, but rather discover the coordination structure purely from empirical experience during learning. Second, our variational learning method enables fully differentiable end-to-end training of the entire policy class. Finally, by utilizing a hierarchical policy class, our approach can easily scale to large action spaces (e.g. a large number of coordinating agents). Our approach can also be seen as a deep hierarchical generalization of Thompson sampling, which is a historically popular way to capture correlations between actions (e.g. in the bandit setting (Agrawal & Goyal, 2012)). ",
+        "bbox": [
+            173,
+            194,
+            825,
+            333
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To summarize, our contributions in this work are as follows: ",
+        "bbox": [
+            173,
+            340,
+            566,
+            354
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• We introduce a structured probabilistic policy class that uses a hierarchy of stochastic latent variables.   \n• We propose an efficient and principled algorithm using variational methods to train the policy end-to-end. To validate our learning framework, we introduce several synthetic multi-agent environments that explicitly require team coordination, and feature competitive pressures that are characteristic of many coordinated decision problems.   \n• We empirically verify that our approach improves sample complexity on coordination games with a large number $N \\sim 2 0$ ) of agents.   \n• We show that learned latent structures correlate with meaningful coordination patterns. ",
+        "bbox": [
+            215,
+            364,
+            825,
+            518
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 COOPERATIVE MULTI-AGENT REINFORCEMENT LEARNING",
+        "text_level": 1,
+        "bbox": [
+            174,
+            537,
+            699,
+            554
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We use multi-agent environments to show the efficacy of our approach to structured exploration, as they naturally exhibit exponentially large state-action spaces. In this work we focus on efficiently learning a centralized policy: a joint policy model for all agents, in the full-information setting. More generally, multi-agent problems can be generalized along many dimensions, e.g. one can learn decentralized policies in partial-information settings. For an overview, see Busoniu et al. (2008). ",
+        "bbox": [
+            174,
+            568,
+            825,
+            637
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In multi-agent RL, agents sequentially interact within an environment defined by the tuple: ${ \\mathcal { E } } \\equiv$ $( \\mathbf { S } , \\mathbf { A } , \\mathbf { r } , \\bar { f _ { P } } )$ . Each agent $i$ starts in an initial state $s _ { 0 } ^ { i }$ , and at each time $t$ observes a state $\\mathbf { s } _ { t } \\in \\mathbf { S }$ and executes an action $a _ { t } ^ { i }$ chosen by a (stochastic) policy $a _ { t } ^ { i } \\sim P \\left( a _ { t } ^ { i } | \\mathbf { s } _ { t } \\right)$ . Each agent then receives a reward $r ^ { i } \\left( \\mathbf { s } _ { t } , \\mathbf { a } _ { t } \\right)$ , and the environment transitions to a new state $\\mathbf { s } _ { t + 1 }$ with probability $f _ { P } \\left( \\mathbf { s } _ { t + 1 } \\big | \\mathbf { s } _ { t } , \\mathbf { a } _ { t } \\right)$ We define the joint state and actions as $\\mathbf { s } _ { t } = \\{ s _ { t } ^ { i } \\in \\mathbf { S } \\}$ and $\\mathbf { a } _ { t } = \\{ a _ { t } ^ { i } \\in \\bar { \\mathbf { A } } \\bar { } \\}$ , where $i \\in \\mathcal { T }$ indexes the agents. Note that the rewards for each agent $r ^ { i }$ can depend on the full joint state and actions. ",
+        "bbox": [
+            173,
+            643,
+            825,
+            733
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this work, we restrict to fully cooperative MDPs that are fully observable, deterministic and episodic. Each agent can see the full state s, $f _ { P }$ is deterministic and each episode $\\boldsymbol { \\tau } = \\left( \\mathbf { s } _ { t } , \\mathbf { a } _ { t } \\right) _ { 0 \\leq t \\leq T }$ ends when the agent encounters a terminal state and the MDP resets. ",
+        "bbox": [
+            174,
+            738,
+            825,
+            782
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In the fully cooperative case, the goal for each agent is to learn its optimal policy $P ^ { * } \\left( a _ { t } ^ { i } | \\mathbf { s } _ { t } , \\pmb \\theta \\right)$ that maximizes the total reward $\\begin{array} { r } { R ( \\tau ) = \\sum _ { i } R ^ { i } ( \\tau ) = \\sum _ { i } \\sum _ { t } r ^ { i } ( { \\bf s } _ { t } , { \\bf a } _ { t } ) } \\end{array}$ : ",
+        "bbox": [
+            169,
+            789,
+            825,
+            821
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/da0a8491e92c692d59d17624d0b3dd05ea9b56e80b67d9d98424b4ec64f11a25.jpg",
+        "text": "$$\n\\operatorname* { m a x } _ { \\pmb { \\theta } } J ( \\pmb { \\theta } ) = \\operatorname* { m a x } _ { \\pmb { \\theta } } \\sum _ { i \\in \\mathcal { I } } J ^ { i } ( \\pmb { \\theta } ) , J ^ { i } ( \\pmb { \\theta } ) = \\mathbb { E } \\left[ \\left. R ^ { i } \\left( \\tau \\right) \\right| \\mathbf { a } _ { t } \\sim P ( \\mathbf { a } _ { t } | \\mathbf { s } _ { t } ; \\pmb { \\theta } ) \\right]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            269,
+            823,
+            723,
+            856
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To optimize, we can apply gradient descent with policy gradient estimators $\\scriptstyle { \\hat { g } } _ { \\theta }$ (Williams (1992)) ",
+        "bbox": [
+            174,
+            862,
+            805,
+            878
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/02fc4bf10b9de8280864aa887000e0152609116513e1b4ba60fb43b6839a3bfe.jpg",
+        "text": "$$\ng _ { \\theta } = \\nabla _ { \\theta } J \\left( \\theta \\right) = \\mathbb { E } \\left[ \\nabla _ { \\theta } \\log P ( \\mathbf { a } _ { t } | \\mathbf { s } _ { t } ; \\theta ) R ( \\tau ) | \\mathbf { a } _ { t } , \\mathbf { s } _ { t } \\right] \\approx \\frac { 1 } { M } \\sum _ { k = 1 } ^ { M } \\sum _ { t } \\nabla _ { \\theta } \\log P ( \\mathbf { a } _ { t } ^ { k } | \\mathbf { s } _ { t } ^ { k } ; \\theta ) R ( \\tau ^ { k } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            183,
+            878,
+            794,
+            922
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/3bf752868df2d590bcfe77fa15be68b612a392b010471c3f46cd1ced42a48bf4.jpg",
+        "image_caption": [
+            "Figure 2: Structured latent variable model of the multi-agent policy (actor, left) and instance of the multi-agent actor-critic interacting in the environment $\\mathcal { E }$ (right). The joint policy contains two stacked layers of stochastic latent variables (red), and deterministically receives states and computes actions (green). Global variables $\\lambda$ are shared across agents. On the right, a neural network instance of the actor-critic uses the reparametrization trick and receives the environment state, samples actions from the policy for all agents and computes value functions $V ^ { \\bullet }$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            232,
+            99,
+            779,
+            227
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where we sample $M$ rollouts $\\tau ^ { k }$ by sampling actions from the policy that is being learned. ",
+        "bbox": [
+            171,
+            349,
+            763,
+            364
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "A central issue in reinforcement learning is the exploration-exploitation trade-off: how can agents sample rollouts and learn efficiently? In particular, when the state-action space is exponentially large, discovering good (coordinated) policies when each agent samples independently becomes combinatorially intractable as $N$ grows. Hence, exploration in large state-action spaces poses a significant challenge. ",
+        "bbox": [
+            174,
+            371,
+            825,
+            441
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.1 MACE: JOINT COORDINATION AND EXPLORATION",
+        "text_level": 1,
+        "bbox": [
+            174,
+            458,
+            568,
+            472
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We now formulate our multi-agent objective (1) using a hierarchical policy class that enables structured exploration. Our approach, MACE (“Multi-Agent Coordinated Exploration”), builds upon two complementary approaches: ",
+        "bbox": [
+            176,
+            483,
+            825,
+            526
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "• Encode structured exploration by sampling actions that are correlated between agents. The correlation between actions encodes coordination. • Use a variational approach to derive and optimize a lower bound on the objective (1). ",
+        "bbox": [
+            215,
+            537,
+            823,
+            585
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Hierarchical Latent Model. To encode coordination between agents, we assume the individual policies have shared structure, encoded by a latent variable $\\lambda _ { t } \\in \\mathbb { R } ^ { n }$ for all $t$ , where $n$ is the dimension of the latent space. This leads to a hierarchical policy model $\\begin{array} { r } { P ( \\mathbf { a } _ { t } , \\lambda _ { t } | \\mathbf { s } _ { t } ) } \\end{array}$ , as shown in Figure 2. We first write the joint policy for a single time-step as: ",
+        "bbox": [
+            174,
+            597,
+            825,
+            654
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8b85b660b432797a3f93e3dfb75152d32dd0078a8f24c7d15b21fb15ffa94f6e.jpg",
+        "text": "$$\nP ( \\mathbf { a } _ { t } | \\mathbf { s } _ { t } ) = \\int d \\lambda _ { t } P ( \\mathbf { a } _ { t } , \\lambda _ { t } | \\mathbf { s } _ { t } ) = \\int d \\lambda _ { t } \\prod _ { i = 1 } ^ { N } P ( a _ { t } ^ { i } , \\lambda _ { t } | \\mathbf { s } _ { t } ) = \\int d \\lambda _ { t } \\prod _ { i = 1 } ^ { N } P ( a _ { t } ^ { i } | \\lambda _ { t } , \\mathbf { s } _ { t } ) P ( \\lambda _ { t } | \\mathbf { s } _ { t } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            186,
+            659,
+            789,
+            703
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where we introduced the conditional priors $P ( \\lambda _ { t } | \\mathbf { s } _ { t } )$ . The latent variables $\\lambda _ { t }$ introduce dependencies among the $\\mathbf { a } _ { t }$ , hence this policy is more flexible compared to standard fully factorized policies (Ranganath et al. (2015)). Note that this approach supports centralized learning and decentralized execution, by sharing a random seed amongst agents to sample $\\lambda _ { t }$ and actions $\\mathbf { a } _ { t }$ during execution. ",
+        "bbox": [
+            176,
+            708,
+            823,
+            765
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Computing the integral in the optimal policy (3) is hard, because the unknown distribution $P ( a _ { t } ^ { i } | \\lambda _ { t } , \\mathbf { s } _ { t } )$ can be highly complex. Hence, to make learning (3) tractable, we will use a variational approach. ",
+        "bbox": [
+            174,
+            771,
+            823,
+            801
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Hierarchical Variational Lower Bound. We next derive a tractable learning algorithm using variational methods. Instead of directly optimizing (1), we cast it as a probabilistic inference problem, as in Levine & Koltun (2013); Vlassis et al. (2009), and instead optimize a lower bound. To do so, we assume that the total reward $R ^ { i }$ for each $i$ to be non-negative and bounded. Hence, we can view the total reward $R ( \\tau )$ as a random variable, whose unnormalized distribution is defined as $P ( R | \\tau ) = R$ . We can then rewrite (1) as a maximum likelihood problem: ",
+        "bbox": [
+            173,
+            806,
+            826,
+            891
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e0531e294e0e307d8b808b2a78a2646ed4d09505b37822297c16922a6c097fe4.jpg",
+        "text": "$$\n\\operatorname* { m a x } _ { \\pmb { \\theta } } \\mathbb { E } _ { \\pi ( \\mathbf { s } _ { t } ; \\pmb { \\theta } ) } \\left[ R \\right] = \\operatorname* { m a x } _ { \\pmb { \\theta } } \\mathbb { E } _ { \\pi ( \\mathbf { s } _ { t } ; \\pmb { \\theta } ) } \\left[ P ( R | \\tau ) \\right]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            356,
+            897,
+            640,
+            920
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Hence, the RL objective is equivalent to a maximal likelihood problem: ",
+        "bbox": [
+            174,
+            102,
+            642,
+            118
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f27c6e69b2e1a853469b232a8fb52fdb2bb74072bdcd6737cebdec49cec50e74.jpg",
+        "text": "$$\n\\operatorname* { m a x } _ { \\theta } \\mathbb { E } _ { \\pi ( s _ { t } ; \\theta ) } \\left[ P ( R | \\tau ) \\right] = \\operatorname* { m a x } _ { \\theta } \\int d \\tau P ( R | \\tau ) P ( \\tau ; \\theta ) \\Leftrightarrow \\operatorname* { m a x } _ { \\theta } \\int d \\tau \\log P ( R | \\tau ) P ( \\tau ; \\theta ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            199,
+            121,
+            777,
+            154
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In MACE we introduce a latent variable $\\lambda _ { t }$ in the probability of a rollout $\\tau$ , using (3): ",
+        "bbox": [
+            173,
+            156,
+            727,
+            171
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a0a4cc9e7b69896ede105d62744e7b2cfa5e0e33d871555986c59c6e2d0d384c.jpg",
+        "text": "$$\nP ( \\tau ; \\pmb { \\theta } ) = P ( \\mathbf { s } _ { 0 } ) \\int d \\lambda _ { 0 : T } \\prod _ { t = 0 } ^ { T } P ( \\mathbf { s } _ { t + 1 } | \\mathbf { s } _ { t } , \\mathbf { a } _ { t } ) P ( \\mathbf { a } _ { t } , \\lambda _ { t } | \\mathbf { s } _ { t } ; \\pmb { \\theta } ) , \\quad \\int d \\lambda _ { 0 : T } \\equiv \\prod _ { t = 0 } ^ { T } \\int d \\lambda _ { t } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            215,
+            175,
+            781,
+            218
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where computing the policy distribution $P ( \\mathbf { a } _ { t } , \\lambda _ { t } | \\mathbf { s } _ { t } ; \\pmb \\theta )$ is intractable, which makes the maximization in Equation (5) hard. Hence, we derive a lower bound on the log-likelihood $\\log P ( R | \\tau ) P ( \\tau ; \\pmb \\theta )$ in Equation (5), using a variational approach. Specifically, we use an approximate factorized variational distribution $Q _ { R }$ that is weighted by the total reward $R$ : ",
+        "bbox": [
+            173,
+            222,
+            826,
+            279
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d319685c1270dcf0e608c8eb8a0ad260278a6636e1a4fe24c7a6894255ac144d.jpg",
+        "text": "$$\nQ _ { R } ( \\lambda _ { 0 : T } | \\tau ; \\phi ) = P ( R | \\tau ) P ( \\mathbf { s } _ { 0 } ) \\prod _ { t = 0 } ^ { T } P ( \\mathbf { s } _ { t + 1 } | \\mathbf { s } _ { t } , \\mathbf { a } _ { t } ) Q ( \\lambda _ { t } | \\mathbf { s } _ { t } ; \\phi ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            290,
+            281,
+            705,
+            325
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\phi$ are the parameters for the variational distribution $Q _ { R }$ . Using Jensen’s inequality (Hoffman et al., 2013) and (3) to factorize $P ( \\mathbf { a } _ { t } , \\lambda _ { t } | \\mathbf { s } _ { t } ; \\pmb \\theta )$ , we can derive: ",
+        "bbox": [
+            174,
+            327,
+            823,
+            357
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e408cf0ce90c3c329fe6b3bd8219e67255f156807c1015ab850e81047d530926.jpg",
+        "text": "$$\n\\log P ( R | \\tau ) P ( \\tau ; \\pmb \\theta ) \\geq \\underbrace { \\int d \\lambda _ { 0 : T } Q _ { R } ( \\lambda _ { 0 : T } | \\tau ; \\phi ) \\sum _ { t = 0 } ^ { T } \\left( \\log P ( \\mathbf a _ { t } | \\lambda _ { t } , \\pmb s _ { t } ; \\pmb \\theta ) + \\log \\frac { P ( \\lambda _ { t } | \\pmb s _ { t } ) } { Q ( \\lambda _ { t } | \\pmb s _ { t } , \\phi ) } \\right) } _ { \\mathrm { E L B O } ( Q _ { R } , \\pmb \\theta , \\phi ) } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            183,
+            361,
+            792,
+            421
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where the right-hand side is called the evidence lower bound (ELBO), which we can maximize as a proxy for (4). For more details on the derivation, see the Appendix. ",
+        "bbox": [
+            171,
+            428,
+            825,
+            457
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The standard choice for the prior $P ( \\lambda _ { t } | \\mathbf { s } _ { t } )$ is to use maximum-entropy standard-normal priors: $P ( \\lambda _ { t } | \\mathbf { s } _ { t } ) = \\mathcal { N } ( \\mathbf { 0 } , \\mathbf { 1 } )$ . We can then optimize (8) using e.g. stochastic gradient ascent. Formally, the MACE policy gradient is: ",
+        "bbox": [
+            174,
+            462,
+            825,
+            506
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e49a219508f1378b4c3a54b66603b7646489d0e71ec713bcb3ce6e8ae396145e.jpg",
+        "text": "$$\n\\begin{array} { r l } { g _ { \\theta } \\approx g _ { \\theta , Q } = \\nabla _ { \\theta } \\mathrm { E } \\mathrm { L } \\mathrm { B O } ( Q _ { R } , \\theta , \\phi ) } & { = \\displaystyle \\int d \\tau d \\lambda _ { 0 : T } Q _ { R } ( \\lambda _ { 0 : T } | \\tau ; \\phi ) \\sum _ { t ^ { \\prime } = 0 } ^ { T } \\nabla _ { \\theta } \\log P ( \\mathbf { a } _ { t ^ { \\prime } } | \\lambda _ { t ^ { \\prime } } , \\mathbf { s } _ { t ^ { \\prime } } ; \\theta ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            183,
+            507,
+            812,
+            553
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "which is an approximation of the true policy gradient (2). This gradient can be estimated using sampled roll-outs $\\tau ^ { k }$ of the policy $P ^ { \\pi }$ : ",
+        "bbox": [
+            173,
+            569,
+            825,
+            599
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9893241c1ba12fd83676ee5f1e8686c5be0c5eaedcd6c000aa535149c9f5bc19.jpg",
+        "text": "$$\n\\boldsymbol { g } _ { \\theta , Q } \\approx \\widehat { \\boldsymbol { g } } _ { \\theta , Q } = \\frac { 1 } { M } \\sum _ { k = 1 } ^ { M } \\sum _ { t = 0 } ^ { T } \\nabla _ { \\theta } \\log P \\left( \\mathbf { a } _ { t } ^ { k } | \\boldsymbol { \\lambda } _ { t } ^ { k } , \\mathbf { s } _ { t } ^ { k } ; \\theta \\right) \\boldsymbol { R } ( \\boldsymbol { \\tau } ^ { k } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            303,
+            602,
+            694,
+            646
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "During a rollout $\\tau ^ { k }$ , we sample $\\lambda \\sim Q$ , observe rewards $R \\sim P ( R | \\tau )$ and transitions $s _ { t + 1 } \\sim$ $P ( s _ { t + 1 } | . )$ , and use these to compute (10). We can similarly compute $g _ { \\phi , Q } = \\nabla _ { \\phi } \\mathrm { E L B O } ( Q _ { R } , \\pmb \\theta , \\phi )$ , the gradient for the variational posterior $Q _ { R }$ . ",
+        "bbox": [
+            174,
+            650,
+            826,
+            694
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Actor-Critic and Bias-Variance. Estimating policy gradients $g _ { \\pmb { \\theta } }$ using empirical rewards can suffer from high variance and instabilities. It is thus useful to consider more general objectives $F ^ { i }$ : ",
+        "bbox": [
+            173,
+            699,
+            825,
+            728
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/42bad2f43012cb8f9bbed550fd37aca104bf87f297f00c7bcdd313647fc0c4bc.jpg",
+        "text": "$$\nJ ^ { i } ( \\pmb { \\theta } ) = \\mathbb { E } \\left[ F ^ { i } \\left( \\tau \\right) \\middle | \\mathbf { a } _ { t } \\sim P ^ { \\pi _ { t } } ( \\mathbf { a } _ { t } | \\mathbf { s } _ { t } ; \\pmb { \\theta } ) \\right] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            361,
+            731,
+            635,
+            751
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "such that the variance in $\\hat { g }$ is reduced.1 In practice, we find that using (10) with more general $F$ , such as generalized advantages (Schulman et al. (2015)), performs quite well. ",
+        "bbox": [
+            171,
+            755,
+            825,
+            785
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 EXPERIMENTAL VALIDATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            803,
+            449,
+            820
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 MULTI-AGENT ENVIRONMENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            833,
+            434,
+            848
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To validate our approach, we created two grid-world games, depicted in Figure 2, inspired by the classic Predator-Prey and Stag-Hunt games (Shoham & Leyton-Brown (2008)). In both games, the world is periodic and the initial positions of the hunters and prey are randomized. Also, we consider two instances for both games: either the prey are moving or fixed. ",
+        "bbox": [
+            174,
+            859,
+            823,
+            890
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Hare-Hunters. Predator-Prey is a classic test environment for multi-agent learning, where 4 predators try to capture a prey by boxing it in. We consider a variation defined by the settings $( N , \\bar { M } , H , T )$ : $N$ hunters and $M$ prey. Each prey can be captured by exactly $H$ hunters: to capture the prey, a hunter gets next to it, after which the hunter is frozen. Once a prey has had $H$ hunters next to it, it is frozen and cannot be captured by another hunter. The terminal rewards used are: ",
+        "bbox": [
+            174,
+            138,
+            825,
+            209
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e94e48008a1ae5a984b9900a4d835e3fa32973a0c31b31116db001be169f7574.jpg",
+        "text": "$$\nR ^ { i } = { \\left\\{ \\begin{array} { l l } { 1 , } & { { \\mathrm { i f ~ } } a l l { \\mathrm { ~ p r e y ~ a r e ~ c a p t u r e d ~ } } H { \\mathrm { ~ t i m e s ~ b e f o r e ~ t h e ~ t i m e ~ l i m i t ~ } } T } \\\\ { 0 , } & { { \\mathrm { o t h e r w i s e } } } \\end{array} \\right. }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            274,
+            219,
+            722,
+            255
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The challenge of the game is for the agents to inactivate all prey within a finite time $T$ . Due to the time limit, the optimal strategy is for the agents to distribute targets efficiently, which can be challenging due to the combinatorially large number of possible hunter-to-prey assignments. ",
+        "bbox": [
+            174,
+            263,
+            823,
+            308
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Stag-Hunters. The Stag-Hunt is another classic multi-agent game designed to study coordination. In this game, hunters have a choice: either they capture a hare for low reward, or, together with another hunter, capture a stag for a high reward. We extend this to the multi-agent $( N , M , H , T )$ -setting: $N$ hunters hunt $M$ prey $M / 2$ stags and $M / 2$ hares). Each stag has $H$ hit-points, while hares and hunters have 1 hit-point. Capturing is as in Hare-Hunters. The spatial domain is similar to the Hare-Hunters game and we also use a time limit $T$ . The terminal reward is now defined as: ",
+        "bbox": [
+            173,
+            313,
+            825,
+            397
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/274657a8db8bff1ed4594a2f2ebc642f7ef44438b1305f5d1491e9fa47773bdf.jpg",
+        "text": "$$\nR ^ { i } = \\left\\{ \\begin{array} { l l } { 1 , } & { \\mathrm { i f ~ } i \\mathrm { ~ c a p t u r e d ~ a l i v e ~ s t a g ~ t h a t ~ b e c a m e ~ i n a c t i v e ~ b e f o r e ~ t h e ~ t i r } } \\\\ { 0 . 1 , } & { \\mathrm { i f ~ } i \\mathrm { ~ c a p t u r e d ~ a ~ l i v e ~ h a r e ~ b e f o r e ~ t h e ~ t i m e ~ l i m i t ~ } T } \\\\ { 0 , } & { \\mathrm { o t h e r w i s e } } \\end{array} \\right.\n$$",
+        "text_format": "latex",
+        "bbox": [
+            227,
+            409,
+            700,
+            460
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The challenge for the agents here is to discover that choosing to capture the same prey can yield substantially higher reward, but this requires coordinating with another hunter. ",
+        "bbox": [
+            173,
+            469,
+            823,
+            498
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 NEURAL COORDINATION MODEL ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            517,
+            444,
+            532
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For experiments, we instantiated our multi-agent policy class (as in Figure 2) with deep neural networks. For simplicity, we only used reactive policies without memory, although it is straightforward to apply MACE to policies with memory (e.g. LSTMs). The model takes a joint state $\\mathbf { s } _ { t }$ as input and computes features $\\phi ( \\mathbf { s } )$ using a 2-layer convolutional neural network. To compute the latent variable $\\boldsymbol { \\bar { \\lambda } } \\in \\mathbb { R } ^ { d }$ , we use the reparametrization trick (Kingma & Welling, 2013) to learn the variational distribution (e.g. $Q ( \\lambda | \\mathbf { s } ) )$ , sampling $\\lambda$ via $\\epsilon \\sim \\mathcal { N } ( \\mathbf { 0 } , \\mathbf { 1 } )$ and distribution parameters $\\mu , \\sigma$ (omitting $t$ ): ",
+        "bbox": [
+            173,
+            544,
+            826,
+            630
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/518f72b20419667fedcfa978f0d4b45b91b4692c4285cd207b142a199db0152e.jpg",
+        "text": "$$\n\\mu ( \\mathbf { s } ) = W _ { \\mu } \\phi ( \\mathbf { s } ) + b _ { \\mu } , \\quad \\log \\sigma ( \\mathbf { s } ) ^ { 2 } = W _ { \\sigma } \\phi ( \\mathbf { s } ) + b _ { \\sigma } , \\quad \\lambda = \\mu ( \\mathbf { s } ) + \\sigma ( \\mathbf { s } ) \\odot \\epsilon .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            245,
+            638,
+            751,
+            657
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Given $\\lambda$ , the model then computes the policies $P ( a ^ { i } | \\lambda , \\mathbf { s } )$ and value functions $V ^ { i } ( \\mathbf { s } )$ as (omitting $t$ ): ",
+        "bbox": [
+            174,
+            667,
+            826,
+            684
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8411131e614500816eb354581c5b0548f865c62ba81854b1c4d8676449fbc928.jpg",
+        "text": "$$\nP ( a ^ { i } | \\lambda , \\mathbf { s } ) = \\mathsf { s o f t m a x } \\left( W _ { \\pi } ^ { i } [ \\lambda ~ \\phi ( \\mathbf { s } ) ] + b _ { \\pi } ^ { i } \\right) , \\quad V ^ { i } ( \\mathbf { s } ) = W _ { V } ^ { i } \\phi ( \\mathbf { s } ) + b _ { V } ^ { i } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            258,
+            693,
+            738,
+            713
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where softma $\\begin{array} { r } { \\mathrm {  ~ \\psi ~ } _ { \\mathrm { { L } } } ( { \\bf x } ) = \\exp { \\bf x } / \\sum _ { j } \\exp { x ^ { j } } } \\end{array}$ . In this way, the model can be trained end-to-end. ",
+        "bbox": [
+            169,
+            722,
+            779,
+            739
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Training. We used A3C (Mnih et al. (2016)) with KL-controlled policy gradients (10), generalized advantage as $F$ (Schulman et al. (2015)). and policy-entropy regularization. For all experiments, we performed a hyper-parameter search and report the best 5 runs seen (see the Appendix for details). ",
+        "bbox": [
+            174,
+            746,
+            825,
+            789
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Baselines. We compared MACE against two natural baselines: ",
+        "bbox": [
+            173,
+            795,
+            578,
+            810
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "• Shared (shared actor-critic): agents share a deterministic hidden layer, but maintain individual weights $\\theta ^ { i }$ for their (stochastic) policy $P ( a | \\lambda , \\mathbf { s } ; \\theta ^ { i } )$ and value function $V ^ { i } ( \\mathbf { s } ; \\pmb \\theta )$ . The key difference is that this model does not sample from the shared hidden layer. Cloned (actor-critic): a model where each agent uses an identical policy and value function with shared weights. There is shared information between the agents, and actions are sampled according to the agents’ own policies. ",
+        "bbox": [
+            215,
+            823,
+            825,
+            915
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/8c625582e478131ef08cee9b51e68833035d058c1f7f3710cae17327dc35d10f.jpg",
+        "image_caption": [
+            "Figure 3: Train-time cumulative terminal reward for $N$ agents in $( N , M , 1 , T )$ Hare-Hunters (upper, $T = 2 0 0 0$ ) and Stag-Hunters (lower, $T = 1 0 0 0 \\mathrm { \\Omega }$ ) on a $5 0 \\times 5 0$ gridworld, for 10-vs-10 or 20-vs-20 agents; randomly moving or fixed preys. Average, minimal and maximal rewards for the best 5 runs for each model are shown. MACE accumulates increasingly higher rewards compared to the baselines, by 1) achieving higher terminal reward per episode and 2) finishing episodes faster (see Figure 4). For 10-10 Stag-Hunters with frozen prey, average reward per-episode is 4.64 (Cloned), 6.22 (Shared), 6.61 (MACE) after 1 million samples. For more, see the Appendix. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            104,
+            825,
+            340
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/aec18be8f5d63baf9f187247eb4654208234a495ff59631db08019cecf6a51ef.jpg",
+        "image_caption": [
+            "Figure 4: Train-time episode lengths during 1 million steps for 10-vs-10 Hare-Hunters (left) and Stag-Hunters (right), with fixed preys. MACE (orange) finishes an episode successfully before the time limit more often than the baselines (Cloned (blue) and Shared (yellow)). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            468,
+            816,
+            577
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 QUANTITATIVE ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            655,
+            423,
+            671
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Above, we defined a variational approach to train hierarchical multi-agent policies using structured exploration. We now validate the efficacy of our approach by showing our method scales to environments with a large number of agents. We ran experiments for both Hare-Hunters and Stag-Hunters for $N = M = 1 0 , 2 0$ in a spatial domain of $5 0 \\times 5 0$ grid cells. ",
+        "bbox": [
+            174,
+            686,
+            825,
+            742
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Sample complexity. In Table 1 we show the achieved rewards after a fixed number of training samples, and Figure 3 showcases the corresponding learning curves. We see that MACE achieves up to $1 0 \\times$ reward compared to the baselines. Figure 4 shows the corresponding distribution of training episode lengths. We see that MACE solves game instances more than $2 0 \\%$ faster than baselines in $5 0 \\%$ $( 1 0 \\% )$ of Hare-Hunters (Stag-Hunters) episodes. In particular, MACE learns to coordinate for higher reward more often: it achieves the highest average reward per-episode (e.g. for 10-10 Stag-Hunters with frozen prey, average rewards are 4.64 (Cloned), 6.22 (Shared), 6.61 (MACE)). Hence, MACE coordinates successfully more often to capture the stags. Together, these results show MACE enables more efficient learning. ",
+        "bbox": [
+            173,
+            750,
+            825,
+            875
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Using the ELBO. A salient difference between (10) and (2) is the KL-regularization, which stems from the derivation of the ELBO. Since we use a more general objective $F$ , c.f. (11), we also investigated the impact of using the KL-regularized policy gradient (10) versus the standard (2). To this end, we ran several instances of the above experiments both with and without KL-regularization. We found that without KL-regularization, training is unstable and prone to mode collapse: the variance $\\sigma$ of the variational distribution can go to 0. This reflects in essentially 0 achieved reward: the model does not solve the game for any reasonable hyperparameter settings. ",
+        "bbox": [
+            176,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/016b708880aba53c4aadcd9380cfad3dfc753d5adf91f90881d9f440c2f467dc.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Table 1: Total terminal reward (averaged over 5 best runs) for $N$ agents for set # of training samples. "
+        ],
+        "table_body": "<table><tr><td>Preys are</td><td colspan=\"2\">Frozen</td><td colspan=\"2\">Moving</td><td colspan=\"2\">Frozen</td><td colspan=\"2\">Moving</td></tr><tr><td>Samples (x100k)</td><td>5</td><td>10</td><td>5</td><td>10</td><td>5</td><td>10</td><td>5</td><td>10</td></tr><tr><td>Hare-Hunters</td><td colspan=\"4\">10-vs-10</td><td colspan=\"4\">20-vs-20</td></tr><tr><td>Cloned</td><td>85.0</td><td>178.3</td><td>465.0</td><td>912.5</td><td>20.0</td><td>70.0</td><td>706.7</td><td>1401.7</td></tr><tr><td>Shared</td><td>65.0</td><td>155.0</td><td>457.5</td><td>923.8</td><td>65.0</td><td>105.0</td><td>491.4</td><td>962.9</td></tr><tr><td>MACE</td><td>240.0</td><td>580.0</td><td>662.7</td><td>1381.8</td><td>200.0</td><td>393.3</td><td>1260.0</td><td>2344.0</td></tr><tr><td>Stag-Hunters</td><td colspan=\"4\">10-vs-10</td><td colspan=\"4\">20-vs-20</td></tr><tr><td>Cloned</td><td>1229.2</td><td>2482.9</td><td>2079.4</td><td>4171.2</td><td>3224.5</td><td>6219.9</td><td>5934.5</td><td>11429.2</td></tr><tr><td>Shared</td><td>1214.5</td><td>2423.7</td><td>2005.7</td><td>4144.3</td><td>3150.7</td><td>6379.8</td><td>6344.4</td><td>12196.8</td></tr><tr><td>MACE</td><td>1515.2</td><td>3047.3</td><td>2275.7</td><td>4610.7</td><td>3799.3</td><td>7158.1</td><td>6880.7</td><td>13358.6</td></tr></table>",
+        "bbox": [
+            189,
+            98,
+            808,
+            257
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/536755bac36a6771a5643f7c332f3df07d3eaa41b7ad473c0c311052fb85c88d.jpg",
+        "image_caption": [
+            "Figure 5: Predators (red) and prey (green) during training for 2v2 Hare-Hunters for 100 episodes. Arrows show where agents move to in the next frame. Top: at the start, predators explore via $\\lambda$ , but do not succeed before the time limit $T$ (red dot). Bottom: after convergence agents succeed consistently (green dot) before the time limit (purple dot) and $\\lambda$ encodes the two strategies from Figure 1. Highlighted $\\lambda$ -components correlate with rollout under a 2-sided $t$ -test at $\\alpha = 0 . 1$ significance. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            297,
+            825,
+            522
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            633,
+            825,
+            690
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Impact of dynamics and $T$ . Inspecting training performance, we see the relative difficulty of capturing moving or randomly moving prey. Capturing moving prey is easier to learn than capturing fixed preys, as comparing rewards in Table 1 shows. This shows a feature of the game dynamics: the expected distance between a hunter and an uncaptured prey are lower when the preys are randomly moving, resulting in an easier game. Comparing Hare-Hunters and Stag-Hunters, we also see the impact of the time limit $T$ . Since we use terminal rewards only, as $T$ gets larger, the reward becomes very sparse and models need more samples to discover good policies. ",
+        "bbox": [
+            174,
+            696,
+            825,
+            795
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5 MODEL INSPECTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            819,
+            377,
+            835
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Beyond training benefits, we now demonstrate empirical evidence that suggest efficacy and meaningfulness of our approach to structured exploration. We start by inspecting the behavior of the latent variable $\\lambda$ for a simple $N = M = 2$ Hare-Hunters game, which enables semantic inspection of the learned policies, as in Figure 5. We make a number of observations. First, $\\lambda$ is relevant: many components are statistically significantly correlated with the agents’ actions. This suggests the model does indeed use the latent $\\lambda$ : it (partly) controls the coordination between agents.2 Second, the latent $\\lambda$ shows strong correlation during all phases of training. This suggests that the model indeed is performing a form of structured exploration. Third, the components of $\\lambda$ are correlated with semantic meaningful behavior. We show a salient example in the bottom 2 rows in Figure 5: the correlated components of $\\lambda$ are disjoint and each component correlates with both agents. The executed policies are exactly the two equivalent ways to assign 2 hunters to 2 preys, as illustrated in Figure 1. ",
+        "bbox": [
+            174,
+            853,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/cdc1d6ab373edf1e5fc1d2b8bc82e1de03d08d996b8c46e0e7bd4bf4d5f0fbc6.jpg",
+        "image_caption": [
+            "Figure 6: Visualization of MACE for a $( 1 0 , 1 0 , 1 , 1 0 0 0 )$ Hare-Hunters game in a $3 0 \\times 3 0$ world. Left: components of the latent code $\\lambda$ that significantly correlate with sampled actions (computed as in Figure 5). Right: Three episode snapshots: at the start, middle and end. Red: predators; green: prey. Arrows indicate where agents move to in the next snapshot. The hunters solve the game (green dot) before the time limit $T = 1 0 0 0$ (purple dot), by distributing targets amongst themselves. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            99,
+            820,
+            223
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            333,
+            825,
+            417
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Coordination with a large $N$ . In the large $N = M = 1 0$ case, the dynamics of the agent collective are a generalization of the $N = M = 2$ case. There are now redundancies in multi-agent hunter-prey assignments that are analogous to the $N = M = 2$ case that are prohibitively complex to analyze due to combinatorial complexity. However our experiments strongly suggest (see e.g. Figure 6) the latent code is again correlated with the agents’ behavior during all phases of training, showing that $\\lambda$ induces meaningful multi-agent coordination. ",
+        "bbox": [
+            174,
+            424,
+            825,
+            507
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            530,
+            344,
+            546
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Deep Structured Inference. Recent works have focused on learning structured representations using expressive distributions, which enable more powerful probabilistic inference. For instance, Johnson et al. (2016) has proposed combining neural networks with graphical models, while Ranganath et al. (2015) learn hierarchical latent distributions. Our work builds upon these approaches to learn structured policies in the reinforcement learning setting. In the multi-agent setting, the RL problem has also been considered as an inference problem in e.g. (Liu et al., 2015; Wu et al., 2013; Liu et al., 2016). ",
+        "bbox": [
+            174,
+            564,
+            825,
+            661
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Variational methods in RL. Neumann (2011); Furmston & Barber (2010) discuss variational approaches for RL problems, but did not consider end-to-end trainable models. Levine & Koltun (2013) used variational methods for guided policy search. Houthooft et al. (2016) learned exploration policies via information gain using variational methods. However, these only consider 1 agent. ",
+        "bbox": [
+            174,
+            667,
+            825,
+            724
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Coordination in RL. Multi-agent coordination has been studied in the RL community (e.g. Guestrin et al. (2002); Kapetanakis & Kudenko (2002); Chalkiadakis & Boutilier (2003)), for instance, as a method to reduce the instability of multiple agents learning simultaneously using RL. The benefit of coordination was already demonstrated in simple multi-agent settings in e.g. Tan (1993). The shared latent variable $\\lambda$ of our structured policy can also be interpreted as a learned correlation device (see Bernstein (2005) for an example in the decentralized setting), which can be used to e.g. break ties between alternatives or induce coordination between agents. More generally, they can be used to achieve correlated equilibria (Greenwald & Hall, 2003), a more general solution concept than Nash equilibria. However, previous methods learned hand-crafted models and do not scale well to complex state spaces and many agents. In contrast, our method learns coordination end-to-end via on-policy methods, learns the multi-agent exploration policy and scales well to many agents via its simple hierarchical structure. ",
+        "bbox": [
+            174,
+            731,
+            825,
+            897
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Communication Models. Recently, end-to-end learning of communication models has been studied for shared broadcast channels (Sukhbaatar et al. (2016)), sequential communication (Peng et al. (2017)), heuristic multi-agent exploration Usunier et al. (2016) and bit-channels (Foerster et al. (2016)). These works show that non-trivial communication protocols can be learned through backpropagation or heuristic stabilization methods, but often do not scale well to a large number of agents. Our hierarchical approach is complementary, learns via variational methods, and can scale to large $N$ . ",
+        "bbox": [
+            174,
+            103,
+            825,
+            188
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Multi-task learning. Hierarchical models have been studied for multi-task learning, e.g. Daume III (2014) learns latent hierarchies via EM in a supervised learning setting. Instead, we study flexible end-to-end trainable latent hierarchies in the reinforcement learning setting. ",
+        "bbox": [
+            174,
+            194,
+            825,
+            236
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "7 DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            258,
+            310,
+            273
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In a sense, we studied the simplest setting that can benefit from structured exploration, in order to isolate the contribution of our work. Our hierarchical model and variational approach are a simple way to implement multi-agent coordination, and easily combine with existing actor-critic methods. Moving forward, there are many ways to expand on our work. Firstly, for complex (partial-information) environments, instead of using reactive policies with simple priors $P \\sim \\mathcal { N } ( \\bar { 0 } , 1 )$ , memoryfull policies with flexible priors (Chen et al., 2016) may be needed. Secondly, our approach is complementary to richer forms of communication between agents. Our hierarchical structure can be interpreted as a broadcast channel, where agents are passive receivers of the message $\\lambda$ . Richer communication protocols could be encoded by policies with more complex inter-agent structure. It would be interesting to investigate how to learn these richer structures. ",
+        "bbox": [
+            174,
+            290,
+            825,
+            429
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            453,
+            285,
+            467
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Shipra Agrawal and Navin Goyal. Analysis of thompson sampling for the multi-armed bandit problem. In Conference on Learning Theory, pp. 39–1, 2012. ",
+        "bbox": [
+            173,
+            477,
+            825,
+            506
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Daniel S Bernstein. Bounded policy iteration for decentralized pomdps. In In Proceedings of the Nineteenth International Joint Conference on Artificial Intelligence. Citeseer, 2005. ",
+        "bbox": [
+            173,
+            516,
+            823,
+            545
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Lucian Busoniu, Robert Babuska, and Bart De Schutter. A comprehensive survey of multiagent reinforcement learning. IEEE Transactions on Systems, Man, And Cybernetics-Part C: Applications and Reviews, 38 (2), 2008, 2008. ",
+        "bbox": [
+            176,
+            556,
+            823,
+            599
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Georgios Chalkiadakis and Craig Boutilier. Coordination in Multiagent Reinforcement Learning: A Bayesian Approach. In International Joint Conference on Autonomous Agents and Multiagent Systems, AAMAS ’03, New York, NY, USA, 2003. ",
+        "bbox": [
+            178,
+            611,
+            823,
+            654
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Xi Chen, Diederik P. Kingma, Tim Salimans, Yan Duan, Prafulla Dhariwal, John Schulman, Ilya Sutskever, and Pieter Abbeel. Variational Lossy Autoencoder. arXiv:1611.02731 [cs, stat], November 2016. URL http://arxiv.org/abs/1611.02731. arXiv: 1611.02731. ",
+        "bbox": [
+            176,
+            665,
+            825,
+            708
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Hal Daume III. Bayesian Multitask Learning with Latent Hierarchies. arXiv:1408.2032 [cs, stat], August 2014. arXiv: 1408.2032. ",
+        "bbox": [
+            173,
+            719,
+            826,
+            748
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jakob N. Foerster, Yannis M. Assael, Nando de Freitas, and Shimon Whiteson. Learning to Communicate with Deep Multi-Agent Reinforcement Learning. arXiv:1605.06676 [cs], May 2016. arXiv: 1605.06676. ",
+        "bbox": [
+            173,
+            760,
+            825,
+            803
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "T. Furmston and D. Barber. Variational methods for reinforcement learning. Journal of Machine Learning Research, 9:241–248, December 2010. ISSN 1533-7928. ",
+        "bbox": [
+            171,
+            814,
+            823,
+            843
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Amy Greenwald and Keith Hall. Correlated q-learning. In Proceedings of the 20th International Conference on Machine Learning (ICML-03), pp. 242–249, 2003. ",
+        "bbox": [
+            171,
+            854,
+            825,
+            883
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Carlos Guestrin, Michail Lagoudakis, and Ronald Parr. Coordinated reinforcement learning. In ICML, 2002. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            922
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Matthew D. Hoffman, David M. Blei, Chong Wang, and John Paisley. Stochastic variational inference. Journal of Machine Learning Research, 14:1303–1347, 2013. URL http://jmlr. org/papers/v14/hoffman13a.html. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            146
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Rein Houthooft, Xi Chen, Yan Duan, John Schulman, Filip De Turck, and Pieter Abbeel. VIME: Variational Information Maximizing Exploration. arXiv:1605.09674 [cs, stat], May 2016. arXiv: 1605.09674. ",
+        "bbox": [
+            176,
+            155,
+            823,
+            198
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "M. J. Johnson, D. Duvenaud, A. B. Wiltschko, S. R. Datta, and R. P. Adams. Composing graphical models with neural networks for structured representations and fast inference. ArXiv e-prints, March 2016. ",
+        "bbox": [
+            173,
+            207,
+            826,
+            250
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Spiros Kapetanakis and Daniel Kudenko. Reinforcement Learning of Coordination in Cooperative Multi-agent Systems. In Eighteenth National Conference on Artificial Intelligence, pp. 326– 331, Menlo Park, CA, USA, 2002. American Association for Artificial Intelligence. ISBN 9780262511292. ",
+        "bbox": [
+            174,
+            258,
+            826,
+            315
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Diederik P Kingma and Max Welling. Auto-encoding variational bayes. arXiv preprint arXiv:1312.6114, 2013. ",
+        "bbox": [
+            173,
+            325,
+            825,
+            354
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sergey Levine and Vladlen Koltun. Variational Policy Search via Trajectory Optimization. In C. J. C. Burges, L. Bottou, M. Welling, Z. Ghahramani, and K. Q. Weinberger (eds.), Advances in Neural Information Processing Systems 26, pp. 207–215. Curran Associates, Inc., 2013. ",
+        "bbox": [
+            176,
+            363,
+            823,
+            407
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Miao Liu, Christopher Amato, Xuejun Liao, Lawrence Carin, and Jonathan P How. Stick-breaking policy learning in dec-pomdps. In IJCAI, pp. 2011–2018, 2015. ",
+        "bbox": [
+            169,
+            415,
+            823,
+            445
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Miao Liu, Christopher Amato, Emily P Anesta, John Daniel Griffith, and Jonathan P How. Learning for decentralized control of multiagent systems in large, partially-observable stochastic environments. 2016. ",
+        "bbox": [
+            174,
+            454,
+            823,
+            496
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Volodymyr Mnih, Adri Puigdomnech Badia, Mehdi Mirza, Alex Graves, Timothy P. Lillicrap, Tim Harley, David Silver, and Koray Kavukcuoglu. Asynchronous Methods for Deep Reinforcement Learning. arXiv:1602.01783 [cs], February 2016. arXiv: 1602.01783. ",
+        "bbox": [
+            174,
+            506,
+            825,
+            549
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Gerhard Neumann. Variational inference for policy search in changing situations. In International Conference on Machine Learning, ICML 2011, pp. 817–824, Bellevue, Washington, USA, June 2011. ",
+        "bbox": [
+            174,
+            559,
+            826,
+            601
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Peng Peng, Quan Yuan, Ying Wen, Yaodong Yang, Zhenkun Tang, Haitao Long, and Jun Wang. Multiagent Bidirectionally-Coordinated Nets for Learning to Play StarCraft Combat Games. arXiv:1703.10069 [cs], March 2017. arXiv: 1703.10069. ",
+        "bbox": [
+            173,
+            609,
+            826,
+            654
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Rajesh Ranganath, Dustin Tran, and David M. Blei. Hierarchical Variational Models. arXiv:1511.02386 [cs, stat], November 2015. arXiv: 1511.02386. ",
+        "bbox": [
+            173,
+            661,
+            826,
+            691
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "John Schulman, Philipp Moritz, Sergey Levine, Michael Jordan, and Pieter Abbeel. High-Dimensional Continuous Control Using Generalized Advantage Estimation. arXiv:1506.02438 [cs], June 2015. arXiv: 1506.02438. ",
+        "bbox": [
+            173,
+            700,
+            825,
+            743
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yoav Shoham and Kevin Leyton-Brown. Multiagent Systems: Algorithmic, Game-Theoretic, and Logical Foundations. Cambridge University Press, New York, NY, USA, 2008. ISBN 9780521899437. ",
+        "bbox": [
+            171,
+            752,
+            825,
+            781
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sainbayar Sukhbaatar, Arthur Szlam, and Rob Fergus. Learning Multiagent Communication with Backpropagation. arXiv:1605.07736 [cs], May 2016. arXiv: 1605.07736. ",
+        "bbox": [
+            169,
+            791,
+            825,
+            820
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ming Tan. Multi-Agent Reinforcement Learning: Independent vs. Cooperative Agents. In In Proceedings of the Tenth International Conference on Machine Learning, pp. 330–337. Morgan Kaufmann, 1993. ",
+        "bbox": [
+            176,
+            829,
+            823,
+            872
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nicolas Usunier, Gabriel Synnaeve, Zeming Lin, and Soumith Chintala. Episodic Exploration for Deep Deterministic Policies: An Application to StarCraft Micromanagement Tasks. arXiv:1609.02993 [cs], September 2016. arXiv: 1609.02993. ",
+        "bbox": [
+            174,
+            882,
+            826,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nikos Vlassis, Marc Toussaint, Georgios Kontes, and Savas Piperidis. Learning model-free robot control by a Monte Carlo EM algorithm. Autonomous Robots, 27(2):123–130, August 2009. ISSN 0929-5593, 1573-7527. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            145
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ronald J Williams. Simple statistical gradient-following algorithms for connectionist reinforcement learning. Machine learning, 8(3-4):229–256, 1992. ",
+        "bbox": [
+            171,
+            155,
+            823,
+            184
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Feng Wu, Shlomo Zilberstein, and Nicholas R Jennings. Monte-carlo expectation maximization for decentralized pomdps. In Proceedings of the Twenty-Third international joint conference on Artificial Intelligence, pp. 397–403. AAAI Press, 2013. ",
+        "bbox": [
+            176,
+            193,
+            823,
+            234
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "8 SUPPLEMENTARY MATERIAL ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            444,
+            118
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "8.1 HIERARCHICAL VARIATIONAL LOWER BOUND. ",
+        "bbox": [
+            173,
+            132,
+            544,
+            148
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We show details on how to derive a tractable learning method to the multi-agent reinforcement learning problem with a centralized controller: ",
+        "bbox": [
+            173,
+            159,
+            825,
+            188
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ec648ac24c86474dab96b8b5bc5ecd92ef50e8b08a8c5006aabf1c9ebe776013.jpg",
+        "text": "$$\nR = \\sum _ { i } R ^ { i } , \\quad \\operatorname* { m a x } _ { \\theta } \\mathbb { E } _ { \\pi ( \\mathbf { s } _ { t } ; \\theta ) } \\left[ R \\right] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            387,
+            194,
+            611,
+            228
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Instead of directly optimizing (16), we cast it as a probabilistic inference problem, as in Levine & Koltun (2013); Vlassis et al. (2009), and optimize a lower bound. ",
+        "bbox": [
+            174,
+            233,
+            821,
+            262
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "To do so, we assume that the total reward $R ^ { i }$ for each $i$ to be non-negative and bounded. Hence, we can view the total reward $R ( \\tau )$ as a random variable, whose unnormalized distribution is defined as ",
+        "bbox": [
+            173,
+            267,
+            821,
+            297
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7cd2479beebe1f4b14e5e94f8e1c8532b75272f5877611d3efaa46ad6910e62f.jpg",
+        "text": "$$\nP ( R | \\tau ) = R .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            452,
+            304,
+            545,
+            320
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We can then rewrite (16) as a maximum likelihood problem: ",
+        "bbox": [
+            171,
+            327,
+            570,
+            343
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/33d5bf27cc15cb380cc1bbe81774e33b55cb1fce6e28d9df8b00f9fadf831c51.jpg",
+        "text": "$$\n\\operatorname* { m a x } _ { \\pmb { \\theta } } \\mathbb { E } _ { \\pi ( \\mathbf { s } _ { t } ; \\pmb { \\theta } ) } \\left[ R \\right] = \\operatorname* { m a x } _ { \\pmb { \\theta } } \\mathbb { E } _ { \\pi ( \\mathbf { s } _ { t } ; \\pmb { \\theta } ) } \\left[ P ( R | \\tau ) \\right]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            354,
+            348,
+            642,
+            371
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Hence, the RL objective is equivalent to a maximal likelihood problem: ",
+        "bbox": [
+            173,
+            378,
+            642,
+            393
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8a58265512817b9e07b146d3738745a47be36a5621965f7a182ba306b8149b91.jpg",
+        "text": "$$\n\\operatorname* { m a x } _ { \\theta } \\mathbb { E } _ { \\pi ( s _ { t } ; \\theta ) } \\left[ P ( R | \\tau ) \\right] = \\operatorname* { m a x } _ { \\theta } \\int d \\tau \\underbrace { P ( R | \\tau ) P ( \\tau ; \\theta ) } _ { P ( R , \\tau ; \\theta ) } \\Leftrightarrow \\operatorname* { m a x } _ { \\theta } \\int d \\tau \\log P ( R | \\tau ) P ( \\tau ; \\theta ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            194,
+            400,
+            774,
+            445
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "where the probability of a rollout $\\tau$ features a marginalization over the latent variables $\\lambda _ { t }$ : ",
+        "bbox": [
+            171,
+            452,
+            761,
+            468
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6c5120fbc58db56e2a7fdcfa5cb5b3b5360c0d4e886e11f1dbd979bb5505c25f.jpg",
+        "text": "$$\n\\begin{array} { l } { { \\displaystyle P ( \\tau ; \\pmb \\theta ) = P ( { \\bf s } _ { 0 } ) \\prod _ { t = 0 } ^ { T } P ( { \\bf s } _ { t + 1 } \\vert { \\bf s } _ { t } , { \\bf a } _ { t } ) P ( { \\bf a } _ { t } \\vert { \\bf s } _ { t } ; \\pmb \\theta ) } } \\\\ { { \\displaystyle ~ = P ( { \\bf s } _ { 0 } ) \\int d \\lambda _ { 0 : T } \\prod _ { t = 0 } ^ { T } P ( { \\bf s } _ { t + 1 } \\vert { \\bf s } _ { t } , { \\bf a } _ { t } ) P ( { \\bf a } _ { t } , \\lambda _ { t } \\vert { \\bf s } _ { t } ; \\pmb \\theta ) , } } \\\\ { { \\displaystyle \\int d \\lambda _ { 0 : T } \\equiv \\prod _ { t = 0 } ^ { T } \\int d \\lambda _ { t } } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            302,
+            473,
+            696,
+            606
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Here, we used the hierarchical decomposition for the policy: ",
+        "bbox": [
+            173,
+            609,
+            570,
+            625
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c9c5ee26a52e116fa0818f8d895c48a515285eced1a45e00edc8e87d66616793.jpg",
+        "text": "$$\n\\begin{array} { l } { { \\displaystyle P ( { \\bf a } _ { t } | { \\bf s } _ { t } ; \\theta ) = \\int d \\lambda _ { t } P ( { \\bf a } _ { t } , \\lambda _ { t } | { \\bf s } _ { t } ; \\theta ) } } \\\\ { ~ } \\\\ { { \\displaystyle ~ = \\int d \\lambda _ { t } \\prod _ { i = 1 } ^ { N } P ( a _ { t } ^ { i } , \\lambda _ { t } | { \\bf s } _ { t } ; \\theta ) } } \\\\ { { \\displaystyle ~ = \\int d \\lambda _ { t } \\prod _ { i = 1 } ^ { N } P ( a _ { t } ^ { i } | \\lambda _ { t } , { \\bf s } _ { t } ; \\theta ) P ( \\lambda _ { t } | { \\bf s } _ { t } ) } , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            336,
+            631,
+            661,
+            753
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "This policy distribution is intractable to learn exactly, as it involves margalization over $\\lambda _ { t }$ and an unknown flexible distribution $P ( a _ { t } ^ { i } | \\lambda _ { t } , \\mathbf { s } _ { t } )$ . Hence the maximization in Equation (19) is hard. Hence, we follow the variational approach and get a lower bound on the log-likelihood $\\log P ( R , \\tau ; \\pmb \\theta )$ in Equation (19). For this, we use an approximate variational distribution $Q _ { R } \\big ( \\lambda _ { 0 : T } | \\tau ; \\phi \\big )$ and Jensen’s inequality (Hoffman et al., 2013): ",
+        "bbox": [
+            173,
+            756,
+            826,
+            828
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fc63d53a7c49eb5ecfc66ffe1e9e8ca667e9206e9950d55b795232ec457bdfd4.jpg",
+        "text": "$$\n\\begin{array} { l } { { \\displaystyle \\log P ( R , \\tau ; \\theta ) \\geq \\int d \\lambda _ { 0 : T } Q _ { R } ( \\lambda _ { 0 : T } | \\tau ; \\phi ) \\log \\left( \\frac { P ( R , \\tau ; \\theta ) } { Q _ { R } ( \\lambda _ { 0 : T } | \\tau ; \\phi ) } \\right) ~ } } \\\\ { { \\displaystyle ~ = \\int d \\lambda _ { 0 : T } Q _ { R } ( \\lambda _ { 0 : T } | \\tau ; \\phi ) \\log \\left( \\frac { P ( R | \\tau ) P ( \\mathbf { s } _ { 0 } ) \\prod _ { t = 0 } ^ { T } P ( \\mathbf { s } _ { t + 1 } | \\mathbf { s } _ { t } , \\mathbf { a } _ { t } ) P ( \\mathbf { a } _ { t } , \\lambda _ { t } | \\mathbf { s } _ { t } ; \\theta ) } { Q _ { R } ( \\lambda _ { 0 : T } | \\tau ; \\phi ) } \\right) , } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            181,
+            833,
+            834,
+            912
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "where in the last line we used (20). By inspecting the quotient in (26), we see that the optimal $Q _ { R }$ is a factorized distribution weighted by the total reward $R$ : ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/db0e42410f9d40f6c36009ba557da7edc4d380cee70b614093a1aabc82bff636.jpg",
+        "text": "$$\nQ _ { R } ( \\lambda _ { 0 : T } | \\tau ; \\phi ) = P ( R | \\tau ) P ( \\mathbf { s } _ { 0 } ) \\prod _ { t = 0 } ^ { T } P ( \\mathbf { s } _ { t + 1 } | \\mathbf { s } _ { t } , \\mathbf { a } _ { t } ) Q ( \\lambda _ { t } | \\mathbf { s } _ { t } ; \\phi ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            290,
+            133,
+            707,
+            176
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We see that (26) simplifies to: ",
+        "bbox": [
+            173,
+            176,
+            370,
+            191
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a9653a895611c03a28142d824dad0a988869ff1cd313abed8b8dcd2172062b42.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\int d \\lambda _ { u x : U } Q _ { K } ( \\lambda _ { u x } | \\tau ; \\phi ) \\log ( \\frac { P ( R ( | T | \\gamma ) P ( s _ { 1 } ) \\prod _ { t ^ { \\prime } = 0 } ^ { T } P ( s _ { t + 1 } ) P ( s _ { t + 1 } , \\lambda _ { t } , \\phi ) ) } { P ( R ( \\prod _ { t ^ { \\prime } } P ( s _ { t } ) \\prod _ { t ^ { \\prime } = 0 } ^ { T } P ( s _ { t } ) \\prod _ { t ^ { \\prime } = 0 } ^ { T } P ( s _ { t + 1 } | s _ { t } , \\lambda _ { t } , \\phi ) Q ( \\lambda _ { t } | s _ { t } ; \\phi ) ) } ) } \\\\ & { = \\int d \\lambda _ { u x : U } Q _ { K } ( \\lambda _ { u x } | \\tau ; \\phi ) \\log ( \\displaystyle \\prod _ { t = 0 } ^ { T } \\frac { P ( a _ { t } , \\lambda _ { t } | s _ { t } , \\xi ) } { Q ( \\lambda _ { t } | s _ { t } , \\phi ) } ) } \\\\ & { = \\int d \\lambda _ { u x : U } Q _ { K } ( \\lambda _ { u x } | \\tau ; \\phi ) \\displaystyle \\sum _ { t = 0 } ^ { T } ( \\log \\frac { P ( a _ { t } , \\lambda _ { t } | s _ { t } , \\xi ) } { Q ( \\lambda _ { t } | s _ { t } , \\phi ) } ) } \\\\ & { = \\int d \\lambda _ { u x : U } Q _ { K } ( \\lambda _ { u x } | \\tau ; \\phi ) \\displaystyle \\sum _ { t = 0 } ^ { T } ( \\log \\frac { P ( a _ { t } | \\lambda _ { t } | s _ { t } , \\lambda _ { t } , \\phi ) } { Q ( \\lambda _ { t } | s _ { t } , \\phi ) } ) } \\\\ & { = \\int d \\lambda _ { u x : U } Q _ { K } ( \\lambda _ { u x } | \\tau ; \\phi ) \\displaystyle \\sum _ { t = 0 } ^ { T } ( \\log \\frac { P ( a _ { t } | \\lambda _ { t } | s _ { t } , \\lambda _ { t } , \\phi ) P ( \\lambda _ { t } | s _ { t } ) } { Q ( \\lambda _ { t } | s _ { t } , \\phi ) } ) } \\\\ &  = \\displaystyle \\int d \\lambda _ { u x : U } Q _ { K } ( \\lambda _ { u x } | \\tau ; \\phi ) \\displaystyle \\sum _ { t ^ { \\prime } = 0 } ^ { T } ( \\log P ( \\lambda _ { t } | \\lambda _ { t } , \\xi ) \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            205,
+            193,
+            758,
+            429
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The right-hand side in Equation (32) is called the evidence lower bound (ELBO), which we can maximize as a proxy for (16). The standard choice is to use maximum-entropy standard-normal priors: $P ( \\lambda _ { t } | \\mathbf { s } _ { t } ) \\bar { { \\mathbf { \\psi } } } = \\dot { N } ( \\mathbf { 0 } , \\mathbf { 1 } )$ . We can then optimize (32) using e.g. stochastic gradient ascent. ",
+        "bbox": [
+            173,
+            431,
+            820,
+            474
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "8.2 TRAINING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            489,
+            287,
+            503
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Training method. We used the A3C method with 5-20 threads for all our experiments. Each thread performed SGD with (??). The loss for the value function at each state $\\mathbf { s } _ { t }$ is the standard $L _ { 2 }$ -loss between the observed total rewards for each agent $i$ and its value estimate: ",
+        "bbox": [
+            173,
+            515,
+            826,
+            559
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a149e3c5ec476fafafc20802059ea23925292fc0c0c5cbc3761ef18f8c6b6e78.jpg",
+        "text": "$$\n\\alpha \\sum _ { t } \\sum _ { i } \\left( V ^ { i } ( \\mathbf { s } _ { t } ) - R ^ { i } ( \\mathbf { s } _ { t } , \\mathbf { a } _ { t } ) \\right) ^ { 2 } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            385,
+            577,
+            612,
+            611
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In addition, in line with other work using actor-critic methods, we found that adding a small entropy regularization on the policy can sometimes positively influence performance, but this does not seem to be always required for our testbeds. The entropy regularization is: ",
+        "bbox": [
+            173,
+            611,
+            825,
+            652
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/90d6d4f41331f29322e98261cc9ea057beb7486a862fa7f3f704496b7e392f61.jpg",
+        "text": "$$\nH ( P ) = - \\beta \\sum _ { t } \\sum _ { { \\bf { a } } _ { t } } P ( { \\bf { a } } _ { t } | { \\bf { s } } _ { t } ; \\pmb { \\theta } ) \\log P ( { \\bf { a } } _ { t } | { \\bf { s } } _ { t } ; \\pmb { \\theta } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            338,
+            654,
+            658,
+            688
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A3C additionally defines training minibatches in terms of a fixed number of environment steps $L$ : a smaller $L$ gives faster training with higher variance and a higher $L$ vice versa. ",
+        "bbox": [
+            176,
+            689,
+            821,
+            718
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Hyperparameter search. For experiments, we performed a random search over hyperparameters: ",
+        "bbox": [
+            171,
+            723,
+            816,
+            739
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/822a84e9f8ff67f6c81e87675b1dbc79f7f01116f11cac55cf32f80eb39794cf.jpg",
+        "table_caption": [
+            "Table 2: Search range of hyper-parameters. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Hyperparameter</td><td></td><td>Search range</td></tr><tr><td>Learning-rate</td><td>n</td><td>[10-6,10-1]</td></tr><tr><td>Discount</td><td>Y</td><td>[0.9, 0.99]</td></tr><tr><td>GAE discount</td><td>T</td><td>[0.9, 0.99]</td></tr><tr><td>Value loss</td><td>α</td><td>[0.1, 0.5]</td></tr><tr><td>Policy entropy</td><td>β</td><td>[0, 0.01]</td></tr></table>",
+        "bbox": [
+            366,
+            748,
+            630,
+            837
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "8.3 RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            883,
+            279,
+            897
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/3bd9a5038376aaf9032942966b648affa0a551b69109db2c38107e8dad165be0.jpg",
+        "image_caption": [
+            "Figure 7: Train-time cumulative terminal reward in $( N , M , 1 , 1 0 0 0 )$ Hare-Hunters (upper) and Stag-Hunters (lower) on a $5 0 \\times 5 0$ gridworld, for 10-vs-10 or 20-vs-20 agents; randomly moving or fixed preys. Average, minimal and maximal rewards for the best 5 runs for each model are shown. MACE accumulates increasingly higher rewards compared to the baselines. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            186,
+            409,
+            805,
+            547
+        ],
+        "page_idx": 13
+    }
+]

parse/train/Skxd6gSYDS/Skxd6gSYDS.md

@@ -0,0 +1,298 @@
+# QUERY-EFFICIENT META ATTACK TO DEEP NEURAL NETWORKS
+
+Jiawei $\mathbf { D } \mathbf { u } ^ { 1 , 3 : }$ ∗, Hu Zhang2∗, Joey Tianyi Zhou3, Yi Yang2 , Jiashi Feng1
+
+1Dept. ECE, National University of Singapore, Singapore 2ReLER, University of Technology Sydney, Australia 3Institute of High performance Computing, A\*STAR, Singapore dujiawei@u.nus.edu,Hu.Zhang-1@student.uts.edu.au joey.tianyi.zhou@gmail.com,Yi.Yang@uts.edu.au elefjia@nus.edu.sg
+
+# ABSTRACT
+
+Black-box attack methods aim to infer suitable attack patterns to targeted DNN models by only using output feedback of the models and the corresponding input queries. However, due to lack of prior and inefficiency in leveraging the query and feedback information, existing methods are mostly query-intensive for obtaining effective attack patterns. In this work, we propose a meta attack approach that is capable of attacking a targeted model with much fewer queries. Its high queryefficiency stems from effective utilization of meta learning approaches in learning generalizable prior abstraction from the previously observed attack patterns and exploiting such prior to help infer attack patterns from only a few queries and outputs. Extensive experiments on MNIST, CIFAR10 and tiny-Imagenet demonstrate that our meta-attack method can remarkably reduce the number of model queries without sacrificing the attack performance. Besides, the obtained meta attacker is not restricted to a particular model but can be used easily with a fast adaptive ability to attack a variety of models. The code of our work is available at https://github.com/dydjw9/MetaAttack_ICLR2020/.
+
+# 1 INTRODUCTION
+
+Despite the great success in various tasks, deep neural networks (DNNs) are found to be susceptible to adversarial attacks and often suffer dramatic performance degradation in front of adversarial examples, even if only tiny and invisible noise is imposed on the input (Szegedy et al., 2014). To investigate the safety and robustness of DNNs, many adversarial attack methods have been developed, which apply to either a white-box (Goodfellow et al., 2015; Moosavi-Dezfooli et al., 2016; Carlini & Wagner, 2017; Madry et al., 2018) or a black-box setting (Papernot et al., 2017; Brendel et al., 2018; Narodytska & Kasiviswanathan, 2017). In the white-box attack setting, the target model is transparent to the attacker and imperceptible adversarial noise can be easily crafted to mislead this model by leveraging its gradient information (Goodfellow et al., 2015). In contrast, in the blackbox setting, the structure and parameters of the target DNN model are invisible, and the adversary can only access the input-output pair in each query. With a sufficient number of queries, black-box methods utilize the returned information to attack the target model generally by estimating gradient (Chen et al., 2017; Ilyas et al., 2018a; Narodytska & Kasiviswanathan, 2017; Cheng et al., 2019).
+
+Black-box attack is more feasible in realistic scenarios than white-box attack but it is much more query-intensive. Such a drawback is largely attributed to the fact that returned information for each queried example is sparse and limited. During inferring attack patterns, existing black-box methods simply integrate the information between two sequential iterations brutally and ignore the implicit but profound message, thus not fully exploiting the returned information. Although query-efficient algorithms for generating attack examples are very meaningful in practice (Ilyas et al., 2018a), how to enhance query-efficiency for black-box attack remains underexplored.
+
+In this work, we address a query-efficiency concerned attack problem. Particularly, we consider only top- $k$ probability scores accessible from the target black-box model. With this practical but challenging scenario, we aim at three important objectives: lower query number, higher success rate and smaller noise magnitude. We develop a meta-learning based attack method, which applies meta learning to obtaining prior information from the successful attack patterns, and uses the prior for efficient optimization. Specifically, we propose to train a meta attacker model through meta learning (Nichol et al., 2018), inspired by its success in solving few-shot learning problems. We first deploy several existing classification models to get pairs of (images, gradients) with the max-margin logit classification loss. Then we use the data pairs of each classification model to train the meta attacker. After obtaining the attacker, we use it to attack a new black-box model for accelerating the search process for adversarial examples by optimizing it with coordinate-wise gradient estimation. Different from previous methods, we use the estimated gradient not only to update adversarial noise but to fine-tune the well-trained attacker. After few-shot fine-tuning, the attacker is able to simulate the gradient distribution of the target model.
+
+We evaluate our method on MNIST, CIFAR10 and tiny-ImageNet datasets by comparing it with state-of-the-art black-box attack methods including Zoo (Chen et al., 2017), DecisionBoundary (Brendel et al., 2018), AutoZoom (Tu et al., 2019), Opt-attack (Cheng et al., 2019) and Bandits (Ilyas et al., 2018b). In both targeted and untargeted settings, our proposed method achieves comparable attack success rate and adversarial perturbation to all baselines but with a significantly reduced query number. The detailed experiment results demonstrate our superior query-efficiency.
+
+# 2 RELATED WORK
+
+Classical white-box attack methods include Fast-Gradient Sign Method (FGSM) (Goodfellow et al., 2015), IFGSM (Madry et al., 2018), DeepFool (Moosavi-Dezfooli et al., 2016) and C&W attack (Carlini & Wagner, 2017), following a setting where detailed information about the target model (gradients and losses) is provided. Comparatively, the black-box setting better accords with the real world scenarios in that little information about the target model is visible to the attacker. The pioneer work on black-box attack (Papernot et al., 2017) tries to construct a substitute model with augmented data and transfer the black-box attack problem to a white-box one. However, its attack performance is very poor due to the limited transferability of adversarial examples between two different models. (Brendel et al., 2018) considers a more restricted case where only top-1 prediction classes are returned and proposes a random-walk based attack method around the decision boundary. It dispenses class prediction scores and hence requires extensive model queries. Zoo (Chen et al., 2017) is a black-box version of C&W attack, achieving a similar attack success rate and comparable visual quality as many white-box attack methods. However, its coordinate-wise gradient estimation requires extensive model evaluations. More recently, (Ilyas et al., 2018a) proposes a query-limited setting with $L _ { \infty }$ noise considered, and uses a natural evolution strategy (NES) to enhance query efficiency. Though this method successfully controls the query number, the noise imposed is larger than average. (Narodytska & Kasiviswanathan, 2017) proposes a novel local-search based technique to construct numerical approximation to the network gradient, which is then carefully used to construct a small set of pixels in an image to perturb. It suffers a similar problem as in (Chen et al., 2017) for pixel-wise attack. (Cheng et al., 2019) considers a hard-label black-box setting and formulates the problem as real-valued optimization that is solved by a zeroth order optimization algorithm. Ilyas et al. (2018b) reduce the queries by introducing two gradient priors, the time-independent prior and the data-dependent prior, and reformulating the optimization problem.
+
+We then briefly introduce some works on meta-learning related to our work. Meta-learning is a process of learning how to learn. A meta-learning algorithm takes in a distribution of tasks, each being a learning problem, and produces a quick learner that can generalize from a small number of examples. Meta-learning is very popular recently for its fast adaptive ability. MAML (Finn et al., 2017) is the first to propose this idea. Recently, a simplified algorithm Reptile (Nichol et al., 2018) which is an approximation to the first-order MAML is proposed, achieving higher efficiency in computation and consuming less memory. With these superior properties, meta learning is applied to adversarial attack methods (Zgner & Gnnemann, 2019; Edmunds et al., 2017). Zgner & Gnnemann (2019) try to attack the structure of a graph model in the training process to decrease the model generalization performance. Edmunds et al. (2017) investigate the susceptibility of MAML to adversarial attacks and the transferability of the obtained meta model to a specific task.
+
+# 3 METHOD
+
+# 3.1 PRELIMINARIES: BLACK-BOX ATTACK SCHEMES
+
+We first formulate the black-box attack problem and introduce the widely used solutions. We use $( { \pmb x } , t )$ to denote the pair of a natural image and its true label, and $\hat { \pmb x }$ and $\dot { t }$ to denote the adversarial perturbed version of $_ { \textbf { \em x } }$ and the returned label by the target classification model $\mathcal { M } _ { t a r }$ . The black-box attack aims to find an adversarial example $\hat { \pmb x }$ with imperceivable difference from $_ { \textbf { \em x } }$ to fail the target model , i.e., ${ \hat { t } } \neq t$ through querying the target model for multiple times. It can be formulated as
+
+$$
+\begin{array} { r l } & { \underset { \hat { \pmb { x } } } { \operatorname* { m i n } } \ell ( \hat { \pmb { x } } , \mathcal { M } _ { t a r } ( \hat { \pmb { x } } ) , t ) } \\ & { \mathrm { s . t . } \ \lVert \hat { \pmb { x } } - \pmb { x } \rVert _ { p } \leq \rho , \ \# \mathrm { q u e r i e s } \leq \mathrm { Q } . } \end{array}
+$$
+
+Here $\| \cdot \| _ { p }$ denotes the $\ell _ { p }$ norm that measures how much perturbation is imposed. $\mathcal { M } _ { t a r } ( \hat { \pmb x } )$ is the returned logit or probability by the target model $\mathcal { M } _ { t a r }$ . The loss function $\ell ( \hat { \pmb x } , \mathcal { M } _ { t a r } ( \hat { \pmb x } ) , t )$ measures the degree of certainty for model $\mathcal { M } _ { t a r }$ assigning the input $\hat { \pmb x }$ into class $t$ . One common used adversarial loss is the probability of class $t$ : $\boldsymbol { \ell } ( \hat { \mathbf { x } } , \mathcal { M } _ { t a r } ( \hat { \mathbf { x } } ) , t ) = p _ { \mathcal { M } _ { t a r } } ( t | \hat { \mathbf { x } } )$ . The first constraint enforces high similarity between the clean image $_ { \textbf { \em x } }$ and the adversarial one $\mathbf { \Delta } \mathbf { x } _ { a d v }$ and the second imposes a fixed budget $Q$ for the number of queries allowed in the optimization.
+
+In the white-box attack setting, the adversary can access the true gradient $\nabla _ { \hat { \pmb { x } } _ { t } } \ell ( \hat { \pmb { x } } _ { t } )$ and perform gradient descent $\hat { { \pmb x } } _ { t + 1 } = \hat { { \pmb x } } _ { t } - \nabla _ { \hat { { \pmb x } } _ { t } } \ell ( \hat { { \pmb x } } _ { t } )$ . But in the black-box setting, the gradient information $\bar { \nabla } _ { \hat { \pmb { x } } _ { t } } \ell ( \hat { \pmb { x } } _ { t } )$ is not attainable. In this case, the attacker can estimate the gradient using only queried information from model evaluation such as hard label, logits and probability scores. This kind of estimator is the backbone of so-called zeroth-order optimization approaches (Chen et al., 2017; Narodytska & Kasiviswanathan, 2017; Tu et al., 2019; Ilyas et al., 2018a;b). The estimation is done via finite difference method (Chen et al., 2017; Narodytska & Kasiviswanathan, 2017; Tu et al., 2019), which finds the $k$ components of the gradient by estimating the inner products of the gradients with all the standard basis vector $e _ { 1 } , . . . , e _ { k }$ :
+
+$$
+\nabla \ell ( { \pmb x } ) \approx \sum _ { i = 1 } ^ { k } \frac { f ( { \pmb x } + h { \pmb e } _ { i } ) - f ( { \pmb x } - h { \pmb e } _ { i } ) } { 2 h } { \pmb e } _ { i } ,
+$$
+
+where step size $h$ controls the quality of the estimated gradient. Another strategy is to reformulate the loss function (Ilyas et al., 2018a;b). Instead of computing the gradient of $\ell ( { \pmb x } )$ itself, the expected value of loss function $\ell ( { \pmb x } )$ under the search distribution is minimized and when the search distribution of random Guassian noise is adopted, the gradient estimation problem transfers into a zeroth-order estimation problem,
+
+$$
+\nabla \mathbb { E } [ \ell ( \pmb { x } ) ] \approx \frac { 1 } { \sigma n } \sum _ { i = 1 } ^ { n } \ell ( \pmb { x } + \sigma \delta _ { i } ) \delta _ { i }
+$$
+
+where $n$ is the amount of noise sampled from the distribution. After obtaining the estimated gradient, classical optimization algorithms (Nesterov, 2013; Johnson & Zhang, 2013) can be used to infer the adversarial examples. Though the estimated gradient may not be accurate, it is still proved useful enough in adversarial attack. The convergence of these zeroth-order methods is guaranteed under mild assumptions (Ghadimi & Lan, 2013; Nesterov & Spokoiny, 2017; Hazan et al., 2016).
+
+Since each model evaluation consumes a query, naively applying the above gradient estimation to black-box attack is quite query expensive due to its coordinate or noise sampling nature. Take the first strategy on tiny-Imagenet dataset for example. It consumes more than 20,000 queries for each image to obtain a full gradient estimate, which is not affordable in practice. In this work, we address such a limitation via developing a query-efficient meta-learning based attack model.
+
+# 3.2 LEARNING OF META ATTACKER
+
+To reduce the query cost for black-box attack, we apply meta learning to training a meta attacker model, inspired by its recent success in few-shot learning problems (Finn et al., 2017; Nichol et al., 2018). The meta attacker learns to extract useful prior information of the gradient of a variety of models w.r.t. specific input samples. It can infer the gradient for a new target model using only a
+
+# Algorithm 1 Meta Attacker Training
+
+Input: Input images $\mathbb { X }$ , groundtruth gradients $\mathbb { G } _ { i }$ generated from classification models $\mathcal { M } _ { i }$ to serve   
+as task $\mathcal { T } _ { i }$ ;   
+1: Randomly initialize $\pmb \theta$ ;   
+2: while not done do   
+3: for all $\mathcal { T } _ { i }$ do   
+4: Sample $K$ samples from $( \mathbb { X } , \mathbb { G } _ { i } )$ for training, denoted as $( \mathbb { X } _ { s } , \mathbb { G } _ { i } ^ { s } )$ ;   
+5: Evaluate $\nabla _ { \pmb { \theta } } \mathcal { L } _ { i } ( \mathcal { A } _ { \pmb { \theta } } ) = \nabla _ { \pmb { \theta } } \| \mathcal { A } _ { \pmb { \theta } } ( \mathbb { X } _ { s } ) - \mathbb { G } _ { i } ^ { s } \| _ { 2 } ^ { 2 }$ with respect to $( \mathbb { X } _ { s } , \mathbb { G } _ { i } ^ { s } )$ ;   
+6: Update $\pmb { \theta } _ { i } ^ { \prime } : = \pmb { \theta } - \alpha \nabla _ { \pmb { \theta } } \mathcal { L } _ { i } ( \mathcal { A } _ { \pmb { \theta } } )$ ;   
+7: end for   
+8: Update $\begin{array} { r } { \pmb { \theta } : = \pmb { \theta } + \epsilon \frac { 1 } { n } \sum _ { i = 1 } ^ { n } ( \pmb { \theta } _ { i } ^ { \prime } - \pmb { \theta } ) } \end{array}$ ;   
+9: end while
+
+Output: Parameters $\pmb \theta$ of meta model $\mathcal { A }$ .
+
+few queries. After obtaining such a meta attacker, we replace the zeroth-order gradient estimation in traditional black box attack methods with it to directly estimate the gradient.
+
+We collect a set of existing classification models $\mathcal { M } _ { 1 } , . . . , \mathcal { M } _ { n }$ to generate gradient information for universal meta attacker training. Specifically, we feed each image $_ { \textbf { \em x } }$ into the models $\mathcal { M } _ { 1 } , . . . , \mathcal { M } _ { n }$ respectively and compute losses $\ell _ { 1 } , . . . , \ell _ { n }$ by using following max-margin logit classification loss:
+
+$$
+\ell _ { i } ( { \pmb x } ) = \mathrm { m a x } \left[ \mathrm { l o g } [ \mathcal { M } _ { i } ( { \pmb x } ) ] _ { t } - \underset { j \neq t } { \mathrm { m a x } } \mathrm { l o g } [ \mathcal { M } _ { i } ( { \pmb x } ) ] _ { j } , 0 \right] .
+$$
+
+Here $t$ is the groundtruth label and $j$ indexes other classes. $[ \mathcal { M } _ { i } ( \pmb { x } ) ] _ { t }$ is the probability score of the true label predicted by the model $\mathcal { M } _ { i }$ , and $[ \mathcal { M } _ { i } ( \pmb { x } ) ] _ { j }$ denotes the probability scores of other classes. By performing one step back-propagation of losses $\ell _ { 1 } , . . . , \ell _ { n }$ w.r.t. the input images $_ { \textbf { \em x } }$ , the corresponding gradients ${ \pmb g } _ { i } = \nabla _ { { \pmb x } } \ell _ { i } ( { \pmb x } ) , i = 1 , . . . , n$ are obtained. Finally, we collect $n$ groups of data $\bar { \mathbb { X } } = \{ \pmb { x } \} , \bar { \mathbb { G } } _ { i } = \{ \pmb { g } _ { i } \bar  \} , i = 1 , . . . , n$ to train the universal meta attacker.
+
+We design a meta attacker $\mathcal { A }$ which has a similar structure as an autoencoder, consisting of symmetric convolution and de-convolution layers and outputs a gradient map with the same size as the input. Meta attacker model $\mathcal { A }$ is parameterized with parameters $\pmb \theta$ .
+
+Due to the intrinsic difference between selected classification models, each obtained set $\left( \mathbb { X } , \mathbb { G } _ { i } \right)$ is treated as a task $\mathcal { T } _ { i }$ in meta attacker training. During the training process, for each iteration we only draw $K$ samples from task $\mathcal { T } _ { i }$ and feedback the loss $\mathcal { L } _ { i }$ to update model parameters from $\pmb \theta$ to $\pmb { \theta } _ { i } ^ { \prime }$ . $\pmb { \theta } _ { i } ^ { \prime }$ is then computed through one or multiple gradient descents: $\pmb { \theta } _ { i } ^ { \prime } : = \pmb { \theta } - \alpha \nabla _ { \pmb { \theta } } \mathcal { L } _ { i } ( \mathcal { A } _ { \pmb { \theta } } )$ . For a sensitive position of the meta attacker, the meta attacker parameters are optimized by combining each $\pmb { \theta } _ { i } ^ { \prime }$ across all tasks $\{ \mathcal { T } _ { i } \} _ { i = 1 , \dots , n }$ , following the update strategy of Reptile (Nichol et al., 2018) in meta learning,
+
+$$
+\pmb \theta : = \pmb \theta + \epsilon \frac { 1 } { n } \sum _ { i = 1 } ^ { n } ( \pmb \theta _ { i } ^ { \prime } - \pmb \theta ) .
+$$
+
+We adopt mean-squared error (MSE) as the training loss in the inner update,
+
+$$
+\mathcal { L } _ { i } ( \mathcal { A } _ { \theta } ) = \| \mathcal { A } _ { \theta } ( \mathbb { X } _ { s } ) - \mathbb { G } _ { i } ^ { s } \| _ { 2 } ^ { 2 } .
+$$
+
+The set $( \mathbb { X } _ { s } , \mathbb { G } _ { i } ^ { s } )$ denotes the $K$ samples used for each inner update from $\pmb \theta$ to $\theta _ { i } ^ { \prime }$ . Since the number of $K$ sampled each time is very small, the update strategy above tries to find good meta attacker parameters $\pmb \theta$ as an initial point, from which the meta attacker model can fast adapt to new data distribution through gradient descent based fine-tuning within limited samples. Therefore, this characteristic can be naturally leveraged in attacking new black-box models by estimating their gradient information through a few queries. Detailed training process of our meta attacker is described in Algorithm 1.
+
+# 3.3 QUERY-EFFICIENT ATTACK VIA META ATTACKER
+
+An effective adversarial attack relies on optimizing the loss function equation 1 w.r.t. the input image to find the adversarial example of the target model $\mathcal { M } _ { t a r }$ . Differently, our proposed method applies the meta attacker $\mathcal { A }$ to predicting the gradient map of a test image directly.
+
+Input: Test image $\scriptstyle { \mathbf { { \mathit { x } } } } _ { 0 }$ with label $t$ , meta attacker $\scriptstyle { \mathcal { A } } _ { \theta }$ , target model $\mathcal { M } _ { t a r }$ , iteration interval $m$ ,   
+selected top- $q$ coordinates;   
+1: for $t = 0 , 1 , 2 , \ldots$ do   
+2: if $( t + 1 )$ mod $m = 0$ then   
+3: Perform zeroth-order gradient estimation on top $q$ coordinates, denoted as $I _ { t }$ and obtain $\mathbf { \nabla } _ { \mathbf { \boldsymbol { g } } _ { t } }$ ;   
+4: Fine-tune meta attacker $\mathcal { A }$ with $( \pmb { x } _ { t } , \pmb { g } _ { t } )$ on $I _ { t }$ by loss $L = \left\| [ A _ { \theta } ( \pmb { x } _ { t } ) ] _ { I _ { t } } - [ \pmb { g } _ { t } ] _ { I _ { t } } \right\| _ { 2 } ^ { 2 }$ ;   
+5: else   
+6: Generate the gradient map $\mathbf { \nabla } _ { \mathbf { \boldsymbol { g } } _ { t } }$ directly from meta attacker $\mathcal { A }$ with $\mathbf { \Delta } _ { \mathbf { \mathcal { X } } _ { t } }$ , select coordinates $I _ { t }$ ;   
+7: end if   
+8: Update $[ { \pmb x } ^ { \prime } ] _ { I _ { t } } = [ { \pmb x } _ { t } ] _ { I _ { t } } + \beta [ { \pmb g } _ { t } ] _ { I _ { t } }$ ;   
+9: if $\mathcal { M } _ { t a r } ( \pmb { x } ^ { \prime } ) \neq t$ then   
+10: $\pmb { x } _ { a d v } = \pmb { x } ^ { \prime }$ ;   
+11: break;   
+12: else   
+13: $\pmb { x } _ { t + 1 } = \pmb { x } ^ { \prime } ;$ ;   
+14: end if   
+15: end for   
+Output: adversarial example $\mathbf { { x } } _ { a d v }$ .
+
+We use the obtained meta attacker model $\mathcal { A }$ to predict useful gradient map for attacking, which should be fine tuned to adapt to the new gradient distribution under our new target model. Particularly, instead of finetuning once, for each given image $_ { \textbf { \em x } }$ , we update $\mathcal { A }$ by leveraging query information with the following periodic scheme. Suppose the given image is perturbed to $\pmb { x } _ { t } \in \mathbb { R } ^ { p }$ at iteration $t$ . If $( t + 1 )$ mod $m = 0$ , our method performs zeroth-order gradient estimation to obtain gradient map $\mathbf { \sigma } _ { \mathbf { \sigma } _ { \mathbf { \sigma } _ { \mathbf { \lambda } } } } \mathbf { \sigma } _ { \mathbf { \sigma } _ { \mathbf { \lambda } } } \mathbf { \sigma } _ { \mathbf { \lambda } _ { \mathbf { \lambda } } } \mathbf { \sigma } _ { \mathbf { \lambda } _ { \mathbf { \lambda } } } \mathbf { \sigma } _ { \mathbf { \lambda } _ { \mathbf { \lambda } } } \mathbf { \sigma } _ { \mathbf { \lambda } _ { \mathbf { \lambda } } } \mathbf { \sigma } _ { \mathbf { \lambda } _ { \mathbf { \lambda } } } \mathbf { \sigma } _ { \mathbf { \lambda } _ { \lambda } }$ for fine-tuning. As each pixel value for estimated gradient map consumes two queries, for further saving queries, we just select $q$ of the $p$ coordinates to estimate, $q \ll p$ , instead of the full gradient map through all $p$ coordinates. The indexes of chosen coordinates are determined by the gradient map $\mathbf { \delta } _ { g _ { t - 1 } }$ obtained in iteration $t - 1$ . We sort the coordinate indexes by the value of $\mathbf { \delta } _ { g _ { t - 1 } }$ and select top- $q$ indexes. The set of these indexes are denoted as $I _ { t }$ . We feed image $\mathbf { \Delta } _ { \mathbf { \mathcal { X } } _ { t } }$ in iteration $t$ into meta attacker $\mathcal { A }$ and compute the MSE loss on indexes $I _ { t }$ , i.e. $L = \left\| [ \mathcal { A } _ { \pmb \theta } ( \pmb x _ { t } ) ] _ { I _ { t } } - [ \pmb g _ { t } ] _ { I _ { t } } \right\| _ { 2 } ^ { 2 }$ . Then we perform gradient descent for the MSE loss with a few steps to update the parameters $\pmb \theta$ of meta attacker $\mathcal { A }$ . For the rest iterations, we just use the periodically updated attacker $\scriptstyle A _ { \theta }$ to directly generate the gradient $\pmb { g } _ { t } = \mathcal { A } _ { \pmb { \theta } } ( \pmb { x } _ { t } )$ . When we have the estimated gradient map $\mathbf { \nabla } _ { \mathbf { \boldsymbol { g } } _ { t } }$ in iteration $t$ , we update to get the adversarial sample $ { \boldsymbol { { x } } } _ { t } ^ { \prime }$ by $[ { \pmb x } _ { t } ^ { \prime } ] _ { I _ { t } } = [ { \pmb x } _ { t } ] _ { I _ { t } } + \beta [ { \pmb g } _ { t } ] _ { I _ { t } } ^ { - }$ where $\beta$ is a hyperparameter to be tuned. The details are summarized in Algorithm 2.
+
+In our method, the following operations contribute to reducing the query number needed by the attacker. First, though we just use $q$ coordinates to fine-tune our meta attacker $\mathcal { A }$ every $m$ iterations, the meta attacker $\mathcal { A }$ is trained to ensure that it can abstract the gradient distribution of different $\mathbf { \Delta } _ { \mathbf { \mathcal { X } } _ { t } }$ and learn to predict the gradient from a few samples with simple fine-tuning. Secondly, the most query-consuming part lies in zeroth-order gradient estimation, due to its coordinate-wise nature. In our algorithm, we only do this every $m$ iterations. When we use the finetuned meta attacker $\mathcal { A }$ directly, no query is consumed in gradient estimation in these iterations. Intuitively, larger $m$ implies less gradient estimation computation and fewer queries. Besides, just as mentioned above, even in zeroth-order gradient estimation, only top- $q$ coordinates are required. Normally, $q$ is much smaller than dimension $p$ of the input.
+
+# 4 EXPERIMENTS
+
+We compare our meta attacker with state-of-the-art black-box attack methods including Zoo (Chen et al., 2017), Decision-Boundary (Brendel et al., 2018), AutoZoom (Tu et al., 2019), Optattack (Cheng et al., 2019), FW-black (Chen et al., 2018) and Bandits (Ilyas et al., 2018b) to evaluate its query efficiency. We also study its generalizability and transferability through a Meta transfer attacker, as detailed in the following sections.
+
+# 4.1 SETTINGS
+
+Datasets and Target Models We evaluate the attack performance on MNIST (LeCun, 1998) for handwritten digit recognition, CIFAR10 (Krizhevsky & Hinton, 2009) and tiny-Imagenet (Russakovsky et al., 2015) for object classification. The architecture details of meta attack models on MNIST, CIFAR10 and tiny-Imagenet are given in Table 6. For MNIST, we train a separate meta attacker model since the images have different channel numbers from other natural image datasets. For CIFAR10 and tiny-Imagenet, we use a common meta attacker model. On CIFAR-10, we choose ResNet18 (He et al., 2016) as the target model $\mathcal { M } _ { t a r }$ and use VGG13, VGG16 (Simonyan & Zisserman, 2014) and GoogleNet (Szegedy et al., 2015) for training our meta attacker. On tiny-Imagenet, we choose VGG19 and ResNet34 as the target model separately, and use VGG13, VGG16 and ResNet18 for training the meta attacker together.
+
+Attack Protocols For a target black-box model $\mathcal { M } _ { t a r }$ , obtaining a pair of (input-output) is considered as one query. We use the mis-classification rate as attack success rate; we randomly select 1000 images from eacwe use the mean $L _ { 2 }$ ataset as test images. To evaluadistance across all the samples $\begin{array} { r } { n o i s e ( \mathcal { M } _ { t a r } ) = \frac { 1 } { n } \sum _ { i = 1 } ^ { n } \| \pmb { x } _ { i , \mathcal { A } , \mathcal { M } _ { t a r } } ^ { a d v } - \pmb { x } _ { i } \| _ { 2 } } \end{array}$ where $\pmb { x } _ { i , \mathcal { A } , \mathcal { M } _ { t a r } } ^ { a d v }$ denotes the adversarial version for the authentic sample $\mathbf { \Delta } _ { \mathbf { \mathcal { X } } _ { i } }$ .
+
+Meta-training Details For all the experiments, we use the same architecture for the meta attacker $\mathcal { A }$ as shown in Table 6. We use Reptile (Nichol et al., 2018) with 0.01 learning rate to train meta attackers. We use 10000 randomly selected images from the training set to train the meta-attackers in three datasets. The proportion of the selected images to the whole training set are $16 \%$ , $20 \%$ , and $10 \%$ respectively. Fine-tuning parameters are set as $m = 5$ for MNIST and CIFAR10, and $m = 3$ for tiny-Imagenet. Top $q = 1 2 8$ coordinates are selected as part coordinates for attacker fine-tuning and model attacking on MNIST; and $q = 5 0 0$ on CIFAR10 and tiny-Imagenet.
+
+# 4.2 COMPARISON WITH BASELINES
+
+We compare our meta attacker with baselines for both the untargeted and targeted black-box attack on the three datasets. The results are reported in detail as below.
+
+Untargeted Attack Untargeted attack aims to generate adversarial examples that would be misclassified by the attacked model into any category different from the ground truth one. The overall results are shown in Table 1, in which, Meta transfer denotes that meta attacker trained on one dataset is used to attack target models on another dataset . Our method is competitive with baselines in terms of adversarial perturbation and success rate, but our query number is reduced.
+
+We also compare the results of our method with Zoo (Chen et al., 2017) and AutoZoom (Tu et al., 2019) from a query-efficiency perspective. We use these models to conduct untargeted attack on CIFAR10 and tiny-Imagenet by limiting a maximum number of queries for each adversarial example and compare their success rate. The results are shown in Fig. 1. We notice that for different query thresholds, the success rate of our method is always higher than Zoo and AutoZoom. This is possibly because the testing samples have different $L _ { 2 }$ distances to the decision boundary. Higher success rate of our method indicates our meta attacker can predict correct gradient even when the query information is limited. These results give strong evidence on effectiveness of our proposed method for enhancing query efficiency.
+
+![](images/04b74de44fc0440b260086d66e284eaba048850f85d47a87b3a7143351aaf388.jpg)  
+Figure 1: Comparison with limited queries.
+
+![](images/aedf9e9c22c2a6993a232496528dcd7d2d8e6fb11b4ed3eaa64b5fd46d3649bb.jpg)  
+Figure 2: Top- $q$ and $\beta$ selection.
+
+Targeted Attack Targeted attack aims to generate adversarial noise such that the perturbed sample would be mis-classified into any pre-specified category. It is a more strict setting than the untargeted one. For fair comparison, we define the target label for each sample —a sample with label $\ell$ gets the target label $( \ell + 1 )$ mod #classes. We deploy our meta attacker the same as above. The results on MNIST, CIFAR10 and tiny-ImageNet are shown in Table 2. Similar to results of untargeted attack, we achieve comparable noise and success rate to baselines but with reduced query numbers.
+
+Table 1: MNIST, CIFAR10 and tiny-ImageNet untargeted attack comparison: Meta attacker attains comparable success rate and $L _ { 2 }$ distortion as baselines, and significantly reduces query numbers.   
+
+<table><tr><td rowspan=1 colspan=1>Dataset /Target model</td><td rowspan=1 colspan=2>Method                                Success Rate  Avg. L2 Avg. Queries</td></tr><tr><td rowspan=6 colspan=1>MNIST/Net4</td><td rowspan=6 colspan=1>Zoo (Chen et al.,2017)Decision Boundary (Brendel et al.,2018)Opt-attack (Cheng et al.,2019)AutoZoom (Tu et al.,2019),Bandits (Ilyas et al.,2018b)Meta attack (ours)</td><td rowspan=1 colspan=1>1.00       1.61      21,760</td></tr><tr><td rowspan=1 colspan=1>1.00       1.85      13.630</td></tr><tr><td rowspan=1 colspan=1>1.00       1.85      12.925</td></tr><tr><td rowspan=1 colspan=1>1.00       1.86      2.412</td></tr><tr><td rowspan=1 colspan=1>0.73       1.99       3,771</td></tr><tr><td rowspan=1 colspan=1>1.00       1.77       749</td></tr><tr><td rowspan=8 colspan=1>CIFAR10/Resnet18</td><td rowspan=8 colspan=1>Zoo (Chen et al., 2017)Decision Boundary (Brendel et al.,2018)Opt-attack (Cheng et al.,2019)AutoZoom (Tu et al.,2019)Bandits (Ilyas et al.,2018b)FW-black (Chen et al.,2018)Meta transfer (ours)Meta attack (ours)</td><td rowspan=1 colspan=1>1.00       0.30       8,192</td></tr><tr><td rowspan=1 colspan=1>1.00       0.30      17,010</td></tr><tr><td rowspan=1 colspan=1>1.00       0.33      20,407</td></tr><tr><td rowspan=1 colspan=1>1.00       0.28      3,112</td></tr><tr><td rowspan=1 colspan=1>0.91       0.33       4,491</td></tr><tr><td rowspan=1 colspan=1>1.00       0.43       5,021</td></tr><tr><td rowspan=1 colspan=1>0.92       0.35       1,765</td></tr><tr><td rowspan=1 colspan=1>0.94       0.34      1,583</td></tr><tr><td rowspan=6 colspan=1>tiny-ImageNet/VGG19</td><td rowspan=6 colspan=1>Zoo (Chen et al.,2017)Decision Boundary (Brendel etal.,2018)Opt-attack (Cheng et al.,2019)AutoZoom (Tu et al.,2019)Bandits (Ilyas et al.,2018b)Meta transfer (ours)Meta attack (ours)</td><td rowspan=1 colspan=1>1.00       0.52      27,827</td></tr><tr><td rowspan=1 colspan=1>1.00       0.52      49,942</td></tr><tr><td rowspan=1 colspan=1>1.00       0.53      71,016</td></tr><tr><td rowspan=1 colspan=1>1.00       0.54      8.904</td></tr><tr><td rowspan=1 colspan=1>0.78       0.54      9,159</td></tr><tr><td rowspan=1 colspan=1>0.99       0.56      3,6240.99       0.53      3,278</td></tr><tr><td rowspan=3 colspan=1>tiny-ImageNet/Resnet34</td><td rowspan=3 colspan=1>Zoo (Chen et al., 2017)Decision Boundary (Brendel et al., 2018)AutoZoom (Tu et al.,2019)Opt-attack (Cheng et al.,2019)Bandits (Ilyas et al.,2018b)Meta transfer (ours)Meta attack (ours)</td><td rowspan=1 colspan=1>1.00       0.47      25,3441.00       0.48      49,9821.00       0.45      9,7701.00       0.52      60,437</td></tr><tr><td rowspan=1 colspan=1>0.73       0.49      9,978</td></tr><tr><td rowspan=1 colspan=1>0.99       0.56       3,5400.99       0.53      3,268</td></tr></table>
+
+# 4.3 MODEL ANALYSIS
+
+Meta Training We first test the benefits of meta training by comparing performance of a metatrained attacker with a Gaussian randomly initialized attacker without meta training on the three datasets. Fig. 3 shows their success rate, $L _ { 2 }$ distortion and query count results for initial success. The meta pre-trained attacker achieves averagely $7 \%$ higher success rate with $1 6 \%$ lower $L _ { 2 }$ distortion and $3 \bar { 0 } \%$ less queries, compared with the randomly initialized one. This justifies the contributions of meta training to enhancing query efficiency and also attack performance.
+
+Guaranteed by fine-tuning, the randomly initialized attacker succeeds over many testing samples. The fine-tuning works like an inner training in meta training. With sufficient fine-tuning iterations, the randomly initialized attacker functions like a well-trained meta attacker. This explains the effectiveness of the randomly initialized meta attacker on many testing samples compromised by more queries. However, it could not predict gradient as accurate as the well-trained meta attacker during earlier iterations. Such inaccuracy leads to larger $L _ { 2 }$ distortion at the beginning. On the contrary, the meta training process enables the well-trained meta attacker to fast-adapt to current testing samples. These results highlight the significant advantages of our meta model towards to black-box attack. The process of meta training makes it familiar with gradient patterns of various models.
+
+Generalizability Here we show that our meta attacker trained on one dataset can be transferred to other datasets. We conduct this experiment between CIFAR10 and tiny-Imagenet, denoted as Meta transfer in Table 1 and 2. We first apply the meta attacker trained on CIFAR10 to attack VGG19, ResNet34 on tiny-Imagenet respectively, which are different from models used for training meta attacker. Note the meta attacker tested on CIFAR10 has no privileged prior and is not familiar with neither tiny-Imagenet dataset nor the corresponding classification models. Similarly, we also use the meta attacker trained on tiny-Imagenet to attack the target ResNet18 model on CIFAR10. The results show the good generalizability and robustness of our proposed meta attacker.
+
+Table 2: MNIST, CIFAR10 and tiny-ImageNet targeted attack comparison: Meta attack significantly outperforms other black-box methods in query numbers.   
+
+<table><tr><td>Dataset/Target model</td><td>Method</td><td>Success Rate</td><td>Avg. L2</td><td>Avg. Queries</td></tr><tr><td rowspan="4">MNIST/Net4</td><td>Zoo (Chen et al.,2017)</td><td>1.00</td><td>2.63</td><td>23,552</td></tr><tr><td>Decision Boundary (Brendel et al.,2018)</td><td>0.64</td><td>2.71</td><td>19,951</td></tr><tr><td>AutoZoom (Tu et al.,2019)</td><td>0.95</td><td>2.52</td><td>6,174</td></tr><tr><td>Opt-attack (Cheng et al.,2019) Meta attack (ours)</td><td>1.00 1.00</td><td>2.33 2.66</td><td>99,661</td></tr><tr><td rowspan="6">CIFAR10/Resnet18</td><td>Zoo (Chen et al.,2017)</td><td>1.00</td><td>0.55</td><td>1,299 66,400</td></tr><tr><td>Decision Boundary (Brendel et al.,2018)</td><td>0.58</td><td>0.53</td><td>16,250</td></tr><tr><td>AutoZoom (Tu et al., 2019)</td><td>1.00</td><td>0.51</td><td>9,082</td></tr><tr><td>Opt-attack (Cheng et al.,2019)</td><td>1.00</td><td>0.50</td><td>121,810</td></tr><tr><td>FW-black (Chen et al.,2018)</td><td>0.90</td><td>0.73</td><td>6.987</td></tr><tr><td>Meta transfer (ours) Meta attack (ours)</td><td>0.92</td><td>0.74</td><td>3,899</td></tr><tr><td rowspan="5">tiny-ImageNet/VGG19</td><td>Zoo (Chen et al., 2017)</td><td>0.93 0.74</td><td>0.77</td><td>3,667</td></tr><tr><td>AutoZoom (Tu et al., 2019)</td><td>0.87</td><td>1.26</td><td>119,648</td></tr><tr><td>Opt-attack (Cheng et al.,2019)</td><td>0.66</td><td>1.45 1.14</td><td>53,778</td></tr><tr><td>Meta transfer (ours)</td><td></td><td></td><td>252.009</td></tr><tr><td>Meta attack (ours)</td><td>0.55 0.54</td><td>1.37 1.24</td><td>12,275 11,498</td></tr><tr><td rowspan="5">tiny-ImageNet/Resnet34</td><td>Zoo (Chen et al., 2017)</td><td>0.60</td><td>1.03</td><td>88.966</td></tr><tr><td>AutoZoom (Tu et al., 2019)</td><td>0.95</td><td>1.15</td><td>52,174</td></tr><tr><td>Opt-attack (Cheng et al.,2019)</td><td>0.78</td><td>1.00</td><td>214,015</td></tr><tr><td>Meta transfer (ours)</td><td>0.69</td><td>1.40</td><td></td></tr><tr><td>Meta attack (ours)</td><td>0.54</td><td>1.21</td><td>13,435 12,897</td></tr></table>
+
+![](images/f6ae08a6a4802b46d90532b0d870dd511117f516cbbfadefd90e9b3b99b561fd.jpg)  
+Figure 3: Comparison of randomly initialized and well-trained meta attackers.
+
+Parameters Selection We test the selection of top- $q$ and $\beta$ on CIFAR10. We choose $q$ ranging from 350 to 600 and give the results with $\beta$ ranging from 3e-3 to 5e-3, as shown in Fig. 2. When $q$ increases, query number, success rate and $L _ { 2 }$ will all increase. In order to balance the overall result, we choose $q$ to be 500. When $\beta$ increases, success rate and $L _ { 2 }$ will increase and query number decreases. In order to balance success rate and query, we choose $\beta$ to be 4e-3 in the experiment.
+
+# 5 CONCLUSION
+
+We propose a meta-based black-box attack method that largely reduces demanded query numbers without compromising in attack success rate and distortion. We train a meta attacker to learn useful prior information about gradient and incorporate it into the optimization process to decrease the number of queries. Specifically, the meta attacker is finetuned to fit the gradient distribution of target model and each update is based on the output of finetuned meta attaker. Extensive experimental results confirm the superior query-efficiency of our method over baselines.
+
+# ACKNOWLEDGEMENT
+
+This research is partially supported by Programmatic grant no. A1687b0033 from the Singapore government’s Research, Innovation and Enterprise 2020 plan (Advanced Manufacturing and Engineering domain).
+
+Hu Zhang (No. 201706340188) is partially supported by the Chinese Scholarship Council.
+
+Jiashi Feng was partially supported by NUS IDS R-263-000-C67-646, ECRA R-263-000-C87-133, MOE Tier-II R-263-000-D17-112 and AI.SG R-263-000-D97-490.
+
+# REFERENCES
+
+W. Brendel, J. Rauber, and M. Bethge. Decision-based adversarial attacks: Reliable attacks against black-box machine learning models. In International Conference on Learning Representations, 2018. URL https://arxiv.org/abs/1712.04248.
+
+Nicholas Carlini and David Wagner. Towards evaluating the robustness of neural networks. In 2017 IEEE Symposium on Security and Privacy (SP), pp. 39–57. IEEE, 2017.
+
+Jinghui Chen, Jinfeng Yi, and Quanquan Gu. A frank-wolfe framework for efficient and effective adversarial attacks. arXiv preprint arXiv:1811.10828, 2018.
+
+Pin-Yu Chen, Huan Zhang, Yash Sharma, Jinfeng Yi, and Cho-Jui Hsieh. Zoo: Zeroth order optimization based black-box attacks to deep neural networks without training substitute models. In Proceedings of the 10th ACM Workshop on Artificial Intelligence and Security, pp. 15–26. ACM, 2017.
+
+Minhao Cheng, Thong Le, Pin-Yu Chen, Huan Zhang, JinFeng Yi, and Cho-Jui Hsieh. Queryefficient hard-label black-box attack: An optimization-based approach. In International Conference on Learning Representations, 2019. URL https://openreview.net/forum?id= rJlk6iRqKX.
+
+Riley Edmunds, Noah Golmant, Vinay Ramasesh, Phillip Kuznetsov, Piyush Patil, and Raul Puri. Transferability of adversarial attacks in model-agnostic meta-learning. Deep Learning and Security Workshop (DLSW) in Singapore, 2017.
+
+Chelsea Finn, Pieter Abbeel, and Sergey Levine. Model-agnostic meta-learning for fast adaptation of deep networks. In Proceedings of the 34th International Conference on Machine LearningVolume 70, pp. 1126–1135. JMLR. org, 2017.
+
+Saeed Ghadimi and Guanghui Lan. Stochastic first-and zeroth-order methods for nonconvex stochastic programming. SIAM Journal on Optimization, 23(4):2341–2368, 2013.
+
+Ian Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. In International Conference on Learning Representations, 2015. URL http:// arxiv.org/abs/1412.6572.
+
+Elad Hazan et al. Introduction to online convex optimization. Foundations and Trends $\textsuperscript { \textregistered }$ in Optimization, 2(3-4):157–325, 2016.
+
+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.
+
+Andrew Ilyas, Logan Engstrom, Anish Athalye, and Jessy Lin. Black-box adversarial attacks with limited queries and information. In Proceedings of the 35th International Conference on Machine Learning, ICML 2018, July 2018a. URL https://arxiv.org/abs/1804.08598.
+
+Andrew Ilyas, Logan Engstrom, and Aleksander Madry. Prior convictions: Black-box adversarial attacks with bandits and priors. arXiv preprint arXiv:1807.07978, 2018b.
+
+Rie Johnson and Tong Zhang. Accelerating stochastic gradient descent using predictive variance reduction. In Advances in neural information processing systems, pp. 315–323, 2013.
+
+Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. Technical report, Citeseer, 2009.
+
+Yann LeCun. The mnist database of handwritten digits. http://yann. lecun. com/exdb/mnist/, 1998.
+
+Aleksander Madry, Aleksandar Makelov, Ludwig Schmidt, Dimitris Tsipras, and Adrian Vladu. Towards deep learning models resistant to adversarial attacks. In International Conference on Learning Representations, 2018. URL https://openreview.net/forum?id $\underline { { \underline { { \mathbf { \Pi } } } } }$ rJzIBfZAb.
+
+Seyed-Mohsen Moosavi-Dezfooli, Alhussein Fawzi, and Pascal Frossard. Deepfool: a simple and accurate method to fool deep neural networks. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 2574–2582, 2016.
+
+Nina Narodytska and Shiva Kasiviswanathan. Simple black-box adversarial attacks on deep neural networks. In 2017 IEEE Conference on Computer Vision and Pattern Recognition Workshops (CVPRW), pp. 1310–1318. IEEE, 2017.
+
+Yurii Nesterov. Introductory lectures on convex optimization: A basic course, volume 87. Springer Science & Business Media, 2013.
+
+Yurii Nesterov and Vladimir Spokoiny. Random gradient-free minimization of convex functions. Foundations of Computational Mathematics, 17(2):527–566, 2017.
+
+Alex Nichol, Joshua Achiam, and John Schulman. On first-order meta-learning algorithms. arXiv preprint arXiv:1803.02999, 2018.
+
+Nicolas Papernot, Patrick McDaniel, Ian Goodfellow, Somesh Jha, Z Berkay Celik, and Ananthram Swami. Practical black-box attacks against machine learning. In Proceedings of the 2017 ACM on Asia conference on computer and communications security, pp. 506–519. ACM, 2017.
+
+Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael Bernstein, Alexander C. Berg, and Li Fei-Fei. ImageNet Large Scale Visual Recognition Challenge. International Journal of Computer Vision (IJCV), 115(3):211–252, 2015. doi: 10.1007/s11263-015-0816-y.
+
+Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. arXiv preprint arXiv:1409.1556, 2014.
+
+Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. In International Conference on Learning Representations, 2014. URL http://arxiv.org/abs/1312.6199.
+
+Christian Szegedy, Wei Liu, Yangqing Jia, Pierre Sermanet, Scott Reed, Dragomir Anguelov, Dumitru Erhan, Vincent Vanhoucke, and Andrew Rabinovich. Going deeper with convolutions. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 1–9, 2015.
+
+Chun-Chen Tu, Paishun Ting, Pin-Yu Chen, Sijia Liu, Huan Zhang, Jinfeng Yi, Cho-Jui Hsieh, and Shin-Ming Cheng. Autozoom: Autoencoder-based zeroth order optimization method for attacking black-box neural networks. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 33, pp. 742–749, 2019.
+
+Daniel Zgner and Stephan Gnnemann. Adversarial attacks on graph neural networks via meta learning. In International Conference on Learning Representations, 2019. URL https: //openreview.net/forum?id $=$ Bylnx209YX.
+
+# 6 APPENDIX
+
+# 6.1 MORE EXPERIMENTAL RESULTS
+
+# 6.1.1 COSINE SIMILARITY BETWEEN ESTIMATED GRADIENTS AND WHITE-BOX GRADIENTS
+
+To demonstrate the ability of estimating gradient of our meta attacker, we have conducted experiments with the Resnet-34 model on the tiny-Imagenet dataset to compare the cosine similarity between the estimated gradients from our proposed meta-attacker and the accurate white-box gradients. We also compare the cosine similarity between ZOO (Chen et al., 2017) estimated gradients and the white-box gradients as reference. The results of cosine similarity and required number of queries are shown in Table 3. We can observe that our meta-attacker does fast-adapt to the target model and generate accurate gradients. Not only it estimates gradients with positive cosine similarity to the true gradients, but it also performs closer to the ZOO estimated results with the same small standard deviation.
+
+Table 3: Cosine similarity between estimated gradients and white-box gradients.   
+
+<table><tr><td></td><td colspan="2">Ours meta-attacker</td><td colspan="2">ZOO (Chen et al.,2017)</td></tr><tr><td>Task Type</td><td>Similarity</td><td>Queries</td><td>Similarity</td><td>Queries</td></tr><tr><td>Untargeted</td><td>0.356± 0.074</td><td>3,268</td><td>0.395 ± 0.079</td><td>25,344</td></tr><tr><td>Targeted</td><td>0.225 ± 0.090</td><td>12,897</td><td>0.363 ± 0.069</td><td>88,966</td></tr></table>
+
+# 6.1.2 VANILLA TRAINING AUTOENCODER AND META-ATTACKER LEARNING FROMESTIMATED GRADIENTS
+
+We have conducted experiments in section 4.3 to demonstrate the benefits of meta training. However, we only compare the performance of a meta-trained attacker with a Gaussian randomly initialized attacker. We conduct two more experiments on meta training here to further investigate the benefits of meta training. First we compare our meta-trained attacker with a vanilla autoencoder that learns to map images to gradients of one white-box model. The vanilla autoencoder has the same architecture with our meta-attacker, but it is trained in one white-box model. Then, we train a new meta-attacker in four black-box models, i.e., the gradients used for training are estimated via ZOO (Chen et al., 2017). The experiment results are presented in Table 4, 5 .
+
+Table 4: MNIST untargeted attack comparison.   
+
+<table><tr><td>Method</td><td>Success Rate</td><td>Avg.L2</td><td>Avg. Queries</td></tr><tr><td>Ours(reported)</td><td>1.000</td><td>1.78</td><td>1,103</td></tr><tr><td>ZOO estimated</td><td>1.000</td><td>1.77</td><td>1,130</td></tr><tr><td>Vanilla Autoencoder</td><td>1.000</td><td>1.93</td><td>1,899</td></tr><tr><td>Initialised attacker</td><td>0.912</td><td>1.96</td><td>1,721</td></tr></table>
+
+Table 5: MNIST targeted attack comparison.   
+
+<table><tr><td>Method</td><td>Success Rate</td><td>Avg.L2</td><td>Avg. Queries</td></tr><tr><td>Ours(reported)</td><td>1.000</td><td>2.66</td><td>1,971</td></tr><tr><td>ZOO estimated</td><td>1.000</td><td>2.42</td><td>2,105</td></tr><tr><td>Vanilla Autoencoder</td><td>1.000</td><td>2.80</td><td>2,905</td></tr><tr><td>Initialised attacker</td><td>0.895</td><td>2.81</td><td>3,040</td></tr></table>
+
+The two experiments are conducted on 1000 randomly selected images from the MNIST testing set. As for the four approach settings: ”Ours (reported)” is the results we report in our paper; ”ZOO estimated” is the meta-attacker trained from ZOO estimated gradients; ”Vanilla Autoencoder” is the autoencoder maps image to gradient trained in one different MNIST classification model; ”Initialised attacker” is the meta-attacker with randomly initialized weights. We can see the ”ZOO estimated” model performs closer to our reported meta-attacker. However, the ”Vanilla Autoencoder” performs much worse (with larger L2-norm and more queries), which performs similarly to randomly initialized meta-attacker. The two experiments verify the effectiveness of our first meta-training phase.
+
+# 6.2 STRUCTURE OF META ATTACKER
+
+Table 6: Structure of meta attacker. Conv: convolutional layer, Convt: de-convolutional layer.   
+
+<table><tr><td>Meta attacker (MNIST)</td><td>Meta attacker (CIFAR10, tiny-ImageNet)</td></tr><tr><td>Conv(16,3,3,1)+ ReLu +bn</td><td>Conv(32,3,3,1)+ ReLu +bn</td></tr><tr><td>Conv(32,4,4,2) +] ReLu +bn</td><td>Conv(64,4,4,2)+ ReLu + bn</td></tr><tr><td>Conv(64,4,4,2)+ ReLu +bn</td><td>Conv(128,4,4,2)+ReLu +bn</td></tr><tr><td>Conv(64,4,4,2)+ ReLu + bn</td><td>Conv(256,4,4,2)+ReLu +bn</td></tr><tr><td>Convt(64,4,4,2)+ ReLu +bn</td><td>Convt(256,4,4,2)+ReLu+ bn</td></tr><tr><td>Convt(32,4,4,2)+ ReLu + bn</td><td>Convt(128,4,4,2)+ReLu+bn</td></tr><tr><td>Convt(16,4,4,2)+ ReLu +bn</td><td>Convt(64,4,4,2)+ ReLu +bn</td></tr><tr><td>Convt(8,3,3,1)+ ReLu +bn</td><td>Convt(32,3,3,1)+ ReLu +bn</td></tr></table>
+
+# 6.3 STRUCTURE OF TARGET MODEL USED IN MNIST
+
+Table 7: Neural network architecture used on MNIST.   
+
+<table><tr><td>MNIST Model (Conv: convolutional layer,FC: fully connected layer.)</td></tr><tr><td>Conv(128,3,3)+ Tanh</td></tr><tr><td>MaxPool(2,2)</td></tr><tr><td>Conv(64,3,3)+ Tanh</td></tr><tr><td>MaxPool(2,2)</td></tr><tr><td>FC(128) +Relu</td></tr><tr><td>FC(10)+ Softmax</td></tr></table>
+
+# 6.4 ACCURACY OF TARGET MODELS ON ORIGINAL DATASETS
+
+Table 8: Accuracy of each target model on each dataset   
+6.5 ADVERSARIAL EXAMPLES GENERATED BY OUR METHOD   
+
+<table><tr><td>Dataset</td><td>MNIST</td><td>CIFAR10</td><td colspan="2">tiny-ImageNet</td></tr><tr><td>Model</td><td>MNIST Model</td><td>Resnet18</td><td>VGG19</td><td>Resnet34</td></tr><tr><td>Accuracy</td><td>0.9911</td><td>0.9501</td><td>0.6481</td><td>0.6972</td></tr></table>
+
+![](images/11b365cdb9479d380ee88693afffb0cc81c3e974ce8f7b69bbdb265161d5613a.jpg)  
+Figure 4: Adversarial examples generated by our method on MNIST. The groundtruth images are shown in the diagonal and the rest are adversarial examples that are misclassified to the targeted class shown on the top.
+
+![](images/4a74d96d9db5a1218e195e43c1dfcd03d5e2a98ff41a7b170f981043ef824aff.jpg)  
+Figure 5: Adversarial examples generated by our method on CIFAR10. The groundtruth images are shown in the diagonal and the rest are adversarial examples that are misclassified to the targeted class shown on the top.

parse/train/Skxd6gSYDS/Skxd6gSYDS_content_list.json

@@ -0,0 +1,1429 @@
+[
+    {
+        "type": "text",
+        "text": "QUERY-EFFICIENT META ATTACK TO DEEP NEURAL NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            99,
+            689,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Jiawei $\\mathbf { D } \\mathbf { u } ^ { 1 , 3 : }$ ∗, Hu Zhang2∗, Joey Tianyi Zhou3, Yi Yang2 , Jiashi Feng1 ",
+        "bbox": [
+            187,
+            169,
+            674,
+            185
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1Dept. ECE, National University of Singapore, Singapore 2ReLER, University of Technology Sydney, Australia 3Institute of High performance Computing, A\\*STAR, Singapore dujiawei@u.nus.edu,Hu.Zhang-1@student.uts.edu.au joey.tianyi.zhou@gmail.com,Yi.Yang@uts.edu.au elefjia@nus.edu.sg ",
+        "bbox": [
+            184,
+            185,
+            655,
+            268
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            305,
+            544,
+            320
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Black-box attack methods aim to infer suitable attack patterns to targeted DNN models by only using output feedback of the models and the corresponding input queries. However, due to lack of prior and inefficiency in leveraging the query and feedback information, existing methods are mostly query-intensive for obtaining effective attack patterns. In this work, we propose a meta attack approach that is capable of attacking a targeted model with much fewer queries. Its high queryefficiency stems from effective utilization of meta learning approaches in learning generalizable prior abstraction from the previously observed attack patterns and exploiting such prior to help infer attack patterns from only a few queries and outputs. Extensive experiments on MNIST, CIFAR10 and tiny-Imagenet demonstrate that our meta-attack method can remarkably reduce the number of model queries without sacrificing the attack performance. Besides, the obtained meta attacker is not restricted to a particular model but can be used easily with a fast adaptive ability to attack a variety of models. The code of our work is available at https://github.com/dydjw9/MetaAttack_ICLR2020/. ",
+        "bbox": [
+            233,
+            339,
+            764,
+            547
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            578,
+            336,
+            594
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Despite the great success in various tasks, deep neural networks (DNNs) are found to be susceptible to adversarial attacks and often suffer dramatic performance degradation in front of adversarial examples, even if only tiny and invisible noise is imposed on the input (Szegedy et al., 2014). To investigate the safety and robustness of DNNs, many adversarial attack methods have been developed, which apply to either a white-box (Goodfellow et al., 2015; Moosavi-Dezfooli et al., 2016; Carlini & Wagner, 2017; Madry et al., 2018) or a black-box setting (Papernot et al., 2017; Brendel et al., 2018; Narodytska & Kasiviswanathan, 2017). In the white-box attack setting, the target model is transparent to the attacker and imperceptible adversarial noise can be easily crafted to mislead this model by leveraging its gradient information (Goodfellow et al., 2015). In contrast, in the blackbox setting, the structure and parameters of the target DNN model are invisible, and the adversary can only access the input-output pair in each query. With a sufficient number of queries, black-box methods utilize the returned information to attack the target model generally by estimating gradient (Chen et al., 2017; Ilyas et al., 2018a; Narodytska & Kasiviswanathan, 2017; Cheng et al., 2019). ",
+        "bbox": [
+            173,
+            612,
+            825,
+            791
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Black-box attack is more feasible in realistic scenarios than white-box attack but it is much more query-intensive. Such a drawback is largely attributed to the fact that returned information for each queried example is sparse and limited. During inferring attack patterns, existing black-box methods simply integrate the information between two sequential iterations brutally and ignore the implicit but profound message, thus not fully exploiting the returned information. Although query-efficient algorithms for generating attack examples are very meaningful in practice (Ilyas et al., 2018a), how to enhance query-efficiency for black-box attack remains underexplored. ",
+        "bbox": [
+            174,
+            799,
+            823,
+            897
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this work, we address a query-efficiency concerned attack problem. Particularly, we consider only top- $k$ probability scores accessible from the target black-box model. With this practical but challenging scenario, we aim at three important objectives: lower query number, higher success rate and smaller noise magnitude. We develop a meta-learning based attack method, which applies meta learning to obtaining prior information from the successful attack patterns, and uses the prior for efficient optimization. Specifically, we propose to train a meta attacker model through meta learning (Nichol et al., 2018), inspired by its success in solving few-shot learning problems. We first deploy several existing classification models to get pairs of (images, gradients) with the max-margin logit classification loss. Then we use the data pairs of each classification model to train the meta attacker. After obtaining the attacker, we use it to attack a new black-box model for accelerating the search process for adversarial examples by optimizing it with coordinate-wise gradient estimation. Different from previous methods, we use the estimated gradient not only to update adversarial noise but to fine-tune the well-trained attacker. After few-shot fine-tuning, the attacker is able to simulate the gradient distribution of the target model. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            297
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We evaluate our method on MNIST, CIFAR10 and tiny-ImageNet datasets by comparing it with state-of-the-art black-box attack methods including Zoo (Chen et al., 2017), DecisionBoundary (Brendel et al., 2018), AutoZoom (Tu et al., 2019), Opt-attack (Cheng et al., 2019) and Bandits (Ilyas et al., 2018b). In both targeted and untargeted settings, our proposed method achieves comparable attack success rate and adversarial perturbation to all baselines but with a significantly reduced query number. The detailed experiment results demonstrate our superior query-efficiency. ",
+        "bbox": [
+            174,
+            305,
+            825,
+            388
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            411,
+            343,
+            428
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Classical white-box attack methods include Fast-Gradient Sign Method (FGSM) (Goodfellow et al., 2015), IFGSM (Madry et al., 2018), DeepFool (Moosavi-Dezfooli et al., 2016) and C&W attack (Carlini & Wagner, 2017), following a setting where detailed information about the target model (gradients and losses) is provided. Comparatively, the black-box setting better accords with the real world scenarios in that little information about the target model is visible to the attacker. The pioneer work on black-box attack (Papernot et al., 2017) tries to construct a substitute model with augmented data and transfer the black-box attack problem to a white-box one. However, its attack performance is very poor due to the limited transferability of adversarial examples between two different models. (Brendel et al., 2018) considers a more restricted case where only top-1 prediction classes are returned and proposes a random-walk based attack method around the decision boundary. It dispenses class prediction scores and hence requires extensive model queries. Zoo (Chen et al., 2017) is a black-box version of C&W attack, achieving a similar attack success rate and comparable visual quality as many white-box attack methods. However, its coordinate-wise gradient estimation requires extensive model evaluations. More recently, (Ilyas et al., 2018a) proposes a query-limited setting with $L _ { \\infty }$ noise considered, and uses a natural evolution strategy (NES) to enhance query efficiency. Though this method successfully controls the query number, the noise imposed is larger than average. (Narodytska & Kasiviswanathan, 2017) proposes a novel local-search based technique to construct numerical approximation to the network gradient, which is then carefully used to construct a small set of pixels in an image to perturb. It suffers a similar problem as in (Chen et al., 2017) for pixel-wise attack. (Cheng et al., 2019) considers a hard-label black-box setting and formulates the problem as real-valued optimization that is solved by a zeroth order optimization algorithm. Ilyas et al. (2018b) reduce the queries by introducing two gradient priors, the time-independent prior and the data-dependent prior, and reformulating the optimization problem. ",
+        "bbox": [
+            173,
+            444,
+            825,
+            763
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We then briefly introduce some works on meta-learning related to our work. Meta-learning is a process of learning how to learn. A meta-learning algorithm takes in a distribution of tasks, each being a learning problem, and produces a quick learner that can generalize from a small number of examples. Meta-learning is very popular recently for its fast adaptive ability. MAML (Finn et al., 2017) is the first to propose this idea. Recently, a simplified algorithm Reptile (Nichol et al., 2018) which is an approximation to the first-order MAML is proposed, achieving higher efficiency in computation and consuming less memory. With these superior properties, meta learning is applied to adversarial attack methods (Zgner & Gnnemann, 2019; Edmunds et al., 2017). Zgner & Gnnemann (2019) try to attack the structure of a graph model in the training process to decrease the model generalization performance. Edmunds et al. (2017) investigate the susceptibility of MAML to adversarial attacks and the transferability of the obtained meta model to a specific task. ",
+        "bbox": [
+            174,
+            771,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3 METHOD ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            282,
+            118
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 PRELIMINARIES: BLACK-BOX ATTACK SCHEMES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            133,
+            555,
+            148
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We first formulate the black-box attack problem and introduce the widely used solutions. We use $( { \\pmb x } , t )$ to denote the pair of a natural image and its true label, and $\\hat { \\pmb x }$ and $\\dot { t }$ to denote the adversarial perturbed version of $_ { \\textbf { \\em x } }$ and the returned label by the target classification model $\\mathcal { M } _ { t a r }$ . The black-box attack aims to find an adversarial example $\\hat { \\pmb x }$ with imperceivable difference from $_ { \\textbf { \\em x } }$ to fail the target model , i.e., ${ \\hat { t } } \\neq t$ through querying the target model for multiple times. It can be formulated as ",
+        "bbox": [
+            173,
+            159,
+            825,
+            229
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ebc524132adf31870e2d58896f478f21a204665e6f0d4edf4b0c856c88865a26.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\underset { \\hat { \\pmb { x } } } { \\operatorname* { m i n } } \\ell ( \\hat { \\pmb { x } } , \\mathcal { M } _ { t a r } ( \\hat { \\pmb { x } } ) , t ) } \\\\ & { \\mathrm { s . t . } \\ \\lVert \\hat { \\pmb { x } } - \\pmb { x } \\rVert _ { p } \\leq \\rho , \\ \\# \\mathrm { q u e r i e s } \\leq \\mathrm { Q } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            377,
+            234,
+            620,
+            279
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Here $\\| \\cdot \\| _ { p }$ denotes the $\\ell _ { p }$ norm that measures how much perturbation is imposed. $\\mathcal { M } _ { t a r } ( \\hat { \\pmb x } )$ is the returned logit or probability by the target model $\\mathcal { M } _ { t a r }$ . The loss function $\\ell ( \\hat { \\pmb x } , \\mathcal { M } _ { t a r } ( \\hat { \\pmb x } ) , t )$ measures the degree of certainty for model $\\mathcal { M } _ { t a r }$ assigning the input $\\hat { \\pmb x }$ into class $t$ . One common used adversarial loss is the probability of class $t$ : $\\boldsymbol { \\ell } ( \\hat { \\mathbf { x } } , \\mathcal { M } _ { t a r } ( \\hat { \\mathbf { x } } ) , t ) = p _ { \\mathcal { M } _ { t a r } } ( t | \\hat { \\mathbf { x } } )$ . The first constraint enforces high similarity between the clean image $_ { \\textbf { \\em x } }$ and the adversarial one $\\mathbf { \\Delta } \\mathbf { x } _ { a d v }$ and the second imposes a fixed budget $Q$ for the number of queries allowed in the optimization. ",
+        "bbox": [
+            173,
+            284,
+            825,
+            368
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In the white-box attack setting, the adversary can access the true gradient $\\nabla _ { \\hat { \\pmb { x } } _ { t } } \\ell ( \\hat { \\pmb { x } } _ { t } )$ and perform gradient descent $\\hat { { \\pmb x } } _ { t + 1 } = \\hat { { \\pmb x } } _ { t } - \\nabla _ { \\hat { { \\pmb x } } _ { t } } \\ell ( \\hat { { \\pmb x } } _ { t } )$ . But in the black-box setting, the gradient information $\\bar { \\nabla } _ { \\hat { \\pmb { x } } _ { t } } \\ell ( \\hat { \\pmb { x } } _ { t } )$ is not attainable. In this case, the attacker can estimate the gradient using only queried information from model evaluation such as hard label, logits and probability scores. This kind of estimator is the backbone of so-called zeroth-order optimization approaches (Chen et al., 2017; Narodytska & Kasiviswanathan, 2017; Tu et al., 2019; Ilyas et al., 2018a;b). The estimation is done via finite difference method (Chen et al., 2017; Narodytska & Kasiviswanathan, 2017; Tu et al., 2019), which finds the $k$ components of the gradient by estimating the inner products of the gradients with all the standard basis vector $e _ { 1 } , . . . , e _ { k }$ : ",
+        "bbox": [
+            173,
+            375,
+            825,
+            501
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/69de960203079b3568adfdef7f620e6f94c22ba733dd20205c1c2d087469e754.jpg",
+        "text": "$$\n\\nabla \\ell ( { \\pmb x } ) \\approx \\sum _ { i = 1 } ^ { k } \\frac { f ( { \\pmb x } + h { \\pmb e } _ { i } ) - f ( { \\pmb x } - h { \\pmb e } _ { i } ) } { 2 h } { \\pmb e } _ { i } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            352,
+            507,
+            643,
+            550
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where step size $h$ controls the quality of the estimated gradient. Another strategy is to reformulate the loss function (Ilyas et al., 2018a;b). Instead of computing the gradient of $\\ell ( { \\pmb x } )$ itself, the expected value of loss function $\\ell ( { \\pmb x } )$ under the search distribution is minimized and when the search distribution of random Guassian noise is adopted, the gradient estimation problem transfers into a zeroth-order estimation problem, ",
+        "bbox": [
+            174,
+            555,
+            825,
+            626
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/cf0dd7c10a02365bed082bfd3270c9fced88f57a4ea243b76548d9473b3b45af.jpg",
+        "text": "$$\n\\nabla \\mathbb { E } [ \\ell ( \\pmb { x } ) ] \\approx \\frac { 1 } { \\sigma n } \\sum _ { i = 1 } ^ { n } \\ell ( \\pmb { x } + \\sigma \\delta _ { i } ) \\delta _ { i }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            383,
+            631,
+            614,
+            672
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $n$ is the amount of noise sampled from the distribution. After obtaining the estimated gradient, classical optimization algorithms (Nesterov, 2013; Johnson & Zhang, 2013) can be used to infer the adversarial examples. Though the estimated gradient may not be accurate, it is still proved useful enough in adversarial attack. The convergence of these zeroth-order methods is guaranteed under mild assumptions (Ghadimi & Lan, 2013; Nesterov & Spokoiny, 2017; Hazan et al., 2016). ",
+        "bbox": [
+            174,
+            678,
+            825,
+            748
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Since each model evaluation consumes a query, naively applying the above gradient estimation to black-box attack is quite query expensive due to its coordinate or noise sampling nature. Take the first strategy on tiny-Imagenet dataset for example. It consumes more than 20,000 queries for each image to obtain a full gradient estimate, which is not affordable in practice. In this work, we address such a limitation via developing a query-efficient meta-learning based attack model. ",
+        "bbox": [
+            174,
+            755,
+            825,
+            825
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2 LEARNING OF META ATTACKER ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            842,
+            436,
+            856
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To reduce the query cost for black-box attack, we apply meta learning to training a meta attacker model, inspired by its recent success in few-shot learning problems (Finn et al., 2017; Nichol et al., 2018). The meta attacker learns to extract useful prior information of the gradient of a variety of models w.r.t. specific input samples. It can infer the gradient for a new target model using only a ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 Meta Attacker Training ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            418,
+            118
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Input: Input images $\\mathbb { X }$ , groundtruth gradients $\\mathbb { G } _ { i }$ generated from classification models $\\mathcal { M } _ { i }$ to serve   \nas task $\\mathcal { T } _ { i }$ ;   \n1: Randomly initialize $\\pmb \\theta$ ;   \n2: while not done do   \n3: for all $\\mathcal { T } _ { i }$ do   \n4: Sample $K$ samples from $( \\mathbb { X } , \\mathbb { G } _ { i } )$ for training, denoted as $( \\mathbb { X } _ { s } , \\mathbb { G } _ { i } ^ { s } )$ ;   \n5: Evaluate $\\nabla _ { \\pmb { \\theta } } \\mathcal { L } _ { i } ( \\mathcal { A } _ { \\pmb { \\theta } } ) = \\nabla _ { \\pmb { \\theta } } \\| \\mathcal { A } _ { \\pmb { \\theta } } ( \\mathbb { X } _ { s } ) - \\mathbb { G } _ { i } ^ { s } \\| _ { 2 } ^ { 2 }$ with respect to $( \\mathbb { X } _ { s } , \\mathbb { G } _ { i } ^ { s } )$ ;   \n6: Update $\\pmb { \\theta } _ { i } ^ { \\prime } : = \\pmb { \\theta } - \\alpha \\nabla _ { \\pmb { \\theta } } \\mathcal { L } _ { i } ( \\mathcal { A } _ { \\pmb { \\theta } } )$ ;   \n7: end for   \n8: Update $\\begin{array} { r } { \\pmb { \\theta } : = \\pmb { \\theta } + \\epsilon \\frac { 1 } { n } \\sum _ { i = 1 } ^ { n } ( \\pmb { \\theta } _ { i } ^ { \\prime } - \\pmb { \\theta } ) } \\end{array}$ ;   \n9: end while ",
+        "bbox": [
+            178,
+            119,
+            823,
+            273
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Output: Parameters $\\pmb \\theta$ of meta model $\\mathcal { A }$ . ",
+        "bbox": [
+            178,
+            273,
+            449,
+            286
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "few queries. After obtaining such a meta attacker, we replace the zeroth-order gradient estimation in traditional black box attack methods with it to directly estimate the gradient. ",
+        "bbox": [
+            171,
+            316,
+            821,
+            344
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We collect a set of existing classification models $\\mathcal { M } _ { 1 } , . . . , \\mathcal { M } _ { n }$ to generate gradient information for universal meta attacker training. Specifically, we feed each image $_ { \\textbf { \\em x } }$ into the models $\\mathcal { M } _ { 1 } , . . . , \\mathcal { M } _ { n }$ respectively and compute losses $\\ell _ { 1 } , . . . , \\ell _ { n }$ by using following max-margin logit classification loss: ",
+        "bbox": [
+            174,
+            352,
+            821,
+            395
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b49b3a5d6ef6d36c5db73ba1abdf69c5a0998df7991e7236d77564ae268d8b3b.jpg",
+        "text": "$$\n\\ell _ { i } ( { \\pmb x } ) = \\mathrm { m a x } \\left[ \\mathrm { l o g } [ \\mathcal { M } _ { i } ( { \\pmb x } ) ] _ { t } - \\underset { j \\neq t } { \\mathrm { m a x } } \\mathrm { l o g } [ \\mathcal { M } _ { i } ( { \\pmb x } ) ] _ { j } , 0 \\right] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            320,
+            398,
+            678,
+            433
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Here $t$ is the groundtruth label and $j$ indexes other classes. $[ \\mathcal { M } _ { i } ( \\pmb { x } ) ] _ { t }$ is the probability score of the true label predicted by the model $\\mathcal { M } _ { i }$ , and $[ \\mathcal { M } _ { i } ( \\pmb { x } ) ] _ { j }$ denotes the probability scores of other classes. By performing one step back-propagation of losses $\\ell _ { 1 } , . . . , \\ell _ { n }$ w.r.t. the input images $_ { \\textbf { \\em x } }$ , the corresponding gradients ${ \\pmb g } _ { i } = \\nabla _ { { \\pmb x } } \\ell _ { i } ( { \\pmb x } ) , i = 1 , . . . , n$ are obtained. Finally, we collect $n$ groups of data $\\bar { \\mathbb { X } } = \\{ \\pmb { x } \\} , \\bar { \\mathbb { G } } _ { i } = \\{ \\pmb { g } _ { i } \\bar  \\} , i = 1 , . . . , n$ to train the universal meta attacker. ",
+        "bbox": [
+            173,
+            436,
+            825,
+            508
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We design a meta attacker $\\mathcal { A }$ which has a similar structure as an autoencoder, consisting of symmetric convolution and de-convolution layers and outputs a gradient map with the same size as the input. Meta attacker model $\\mathcal { A }$ is parameterized with parameters $\\pmb \\theta$ . ",
+        "bbox": [
+            176,
+            513,
+            823,
+            556
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Due to the intrinsic difference between selected classification models, each obtained set $\\left( \\mathbb { X } , \\mathbb { G } _ { i } \\right)$ is treated as a task $\\mathcal { T } _ { i }$ in meta attacker training. During the training process, for each iteration we only draw $K$ samples from task $\\mathcal { T } _ { i }$ and feedback the loss $\\mathcal { L } _ { i }$ to update model parameters from $\\pmb \\theta$ to $\\pmb { \\theta } _ { i } ^ { \\prime }$ . $\\pmb { \\theta } _ { i } ^ { \\prime }$ is then computed through one or multiple gradient descents: $\\pmb { \\theta } _ { i } ^ { \\prime } : = \\pmb { \\theta } - \\alpha \\nabla _ { \\pmb { \\theta } } \\mathcal { L } _ { i } ( \\mathcal { A } _ { \\pmb { \\theta } } )$ . For a sensitive position of the meta attacker, the meta attacker parameters are optimized by combining each $\\pmb { \\theta } _ { i } ^ { \\prime }$ across all tasks $\\{ \\mathcal { T } _ { i } \\} _ { i = 1 , \\dots , n }$ , following the update strategy of Reptile (Nichol et al., 2018) in meta learning, ",
+        "bbox": [
+            173,
+            563,
+            825,
+            661
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/50cd1098bfd2a0fef7d2337a7a4e64a9017d8216e17d166705a24ec037843dbb.jpg",
+        "text": "$$\n\\pmb \\theta : = \\pmb \\theta + \\epsilon \\frac { 1 } { n } \\sum _ { i = 1 } ^ { n } ( \\pmb \\theta _ { i } ^ { \\prime } - \\pmb \\theta ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            410,
+            659,
+            588,
+            699
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We adopt mean-squared error (MSE) as the training loss in the inner update, ",
+        "bbox": [
+            173,
+            700,
+            673,
+            715
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1d95069983c4fd7aef2741fef48939d32ab2dcfff73efd89163d40411d45e9b8.jpg",
+        "text": "$$\n\\mathcal { L } _ { i } ( \\mathcal { A } _ { \\theta } ) = \\| \\mathcal { A } _ { \\theta } ( \\mathbb { X } _ { s } ) - \\mathbb { G } _ { i } ^ { s } \\| _ { 2 } ^ { 2 } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            400,
+            718,
+            598,
+            737
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The set $( \\mathbb { X } _ { s } , \\mathbb { G } _ { i } ^ { s } )$ denotes the $K$ samples used for each inner update from $\\pmb \\theta$ to $\\theta _ { i } ^ { \\prime }$ . Since the number of $K$ sampled each time is very small, the update strategy above tries to find good meta attacker parameters $\\pmb \\theta$ as an initial point, from which the meta attacker model can fast adapt to new data distribution through gradient descent based fine-tuning within limited samples. Therefore, this characteristic can be naturally leveraged in attacking new black-box models by estimating their gradient information through a few queries. Detailed training process of our meta attacker is described in Algorithm 1. ",
+        "bbox": [
+            173,
+            741,
+            825,
+            839
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.3 QUERY-EFFICIENT ATTACK VIA META ATTACKER ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            856,
+            555,
+            871
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "An effective adversarial attack relies on optimizing the loss function equation 1 w.r.t. the input image to find the adversarial example of the target model $\\mathcal { M } _ { t a r }$ . Differently, our proposed method applies the meta attacker $\\mathcal { A }$ to predicting the gradient map of a test image directly. ",
+        "bbox": [
+            176,
+            881,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Input: Test image $\\scriptstyle { \\mathbf { { \\mathit { x } } } } _ { 0 }$ with label $t$ , meta attacker $\\scriptstyle { \\mathcal { A } } _ { \\theta }$ , target model $\\mathcal { M } _ { t a r }$ , iteration interval $m$ ,   \nselected top- $q$ coordinates;   \n1: for $t = 0 , 1 , 2 , \\ldots$ do   \n2: if $( t + 1 )$ mod $m = 0$ then   \n3: Perform zeroth-order gradient estimation on top $q$ coordinates, denoted as $I _ { t }$ and obtain $\\mathbf { \\nabla } _ { \\mathbf { \\boldsymbol { g } } _ { t } }$ ;   \n4: Fine-tune meta attacker $\\mathcal { A }$ with $( \\pmb { x } _ { t } , \\pmb { g } _ { t } )$ on $I _ { t }$ by loss $L = \\left\\| [ A _ { \\theta } ( \\pmb { x } _ { t } ) ] _ { I _ { t } } - [ \\pmb { g } _ { t } ] _ { I _ { t } } \\right\\| _ { 2 } ^ { 2 }$ ;   \n5: else   \n6: Generate the gradient map $\\mathbf { \\nabla } _ { \\mathbf { \\boldsymbol { g } } _ { t } }$ directly from meta attacker $\\mathcal { A }$ with $\\mathbf { \\Delta } _ { \\mathbf { \\mathcal { X } } _ { t } }$ , select coordinates $I _ { t }$ ;   \n7: end if   \n8: Update $[ { \\pmb x } ^ { \\prime } ] _ { I _ { t } } = [ { \\pmb x } _ { t } ] _ { I _ { t } } + \\beta [ { \\pmb g } _ { t } ] _ { I _ { t } }$ ;   \n9: if $\\mathcal { M } _ { t a r } ( \\pmb { x } ^ { \\prime } ) \\neq t$ then   \n10: $\\pmb { x } _ { a d v } = \\pmb { x } ^ { \\prime }$ ;   \n11: break;   \n12: else   \n13: $\\pmb { x } _ { t + 1 } = \\pmb { x } ^ { \\prime } ;$ ;   \n14: end if   \n15: end for   \nOutput: adversarial example $\\mathbf { { x } } _ { a d v }$ . ",
+        "bbox": [
+            176,
+            119,
+            826,
+            376
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We use the obtained meta attacker model $\\mathcal { A }$ to predict useful gradient map for attacking, which should be fine tuned to adapt to the new gradient distribution under our new target model. Particularly, instead of finetuning once, for each given image $_ { \\textbf { \\em x } }$ , we update $\\mathcal { A }$ by leveraging query information with the following periodic scheme. Suppose the given image is perturbed to $\\pmb { x } _ { t } \\in \\mathbb { R } ^ { p }$ at iteration $t$ . If $( t + 1 )$ mod $m = 0$ , our method performs zeroth-order gradient estimation to obtain gradient map $\\mathbf { \\sigma } _ { \\mathbf { \\sigma } _ { \\mathbf { \\sigma } _ { \\mathbf { \\lambda } } } } \\mathbf { \\sigma } _ { \\mathbf { \\sigma } _ { \\mathbf { \\lambda } } } \\mathbf { \\sigma } _ { \\mathbf { \\lambda } _ { \\mathbf { \\lambda } } } \\mathbf { \\sigma } _ { \\mathbf { \\lambda } _ { \\mathbf { \\lambda } } } \\mathbf { \\sigma } _ { \\mathbf { \\lambda } _ { \\mathbf { \\lambda } } } \\mathbf { \\sigma } _ { \\mathbf { \\lambda } _ { \\mathbf { \\lambda } } } \\mathbf { \\sigma } _ { \\mathbf { \\lambda } _ { \\mathbf { \\lambda } } } \\mathbf { \\sigma } _ { \\mathbf { \\lambda } _ { \\lambda } }$ for fine-tuning. As each pixel value for estimated gradient map consumes two queries, for further saving queries, we just select $q$ of the $p$ coordinates to estimate, $q \\ll p$ , instead of the full gradient map through all $p$ coordinates. The indexes of chosen coordinates are determined by the gradient map $\\mathbf { \\delta } _ { g _ { t - 1 } }$ obtained in iteration $t - 1$ . We sort the coordinate indexes by the value of $\\mathbf { \\delta } _ { g _ { t - 1 } }$ and select top- $q$ indexes. The set of these indexes are denoted as $I _ { t }$ . We feed image $\\mathbf { \\Delta } _ { \\mathbf { \\mathcal { X } } _ { t } }$ in iteration $t$ into meta attacker $\\mathcal { A }$ and compute the MSE loss on indexes $I _ { t }$ , i.e. $L = \\left\\| [ \\mathcal { A } _ { \\pmb \\theta } ( \\pmb x _ { t } ) ] _ { I _ { t } } - [ \\pmb g _ { t } ] _ { I _ { t } } \\right\\| _ { 2 } ^ { 2 }$ . Then we perform gradient descent for the MSE loss with a few steps to update the parameters $\\pmb \\theta$ of meta attacker $\\mathcal { A }$ . For the rest iterations, we just use the periodically updated attacker $\\scriptstyle A _ { \\theta }$ to directly generate the gradient $\\pmb { g } _ { t } = \\mathcal { A } _ { \\pmb { \\theta } } ( \\pmb { x } _ { t } )$ . When we have the estimated gradient map $\\mathbf { \\nabla } _ { \\mathbf { \\boldsymbol { g } } _ { t } }$ in iteration $t$ , we update to get the adversarial sample $ { \\boldsymbol { { x } } } _ { t } ^ { \\prime }$ by $[ { \\pmb x } _ { t } ^ { \\prime } ] _ { I _ { t } } = [ { \\pmb x } _ { t } ] _ { I _ { t } } + \\beta [ { \\pmb g } _ { t } ] _ { I _ { t } } ^ { - }$ where $\\beta$ is a hyperparameter to be tuned. The details are summarized in Algorithm 2. ",
+        "bbox": [
+            173,
+            414,
+            825,
+            637
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In our method, the following operations contribute to reducing the query number needed by the attacker. First, though we just use $q$ coordinates to fine-tune our meta attacker $\\mathcal { A }$ every $m$ iterations, the meta attacker $\\mathcal { A }$ is trained to ensure that it can abstract the gradient distribution of different $\\mathbf { \\Delta } _ { \\mathbf { \\mathcal { X } } _ { t } }$ and learn to predict the gradient from a few samples with simple fine-tuning. Secondly, the most query-consuming part lies in zeroth-order gradient estimation, due to its coordinate-wise nature. In our algorithm, we only do this every $m$ iterations. When we use the finetuned meta attacker $\\mathcal { A }$ directly, no query is consumed in gradient estimation in these iterations. Intuitively, larger $m$ implies less gradient estimation computation and fewer queries. Besides, just as mentioned above, even in zeroth-order gradient estimation, only top- $q$ coordinates are required. Normally, $q$ is much smaller than dimension $p$ of the input. ",
+        "bbox": [
+            173,
+            645,
+            825,
+            784
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            815,
+            326,
+            832
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We compare our meta attacker with state-of-the-art black-box attack methods including Zoo (Chen et al., 2017), Decision-Boundary (Brendel et al., 2018), AutoZoom (Tu et al., 2019), Optattack (Cheng et al., 2019), FW-black (Chen et al., 2018) and Bandits (Ilyas et al., 2018b) to evaluate its query efficiency. We also study its generalizability and transferability through a Meta transfer attacker, as detailed in the following sections. ",
+        "bbox": [
+            174,
+            854,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 SETTINGS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            284,
+            117
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Datasets and Target Models We evaluate the attack performance on MNIST (LeCun, 1998) for handwritten digit recognition, CIFAR10 (Krizhevsky & Hinton, 2009) and tiny-Imagenet (Russakovsky et al., 2015) for object classification. The architecture details of meta attack models on MNIST, CIFAR10 and tiny-Imagenet are given in Table 6. For MNIST, we train a separate meta attacker model since the images have different channel numbers from other natural image datasets. For CIFAR10 and tiny-Imagenet, we use a common meta attacker model. On CIFAR-10, we choose ResNet18 (He et al., 2016) as the target model $\\mathcal { M } _ { t a r }$ and use VGG13, VGG16 (Simonyan & Zisserman, 2014) and GoogleNet (Szegedy et al., 2015) for training our meta attacker. On tiny-Imagenet, we choose VGG19 and ResNet34 as the target model separately, and use VGG13, VGG16 and ResNet18 for training the meta attacker together. ",
+        "bbox": [
+            173,
+            130,
+            825,
+            268
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Attack Protocols For a target black-box model $\\mathcal { M } _ { t a r }$ , obtaining a pair of (input-output) is considered as one query. We use the mis-classification rate as attack success rate; we randomly select 1000 images from eacwe use the mean $L _ { 2 }$ ataset as test images. To evaluadistance across all the samples $\\begin{array} { r } { n o i s e ( \\mathcal { M } _ { t a r } ) = \\frac { 1 } { n } \\sum _ { i = 1 } ^ { n } \\| \\pmb { x } _ { i , \\mathcal { A } , \\mathcal { M } _ { t a r } } ^ { a d v } - \\pmb { x } _ { i } \\| _ { 2 } } \\end{array}$ where $\\pmb { x } _ { i , \\mathcal { A } , \\mathcal { M } _ { t a r } } ^ { a d v }$ denotes the adversarial version for the authentic sample $\\mathbf { \\Delta } _ { \\mathbf { \\mathcal { X } } _ { i } }$ . ",
+        "bbox": [
+            174,
+            276,
+            825,
+            351
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Meta-training Details For all the experiments, we use the same architecture for the meta attacker $\\mathcal { A }$ as shown in Table 6. We use Reptile (Nichol et al., 2018) with 0.01 learning rate to train meta attackers. We use 10000 randomly selected images from the training set to train the meta-attackers in three datasets. The proportion of the selected images to the whole training set are $16 \\%$ , $20 \\%$ , and $10 \\%$ respectively. Fine-tuning parameters are set as $m = 5$ for MNIST and CIFAR10, and $m = 3$ for tiny-Imagenet. Top $q = 1 2 8$ coordinates are selected as part coordinates for attacker fine-tuning and model attacking on MNIST; and $q = 5 0 0$ on CIFAR10 and tiny-Imagenet. ",
+        "bbox": [
+            174,
+            366,
+            825,
+            463
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 COMPARISON WITH BASELINES",
+        "text_level": 1,
+        "bbox": [
+            176,
+            479,
+            433,
+            493
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We compare our meta attacker with baselines for both the untargeted and targeted black-box attack on the three datasets. The results are reported in detail as below. ",
+        "bbox": [
+            173,
+            506,
+            823,
+            534
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Untargeted Attack Untargeted attack aims to generate adversarial examples that would be misclassified by the attacked model into any category different from the ground truth one. The overall results are shown in Table 1, in which, Meta transfer denotes that meta attacker trained on one dataset is used to attack target models on another dataset . Our method is competitive with baselines in terms of adversarial perturbation and success rate, but our query number is reduced. ",
+        "bbox": [
+            174,
+            541,
+            823,
+            611
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We also compare the results of our method with Zoo (Chen et al., 2017) and AutoZoom (Tu et al., 2019) from a query-efficiency perspective. We use these models to conduct untargeted attack on CIFAR10 and tiny-Imagenet by limiting a maximum number of queries for each adversarial example and compare their success rate. The results are shown in Fig. 1. We notice that for different query thresholds, the success rate of our method is always higher than Zoo and AutoZoom. This is possibly because the testing samples have different $L _ { 2 }$ distances to the decision boundary. Higher success rate of our method indicates our meta attacker can predict correct gradient even when the query information is limited. These results give strong evidence on effectiveness of our proposed method for enhancing query efficiency. ",
+        "bbox": [
+            173,
+            618,
+            825,
+            744
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/04b74de44fc0440b260086d66e284eaba048850f85d47a87b3a7143351aaf388.jpg",
+        "image_caption": [
+            "Figure 1: Comparison with limited queries. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            756,
+            477,
+            852
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/aedf9e9c22c2a6993a232496528dcd7d2d8e6fb11b4ed3eaa64b5fd46d3649bb.jpg",
+        "image_caption": [
+            "Figure 2: Top- $q$ and $\\beta$ selection. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            485,
+            757,
+            825,
+            851
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Targeted Attack Targeted attack aims to generate adversarial noise such that the perturbed sample would be mis-classified into any pre-specified category. It is a more strict setting than the untargeted one. For fair comparison, we define the target label for each sample —a sample with label $\\ell$ gets the target label $( \\ell + 1 )$ mod #classes. We deploy our meta attacker the same as above. The results on MNIST, CIFAR10 and tiny-ImageNet are shown in Table 2. Similar to results of untargeted attack, we achieve comparable noise and success rate to baselines but with reduced query numbers. ",
+        "bbox": [
+            173,
+            895,
+            826,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/9c9bad41fb2cb05e44582a70fe698824cdc9a37edc9481bd1180d567803cb1c4.jpg",
+        "table_caption": [
+            "Table 1: MNIST, CIFAR10 and tiny-ImageNet untargeted attack comparison: Meta attacker attains comparable success rate and $L _ { 2 }$ distortion as baselines, and significantly reduces query numbers. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Dataset /Target model</td><td rowspan=1 colspan=2>Method                                Success Rate  Avg. L2 Avg. Queries</td></tr><tr><td rowspan=6 colspan=1>MNIST/Net4</td><td rowspan=6 colspan=1>Zoo (Chen et al.,2017)Decision Boundary (Brendel et al.,2018)Opt-attack (Cheng et al.,2019)AutoZoom (Tu et al.,2019),Bandits (Ilyas et al.,2018b)Meta attack (ours)</td><td rowspan=1 colspan=1>1.00       1.61      21,760</td></tr><tr><td rowspan=1 colspan=1>1.00       1.85      13.630</td></tr><tr><td rowspan=1 colspan=1>1.00       1.85      12.925</td></tr><tr><td rowspan=1 colspan=1>1.00       1.86      2.412</td></tr><tr><td rowspan=1 colspan=1>0.73       1.99       3,771</td></tr><tr><td rowspan=1 colspan=1>1.00       1.77       749</td></tr><tr><td rowspan=8 colspan=1>CIFAR10/Resnet18</td><td rowspan=8 colspan=1>Zoo (Chen et al., 2017)Decision Boundary (Brendel et al.,2018)Opt-attack (Cheng et al.,2019)AutoZoom (Tu et al.,2019)Bandits (Ilyas et al.,2018b)FW-black (Chen et al.,2018)Meta transfer (ours)Meta attack (ours)</td><td rowspan=1 colspan=1>1.00       0.30       8,192</td></tr><tr><td rowspan=1 colspan=1>1.00       0.30      17,010</td></tr><tr><td rowspan=1 colspan=1>1.00       0.33      20,407</td></tr><tr><td rowspan=1 colspan=1>1.00       0.28      3,112</td></tr><tr><td rowspan=1 colspan=1>0.91       0.33       4,491</td></tr><tr><td rowspan=1 colspan=1>1.00       0.43       5,021</td></tr><tr><td rowspan=1 colspan=1>0.92       0.35       1,765</td></tr><tr><td rowspan=1 colspan=1>0.94       0.34      1,583</td></tr><tr><td rowspan=6 colspan=1>tiny-ImageNet/VGG19</td><td rowspan=6 colspan=1>Zoo (Chen et al.,2017)Decision Boundary (Brendel etal.,2018)Opt-attack (Cheng et al.,2019)AutoZoom (Tu et al.,2019)Bandits (Ilyas et al.,2018b)Meta transfer (ours)Meta attack (ours)</td><td rowspan=1 colspan=1>1.00       0.52      27,827</td></tr><tr><td rowspan=1 colspan=1>1.00       0.52      49,942</td></tr><tr><td rowspan=1 colspan=1>1.00       0.53      71,016</td></tr><tr><td rowspan=1 colspan=1>1.00       0.54      8.904</td></tr><tr><td rowspan=1 colspan=1>0.78       0.54      9,159</td></tr><tr><td rowspan=1 colspan=1>0.99       0.56      3,6240.99       0.53      3,278</td></tr><tr><td rowspan=3 colspan=1>tiny-ImageNet/Resnet34</td><td rowspan=3 colspan=1>Zoo (Chen et al., 2017)Decision Boundary (Brendel et al., 2018)AutoZoom (Tu et al.,2019)Opt-attack (Cheng et al.,2019)Bandits (Ilyas et al.,2018b)Meta transfer (ours)Meta attack (ours)</td><td rowspan=1 colspan=1>1.00       0.47      25,3441.00       0.48      49,9821.00       0.45      9,7701.00       0.52      60,437</td></tr><tr><td rowspan=1 colspan=1>0.73       0.49      9,978</td></tr><tr><td rowspan=1 colspan=1>0.99       0.56       3,5400.99       0.53      3,268</td></tr></table>",
+        "bbox": [
+            184,
+            140,
+            815,
+            497
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            523,
+            825,
+            580
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.3 MODEL ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            597,
+            343,
+            611
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Meta Training We first test the benefits of meta training by comparing performance of a metatrained attacker with a Gaussian randomly initialized attacker without meta training on the three datasets. Fig. 3 shows their success rate, $L _ { 2 }$ distortion and query count results for initial success. The meta pre-trained attacker achieves averagely $7 \\%$ higher success rate with $1 6 \\%$ lower $L _ { 2 }$ distortion and $3 \\bar { 0 } \\%$ less queries, compared with the randomly initialized one. This justifies the contributions of meta training to enhancing query efficiency and also attack performance. ",
+        "bbox": [
+            174,
+            622,
+            825,
+            707
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Guaranteed by fine-tuning, the randomly initialized attacker succeeds over many testing samples. The fine-tuning works like an inner training in meta training. With sufficient fine-tuning iterations, the randomly initialized attacker functions like a well-trained meta attacker. This explains the effectiveness of the randomly initialized meta attacker on many testing samples compromised by more queries. However, it could not predict gradient as accurate as the well-trained meta attacker during earlier iterations. Such inaccuracy leads to larger $L _ { 2 }$ distortion at the beginning. On the contrary, the meta training process enables the well-trained meta attacker to fast-adapt to current testing samples. These results highlight the significant advantages of our meta model towards to black-box attack. The process of meta training makes it familiar with gradient patterns of various models. ",
+        "bbox": [
+            174,
+            713,
+            825,
+            838
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Generalizability Here we show that our meta attacker trained on one dataset can be transferred to other datasets. We conduct this experiment between CIFAR10 and tiny-Imagenet, denoted as Meta transfer in Table 1 and 2. We first apply the meta attacker trained on CIFAR10 to attack VGG19, ResNet34 on tiny-Imagenet respectively, which are different from models used for training meta attacker. Note the meta attacker tested on CIFAR10 has no privileged prior and is not familiar with neither tiny-Imagenet dataset nor the corresponding classification models. Similarly, we also use the meta attacker trained on tiny-Imagenet to attack the target ResNet18 model on CIFAR10. The results show the good generalizability and robustness of our proposed meta attacker. ",
+        "bbox": [
+            174,
+            854,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/73166deb8571945848a86aa04ff606cd1117768c0254e7e6804a303b7abdc88a.jpg",
+        "table_caption": [
+            "Table 2: MNIST, CIFAR10 and tiny-ImageNet targeted attack comparison: Meta attack significantly outperforms other black-box methods in query numbers. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset/Target model</td><td>Method</td><td>Success Rate</td><td>Avg. L2</td><td>Avg. Queries</td></tr><tr><td rowspan=\"4\">MNIST/Net4</td><td>Zoo (Chen et al.,2017)</td><td>1.00</td><td>2.63</td><td>23,552</td></tr><tr><td>Decision Boundary (Brendel et al.,2018)</td><td>0.64</td><td>2.71</td><td>19,951</td></tr><tr><td>AutoZoom (Tu et al.,2019)</td><td>0.95</td><td>2.52</td><td>6,174</td></tr><tr><td>Opt-attack (Cheng et al.,2019) Meta attack (ours)</td><td>1.00 1.00</td><td>2.33 2.66</td><td>99,661</td></tr><tr><td rowspan=\"6\">CIFAR10/Resnet18</td><td>Zoo (Chen et al.,2017)</td><td>1.00</td><td>0.55</td><td>1,299 66,400</td></tr><tr><td>Decision Boundary (Brendel et al.,2018)</td><td>0.58</td><td>0.53</td><td>16,250</td></tr><tr><td>AutoZoom (Tu et al., 2019)</td><td>1.00</td><td>0.51</td><td>9,082</td></tr><tr><td>Opt-attack (Cheng et al.,2019)</td><td>1.00</td><td>0.50</td><td>121,810</td></tr><tr><td>FW-black (Chen et al.,2018)</td><td>0.90</td><td>0.73</td><td>6.987</td></tr><tr><td>Meta transfer (ours) Meta attack (ours)</td><td>0.92</td><td>0.74</td><td>3,899</td></tr><tr><td rowspan=\"5\">tiny-ImageNet/VGG19</td><td>Zoo (Chen et al., 2017)</td><td>0.93 0.74</td><td>0.77</td><td>3,667</td></tr><tr><td>AutoZoom (Tu et al., 2019)</td><td>0.87</td><td>1.26</td><td>119,648</td></tr><tr><td>Opt-attack (Cheng et al.,2019)</td><td>0.66</td><td>1.45 1.14</td><td>53,778</td></tr><tr><td>Meta transfer (ours)</td><td></td><td></td><td>252.009</td></tr><tr><td>Meta attack (ours)</td><td>0.55 0.54</td><td>1.37 1.24</td><td>12,275 11,498</td></tr><tr><td rowspan=\"5\">tiny-ImageNet/Resnet34</td><td>Zoo (Chen et al., 2017)</td><td>0.60</td><td>1.03</td><td>88.966</td></tr><tr><td>AutoZoom (Tu et al., 2019)</td><td>0.95</td><td>1.15</td><td>52,174</td></tr><tr><td>Opt-attack (Cheng et al.,2019)</td><td>0.78</td><td>1.00</td><td>214,015</td></tr><tr><td>Meta transfer (ours)</td><td>0.69</td><td>1.40</td><td></td></tr><tr><td>Meta attack (ours)</td><td>0.54</td><td>1.21</td><td>13,435 12,897</td></tr></table>",
+        "bbox": [
+            184,
+            140,
+            815,
+            430
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/f6ae08a6a4802b46d90532b0d870dd511117f516cbbfadefd90e9b3b99b561fd.jpg",
+        "image_caption": [
+            "Figure 3: Comparison of randomly initialized and well-trained meta attackers. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            192,
+            441,
+            803,
+            587
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            650,
+            825,
+            691
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Parameters Selection We test the selection of top- $q$ and $\\beta$ on CIFAR10. We choose $q$ ranging from 350 to 600 and give the results with $\\beta$ ranging from 3e-3 to 5e-3, as shown in Fig. 2. When $q$ increases, query number, success rate and $L _ { 2 }$ will all increase. In order to balance the overall result, we choose $q$ to be 500. When $\\beta$ increases, success rate and $L _ { 2 }$ will increase and query number decreases. In order to balance success rate and query, we choose $\\beta$ to be 4e-3 in the experiment. ",
+        "bbox": [
+            174,
+            713,
+            825,
+            784
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            804,
+            318,
+            820
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We propose a meta-based black-box attack method that largely reduces demanded query numbers without compromising in attack success rate and distortion. We train a meta attacker to learn useful prior information about gradient and incorporate it into the optimization process to decrease the number of queries. Specifically, the meta attacker is finetuned to fit the gradient distribution of target model and each update is based on the output of finetuned meta attaker. Extensive experimental results confirm the superior query-efficiency of our method over baselines. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGEMENT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            357,
+            117
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "This research is partially supported by Programmatic grant no. A1687b0033 from the Singapore government’s Research, Innovation and Enterprise 2020 plan (Advanced Manufacturing and Engineering domain). ",
+        "bbox": [
+            174,
+            133,
+            825,
+            175
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Hu Zhang (No. 201706340188) is partially supported by the Chinese Scholarship Council. ",
+        "bbox": [
+            171,
+            183,
+            766,
+            198
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jiashi Feng was partially supported by NUS IDS R-263-000-C67-646, ECRA R-263-000-C87-133, MOE Tier-II R-263-000-D17-112 and AI.SG R-263-000-D97-490. ",
+        "bbox": [
+            171,
+            204,
+            823,
+            232
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            285,
+            117
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "W. Brendel, J. Rauber, and M. Bethge. Decision-based adversarial attacks: Reliable attacks against black-box machine learning models. In International Conference on Learning Representations, 2018. URL https://arxiv.org/abs/1712.04248. ",
+        "bbox": [
+            176,
+            126,
+            823,
+            170
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nicholas Carlini and David Wagner. Towards evaluating the robustness of neural networks. In 2017 IEEE Symposium on Security and Privacy (SP), pp. 39–57. IEEE, 2017. ",
+        "bbox": [
+            171,
+            179,
+            823,
+            208
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jinghui Chen, Jinfeng Yi, and Quanquan Gu. A frank-wolfe framework for efficient and effective adversarial attacks. arXiv preprint arXiv:1811.10828, 2018. ",
+        "bbox": [
+            173,
+            218,
+            820,
+            248
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Pin-Yu Chen, Huan Zhang, Yash Sharma, Jinfeng Yi, and Cho-Jui Hsieh. Zoo: Zeroth order optimization based black-box attacks to deep neural networks without training substitute models. In Proceedings of the 10th ACM Workshop on Artificial Intelligence and Security, pp. 15–26. ACM, 2017. ",
+        "bbox": [
+            173,
+            257,
+            826,
+            314
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Minhao Cheng, Thong Le, Pin-Yu Chen, Huan Zhang, JinFeng Yi, and Cho-Jui Hsieh. Queryefficient hard-label black-box attack: An optimization-based approach. In International Conference on Learning Representations, 2019. URL https://openreview.net/forum?id= rJlk6iRqKX. ",
+        "bbox": [
+            173,
+            325,
+            825,
+            382
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Riley Edmunds, Noah Golmant, Vinay Ramasesh, Phillip Kuznetsov, Piyush Patil, and Raul Puri. Transferability of adversarial attacks in model-agnostic meta-learning. Deep Learning and Security Workshop (DLSW) in Singapore, 2017. ",
+        "bbox": [
+            176,
+            392,
+            821,
+            435
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Chelsea Finn, Pieter Abbeel, and Sergey Levine. Model-agnostic meta-learning for fast adaptation of deep networks. In Proceedings of the 34th International Conference on Machine LearningVolume 70, pp. 1126–1135. JMLR. org, 2017. ",
+        "bbox": [
+            173,
+            444,
+            825,
+            489
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Saeed Ghadimi and Guanghui Lan. Stochastic first-and zeroth-order methods for nonconvex stochastic programming. SIAM Journal on Optimization, 23(4):2341–2368, 2013. ",
+        "bbox": [
+            173,
+            498,
+            823,
+            529
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ian Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. In International Conference on Learning Representations, 2015. URL http:// arxiv.org/abs/1412.6572. ",
+        "bbox": [
+            174,
+            537,
+            823,
+            580
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Elad Hazan et al. Introduction to online convex optimization. Foundations and Trends $\\textsuperscript { \\textregistered }$ in Optimization, 2(3-4):157–325, 2016. ",
+        "bbox": [
+            171,
+            590,
+            823,
+            621
+        ],
+        "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,
+            631,
+            821,
+            674
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Andrew Ilyas, Logan Engstrom, Anish Athalye, and Jessy Lin. Black-box adversarial attacks with limited queries and information. In Proceedings of the 35th International Conference on Machine Learning, ICML 2018, July 2018a. URL https://arxiv.org/abs/1804.08598. ",
+        "bbox": [
+            173,
+            684,
+            826,
+            728
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Andrew Ilyas, Logan Engstrom, and Aleksander Madry. Prior convictions: Black-box adversarial attacks with bandits and priors. arXiv preprint arXiv:1807.07978, 2018b. ",
+        "bbox": [
+            173,
+            737,
+            823,
+            767
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Rie Johnson and Tong Zhang. Accelerating stochastic gradient descent using predictive variance reduction. In Advances in neural information processing systems, pp. 315–323, 2013. ",
+        "bbox": [
+            171,
+            776,
+            823,
+            806
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. Technical report, Citeseer, 2009. ",
+        "bbox": [
+            169,
+            815,
+            823,
+            845
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun. The mnist database of handwritten digits. http://yann. lecun. com/exdb/mnist/, 1998. ",
+        "bbox": [
+            171,
+            856,
+            820,
+            871
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Aleksander Madry, Aleksandar Makelov, Ludwig Schmidt, Dimitris Tsipras, and Adrian Vladu. Towards deep learning models resistant to adversarial attacks. In International Conference on Learning Representations, 2018. URL https://openreview.net/forum?id $\\underline { { \\underline { { \\mathbf { \\Pi } } } } }$ rJzIBfZAb. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Seyed-Mohsen Moosavi-Dezfooli, Alhussein Fawzi, and Pascal Frossard. Deepfool: a simple and accurate method to fool deep neural networks. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 2574–2582, 2016. ",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nina Narodytska and Shiva Kasiviswanathan. Simple black-box adversarial attacks on deep neural networks. In 2017 IEEE Conference on Computer Vision and Pattern Recognition Workshops (CVPRW), pp. 1310–1318. IEEE, 2017. ",
+        "bbox": [
+            176,
+            155,
+            821,
+            198
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yurii Nesterov. Introductory lectures on convex optimization: A basic course, volume 87. Springer Science & Business Media, 2013. ",
+        "bbox": [
+            171,
+            207,
+            823,
+            236
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yurii Nesterov and Vladimir Spokoiny. Random gradient-free minimization of convex functions. Foundations of Computational Mathematics, 17(2):527–566, 2017. ",
+        "bbox": [
+            173,
+            244,
+            821,
+            273
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alex Nichol, Joshua Achiam, and John Schulman. On first-order meta-learning algorithms. arXiv preprint arXiv:1803.02999, 2018. ",
+        "bbox": [
+            173,
+            281,
+            821,
+            310
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nicolas Papernot, Patrick McDaniel, Ian Goodfellow, Somesh Jha, Z Berkay Celik, and Ananthram Swami. Practical black-box attacks against machine learning. In Proceedings of the 2017 ACM on Asia conference on computer and communications security, pp. 506–519. ACM, 2017. ",
+        "bbox": [
+            174,
+            319,
+            825,
+            363
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael Bernstein, Alexander C. Berg, and Li Fei-Fei. ImageNet Large Scale Visual Recognition Challenge. International Journal of Computer Vision (IJCV), 115(3):211–252, 2015. doi: 10.1007/s11263-015-0816-y. ",
+        "bbox": [
+            173,
+            371,
+            825,
+            428
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. arXiv preprint arXiv:1409.1556, 2014. ",
+        "bbox": [
+            174,
+            436,
+            823,
+            465
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. In International Conference on Learning Representations, 2014. URL http://arxiv.org/abs/1312.6199. ",
+        "bbox": [
+            174,
+            473,
+            825,
+            517
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Christian Szegedy, Wei Liu, Yangqing Jia, Pierre Sermanet, Scott Reed, Dragomir Anguelov, Dumitru Erhan, Vincent Vanhoucke, and Andrew Rabinovich. Going deeper with convolutions. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 1–9, 2015. ",
+        "bbox": [
+            174,
+            526,
+            825,
+            569
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Chun-Chen Tu, Paishun Ting, Pin-Yu Chen, Sijia Liu, Huan Zhang, Jinfeng Yi, Cho-Jui Hsieh, and Shin-Ming Cheng. Autozoom: Autoencoder-based zeroth order optimization method for attacking black-box neural networks. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 33, pp. 742–749, 2019. ",
+        "bbox": [
+            174,
+            577,
+            825,
+            635
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Daniel Zgner and Stephan Gnnemann. Adversarial attacks on graph neural networks via meta learning. In International Conference on Learning Representations, 2019. URL https: //openreview.net/forum?id $=$ Bylnx209YX. ",
+        "bbox": [
+            174,
+            643,
+            825,
+            686
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "6 APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            294,
+            118
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "6.1 MORE EXPERIMENTAL RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            132,
+            434,
+            147
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "6.1.1 COSINE SIMILARITY BETWEEN ESTIMATED GRADIENTS AND WHITE-BOX GRADIENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            160,
+            816,
+            172
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "To demonstrate the ability of estimating gradient of our meta attacker, we have conducted experiments with the Resnet-34 model on the tiny-Imagenet dataset to compare the cosine similarity between the estimated gradients from our proposed meta-attacker and the accurate white-box gradients. We also compare the cosine similarity between ZOO (Chen et al., 2017) estimated gradients and the white-box gradients as reference. The results of cosine similarity and required number of queries are shown in Table 3. We can observe that our meta-attacker does fast-adapt to the target model and generate accurate gradients. Not only it estimates gradients with positive cosine similarity to the true gradients, but it also performs closer to the ZOO estimated results with the same small standard deviation. ",
+        "bbox": [
+            173,
+            183,
+            825,
+            308
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/ee459412095f0e0d39d2d12d4498649fa8c9c2091517154b32d27888d5665a07.jpg",
+        "table_caption": [
+            "Table 3: Cosine similarity between estimated gradients and white-box gradients. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"2\">Ours meta-attacker</td><td colspan=\"2\">ZOO (Chen et al.,2017)</td></tr><tr><td>Task Type</td><td>Similarity</td><td>Queries</td><td>Similarity</td><td>Queries</td></tr><tr><td>Untargeted</td><td>0.356± 0.074</td><td>3,268</td><td>0.395 ± 0.079</td><td>25,344</td></tr><tr><td>Targeted</td><td>0.225 ± 0.090</td><td>12,897</td><td>0.363 ± 0.069</td><td>88,966</td></tr></table>",
+        "bbox": [
+            285,
+            343,
+            705,
+            406
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "6.1.2 VANILLA TRAINING AUTOENCODER AND META-ATTACKER LEARNING FROMESTIMATED GRADIENTS",
+        "text_level": 1,
+        "bbox": [
+            176,
+            429,
+            753,
+            457
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We have conducted experiments in section 4.3 to demonstrate the benefits of meta training. However, we only compare the performance of a meta-trained attacker with a Gaussian randomly initialized attacker. We conduct two more experiments on meta training here to further investigate the benefits of meta training. First we compare our meta-trained attacker with a vanilla autoencoder that learns to map images to gradients of one white-box model. The vanilla autoencoder has the same architecture with our meta-attacker, but it is trained in one white-box model. Then, we train a new meta-attacker in four black-box models, i.e., the gradients used for training are estimated via ZOO (Chen et al., 2017). The experiment results are presented in Table 4, 5 . ",
+        "bbox": [
+            173,
+            465,
+            826,
+            578
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/135c63dc82c86fc9bceef0ce8b58c81046701d283ad4367519521cbcd2f6a370.jpg",
+        "table_caption": [
+            "Table 4: MNIST untargeted attack comparison. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>Success Rate</td><td>Avg.L2</td><td>Avg. Queries</td></tr><tr><td>Ours(reported)</td><td>1.000</td><td>1.78</td><td>1,103</td></tr><tr><td>ZOO estimated</td><td>1.000</td><td>1.77</td><td>1,130</td></tr><tr><td>Vanilla Autoencoder</td><td>1.000</td><td>1.93</td><td>1,899</td></tr><tr><td>Initialised attacker</td><td>0.912</td><td>1.96</td><td>1,721</td></tr></table>",
+        "bbox": [
+            302,
+            617,
+            691,
+            685
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/333a46e1ae5fc4c011f82a487d9239d63e9c1217b503c7a27b8b969eb2fe00ca.jpg",
+        "table_caption": [
+            "Table 5: MNIST targeted attack comparison. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>Success Rate</td><td>Avg.L2</td><td>Avg. Queries</td></tr><tr><td>Ours(reported)</td><td>1.000</td><td>2.66</td><td>1,971</td></tr><tr><td>ZOO estimated</td><td>1.000</td><td>2.42</td><td>2,105</td></tr><tr><td>Vanilla Autoencoder</td><td>1.000</td><td>2.80</td><td>2,905</td></tr><tr><td>Initialised attacker</td><td>0.895</td><td>2.81</td><td>3,040</td></tr></table>",
+        "bbox": [
+            297,
+            729,
+            696,
+            800
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "The two experiments are conducted on 1000 randomly selected images from the MNIST testing set. As for the four approach settings: ”Ours (reported)” is the results we report in our paper; ”ZOO estimated” is the meta-attacker trained from ZOO estimated gradients; ”Vanilla Autoencoder” is the autoencoder maps image to gradient trained in one different MNIST classification model; ”Initialised attacker” is the meta-attacker with randomly initialized weights. We can see the ”ZOO estimated” model performs closer to our reported meta-attacker. However, the ”Vanilla Autoencoder” performs much worse (with larger L2-norm and more queries), which performs similarly to randomly initialized meta-attacker. The two experiments verify the effectiveness of our first meta-training phase. ",
+        "bbox": [
+            173,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "6.2 STRUCTURE OF META ATTACKER ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            446,
+            118
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/ebcb941d22a9fc2bb38c1feec80d6bdede3f9d539166bcba51bded86364eee35.jpg",
+        "table_caption": [
+            "Table 6: Structure of meta attacker. Conv: convolutional layer, Convt: de-convolutional layer. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Meta attacker (MNIST)</td><td>Meta attacker (CIFAR10, tiny-ImageNet)</td></tr><tr><td>Conv(16,3,3,1)+ ReLu +bn</td><td>Conv(32,3,3,1)+ ReLu +bn</td></tr><tr><td>Conv(32,4,4,2) +] ReLu +bn</td><td>Conv(64,4,4,2)+ ReLu + bn</td></tr><tr><td>Conv(64,4,4,2)+ ReLu +bn</td><td>Conv(128,4,4,2)+ReLu +bn</td></tr><tr><td>Conv(64,4,4,2)+ ReLu + bn</td><td>Conv(256,4,4,2)+ReLu +bn</td></tr><tr><td>Convt(64,4,4,2)+ ReLu +bn</td><td>Convt(256,4,4,2)+ReLu+ bn</td></tr><tr><td>Convt(32,4,4,2)+ ReLu + bn</td><td>Convt(128,4,4,2)+ReLu+bn</td></tr><tr><td>Convt(16,4,4,2)+ ReLu +bn</td><td>Convt(64,4,4,2)+ ReLu +bn</td></tr><tr><td>Convt(8,3,3,1)+ ReLu +bn</td><td>Convt(32,3,3,1)+ ReLu +bn</td></tr></table>",
+        "bbox": [
+            245,
+            160,
+            750,
+            287
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "6.3 STRUCTURE OF TARGET MODEL USED IN MNIST ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            314,
+            562,
+            330
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/884912d113a90e1675d58554037c1f12b90a0557bbca5923b1fae7d504ef6f1b.jpg",
+        "table_caption": [
+            "Table 7: Neural network architecture used on MNIST. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>MNIST Model (Conv: convolutional layer,FC: fully connected layer.)</td></tr><tr><td>Conv(128,3,3)+ Tanh</td></tr><tr><td>MaxPool(2,2)</td></tr><tr><td>Conv(64,3,3)+ Tanh</td></tr><tr><td>MaxPool(2,2)</td></tr><tr><td>FC(128) +Relu</td></tr><tr><td>FC(10)+ Softmax</td></tr></table>",
+        "bbox": [
+            281,
+            371,
+            715,
+            472
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "6.4 ACCURACY OF TARGET MODELS ON ORIGINAL DATASETS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            497,
+            620,
+            513
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/307d1d87685dda40da88f71083969d0ceba9c99ec47efb80a7649db5d2d61eef.jpg",
+        "table_caption": [
+            "Table 8: Accuracy of each target model on each dataset ",
+            "6.5 ADVERSARIAL EXAMPLES GENERATED BY OUR METHOD "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td>MNIST</td><td>CIFAR10</td><td colspan=\"2\">tiny-ImageNet</td></tr><tr><td>Model</td><td>MNIST Model</td><td>Resnet18</td><td>VGG19</td><td>Resnet34</td></tr><tr><td>Accuracy</td><td>0.9911</td><td>0.9501</td><td>0.6481</td><td>0.6972</td></tr></table>",
+        "bbox": [
+            339,
+            555,
+            658,
+            606
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/11b365cdb9479d380ee88693afffb0cc81c3e974ce8f7b69bbdb265161d5613a.jpg",
+        "image_caption": [
+            "Figure 4: Adversarial examples generated by our method on MNIST. The groundtruth images are shown in the diagonal and the rest are adversarial examples that are misclassified to the targeted class shown on the top. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            269,
+            285,
+            725,
+            688
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/4a74d96d9db5a1218e195e43c1dfcd03d5e2a98ff41a7b170f981043ef824aff.jpg",
+        "image_caption": [
+            "Figure 5: Adversarial examples generated by our method on CIFAR10. The groundtruth images are shown in the diagonal and the rest are adversarial examples that are misclassified to the targeted class shown on the top. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            236,
+            258,
+            759,
+            713
+        ],
+        "page_idx": 14
+    }
+]

parse/train/rkKCdAdgx/rkKCdAdgx.md

@@ -0,0 +1,291 @@
+# COMPACT EMBEDDING OF BINARY-CODED INPUTS AND OUTPUTS USING BLOOM FILTERS
+
+Joan Serra & Alexandros Karatzoglou\`   
+Telefonica Research´   
+Pl. Ernest Lluch i Mart´ın, 5   
+Barcelona, 08019, Spain   
+firstname.lastname@telefonica.com
+
+# ABSTRACT
+
+The size of neural network models that deal with sparse inputs and outputs is often dominated by the dimensionality of those inputs and outputs. Large models with high-dimensional inputs and outputs are difficult to train due to the limited memory of graphical processing units, and difficult to deploy on mobile devices with limited hardware. To address these difficulties, we propose Bloom embeddings, a compression technique that can be applied to the input and output of neural network models dealing with sparse high-dimensional binary-coded instances. Bloom embeddings are computationally efficient, and do not seriously compromise the accuracy of the model up to 1/5 compression ratios. In some cases, they even improve over the original accuracy, with relative increases up to $12 \%$ . We evaluate Bloom embeddings on 7 data sets and compare it against 4 alternative methods, obtaining favorable results. We also discuss a number of further advantages of Bloom embeddings, such as ‘on-the-fly’ constant-time operation, zero or marginal space requirements, training time speedups, or the fact that they do not require any change to the core model architecture or training configuration.
+
+# 1 INTRODUCTION
+
+The size of neural network models that deal with sparse inputs and outputs is often dominated by the dimensionality of such inputs and outputs. This is the case, for instance, with recommender systems, where high-dimensional sparse vectors, typically in the order from tens of thousands to hundreds of millions, constitute both the input and the output of the model (e.g., Wu et al., 2016; Hidasi et al., 2016; Cheng et al., 2016; Strub et al., 2016). This results in large models that present a number of difficulties, both at training and prediction stages. Apart from training and prediction times, an obvious bottleneck of such models is space: their size (and even performance) is hampered by the physical memory of graphical processing units (GPUs), and they are difficult to deploy on mobile devices with limited hardware (cf. Han et al., 2016).
+
+One option to reduce the size of sparse inputs and outputs is to embed them into a lower-dimensional space. Embedding sparse high-dimensional inputs is commonplace (e.g., Bengio et al., 2000; Turian et al., 2010; Mikolov et al., 2013). However, embedding sparse high-dimensional outputs, or even inputs and outputs at the same time, is much less common (cf. Weston et al., 2002; Bengio et al., 2010; Akata et al., 2015). Importantly, typical embeddings still require the storage and processing of large matrices with the same dimensionality as the input/output (like the original neural network model would do). Thus, the gains in terms of space are limited. As mentioned, the size of such models is dominated by the input/output dimensionality, with input and output layers representing about $9 9 . 9 4 \%$ of the total amount of weights of the model1.
+
+In general, an ideal embedding procedure for sparse high-dimensional inputs/outputs should produce compact embeddings, of much lower dimensionality than the original input/output. In addition, it should consume little space, both in terms of storage and memory space. Smaller sizes imply less parameters, thus training the model on embedded vectors would also be faster than with the original instances. The embedding of the output should also lead to a formulation for which the appropriate loss should be clear. Embeddings should not compromise the accuracy of the model nor the required number of training epochs to obtain that accuracy. In addition, no changes to the original core architecture of the model should be required to achieve good performance (obviously, input/output dimensions must change). The embedding should also be fast; if not to be done directly ‘on-the-fly’, at least fast enough so that speed improvements made during training are not lost in the embedding operation. Last, but not least, output embeddings should be easily reversible, so that the output of the model could be mapped to the original items at prediction time.
+
+In this paper, we propose an unsupervised embedding technique that fulfills all the previous requirements. It can be applied to both input and output layers of neural network models that deal with binary (one-hot encoded) inputs and/or outputs. In addition, it produces lower-dimensionality binary embeddings that can be easily mapped to the original instances. Provided that the embedding dimension is not too low, the accuracy is not compromised. Furthermore, in some cases, we show that training with embedded vectors can even increase prediction accuracy. The embedding requires no changes to the core network structure nor to the model configuration, and works with a softmax output, the most common output activation for binary-coded instances. As it is unsupervised, the embedding does not require any preliminary training. Moreover, it is a constant-time operation that can be either performed on-the-fly, requiring no disk or memory space, or can be cached in memory, occupying orders of magnitude less space than a typical embedding matrix. Lower dimensionality of input/output vectors result in faster training, and the mapping from the embedded space to the original one does not add an overwhelming amount of time to the prediction stage. The proposed embedding is based on the idea of Bloom filters (Bloom, 1970), and therefore it inherits part of the theory developed around that idea (Blustein & El-Maazawi, 2002; Dillinger & Manolios, 2004; Mitzenmacher & Upfal, 2005; Bonomi et al., 2006).
+
+# 2 RELATED WORK
+
+A common approach to embed high-dimensional inputs is the hashing trick (Langford et al., 2007; Shi et al., 2009; Weinberger et al., 2009). However, the hashing trick approach does not deal with outputs, as it offers no explicit way to map back from the (dense) embedding space to the original space. A more elementary version of the hashing trick (Ganchev & Dredze, 2008) can be used at the outputs by considering it as a special case of the Bloom-based methodology proposed here. A framework providing both encoding and decoding strategies is the error-correcting output codes (ECOC) framework (Dietterich & Bakiri, 1995). Originally designed for single-class outputs, it can be also applied to class sets (Armano et al., 2012). The compressed sensing approach of Hsu et al. (2009) builds on top of ECOC to reduce multi-label regression to binary regression problems. Similarly, Cisse et al. (2013) use Bloom filters to reduce multi-label classification to binary classification ´ problems and improve the robustness of individual binary classifiers’ errors. Another example of a framework offering recovery capabilities is kernel dependency estimation (Weston et al., 2002).
+
+Data-dependent embeddings that require some form of learning also exist. A typical approach is to rely on variants of latent semantic analysis or singular value decomposition (SVD), exploiting similarities or correlations that may be present in the data. Again, the issue of mapping from the embedding space to the original space is left unresolved. Nonetheless, recently, Chollet (2016) has successfully applied a K-nearest neighbors (KNN) algorithm to perform such a mapping and to derive a ranking of the elements in the original space. An SVD decomposition of the pairwise mutual information matrix (PMI) is used to perform the embedding, and cosine similarity is used as loss function and to retrieve neighbors. Using the KNN trick offers the possibility to exploit different types of factorization of similarity-based matrices. Canonical correlation analysis is an example that considers both inputs and outputs at the same time (Hotelling, 1936). Other examples considering output embeddings are nuclear norm regularized learning (Amit et al., 2007), label embedding trees (Bengio et al., 2010), or the WSABIE algorithm (Weston et al., 2010). In the presence of side information, like text descriptions, element or class taxonomies, or manually-collected data, a range of approaches are applicable. Akata et al. (2015) provide a comprehensive list. In our study, we assume no side information is available and focus on input/output-based embeddings.
+
+From a more general perspective, reducing the space of (or compressing) neural network models is an active research topic, driven by the need to deploy such models in systems with limited hardware resources. A common approach is to reduce the size of already trained models by some quantization and/or pruning of the connections in dense layers (Courbariaux et al., 2015; Han et al., 2016; Kim et al., 2016). A less frequently used approach is to reduce the model size before training (Chen et al., 2015). These methods typically do not focus on input layers and, to the best of our knowledge, none of them deals with high-dimensional outputs. It is also worth noting that a number of techniques have been proposed to efficiently deal with high-dimensional outputs, specially in the natural language processing domain. The hierarchical softmax approach (Morin & Bengio, 2005) or the more recent adaptive softmax (Grave et al., 2016) are two examples of those. Yet, as mentioned, the focus of these works is on speed, not on space. The work of Vincent et al. (2015) focuses on both aspects of very large sparse outputs but, to the best of our knowledge, cannot be applied to traditional softmax outputs.
+
+# 3 BLOOM EMBEDDINGS
+
+# 3.1 BLOOM FILTERS
+
+Bloom filters (Bloom, 1970) are a compact probabilistic data structure that is used to represent sets of elements, and to efficiently check whether an element is a member of a set (Mitzenmacher & Upfal, 2005). Since the instances we deal with represent sets of one-hot encoded elements, Bloom filters are an interesting option to embed those in a compact space with good recovery (or checking) guarantees.
+
+In essence, Bloom filters project every element of a set to $k$ different positions of a binary array $\mathbf { u }$ of size $m$ . Projections are done using a set of $k$ independent hash functions $\mathsf { H } = \left\{ H _ { i } \right\} _ { i = 1 } ^ { k }$ , each of which with a range from 1 to $m$ , ideally distributing the projected elements uniformly at random (Mitzenmacher & Upfal, 2005). Proper independent hash functions can be derived using enhanced double hashing or triple hashing (Dillinger & Manolios, 2004). The number of hash functions $k$ is usually a constant, $k \ll m$ , proportional to the expected number of elements to be projected.
+
+To check if an element is in $\mathbf { u }$ , one feeds it to the $k$ hash functions $H$ to get $k$ array positions. If any of the bits at these positions is 0, then the element is definitely not in the set. Thus, element checks return no false negatives, meaning that the structure gives an answer with $100 \%$ recall (Mitzenmacher & Upfal, 2005). However, if all $k$ bits at the projected positions are 1, then either the element is in the set, or the bits have by chance been set to 1 during the insertion of other set elements. This implies that false positives are possible, due to collisions between projections of different elements (Blustein & El-Maazawi, 2002). The values of $m$ and $k$ can be adjusted to control the probability of such collisions. However, in practice, $m$ is usually constrained by space requirements, and $k \leq 1 0$ is employed, independent of the number of elements to be projected, and giving less than $1 \%$ false positive probability (Bonomi et al., 2006).
+
+# 3.2 EMBEDDING AND RECOVERY
+
+In the following, we describe the use of Bloom filter techniques in embedding binary highdimensional instances, and the recovery or mapping to such instances from these embeddings. We denote our approach as Bloom embedding (BE). The idea we pursue is to embed both inputs and outputs and to perform training in the embedding space. To do so, only a probability-based output activation is required, together with a loss function that is appropriate for such activations.
+
+Let $\mathbf { X }$ be an input or output instance with dimensionality $d$ , such that $\mathbf { x } = [ x _ { 1 } , \dots x _ { d } ]$ , $x _ { i } \in \{ 0 , 1 \}$ . Instances $\mathbf { X }$ are assumed to be sparse, that is, $\textstyle \sum _ { i = 1 } ^ { d } x _ { i } \ll d$ . Because of that, we can more conveniently (and compactly) represent $\mathbf { X }$ as set $\boldsymbol { z } = \left\{ \boldsymbol { z } _ { i } \right\} _ { i = 1 } ^ { c }$ , $z _ { i } \in \mathbb { N } _ { \leq d }$ , where $c$ is the number of non-zero elements and $z _ { i }$ is the position of such elements in $\mathbf { X }$ . For every set $\textsf { Z }$ , we generate an embedded instance $\mathbf { u }$ of dimensionality $m < d$ , such that $\mathbf { u } = [ u _ { 1 } , \dots u _ { m } ]$ , $u _ { i } \in \{ 0 , 1 \}$ . To do so, we first set all $m$ components of $\mathbf { u }$ to 0. Then, iteratively, for every element $z _ { i }$ , $i = 1 , \dots c$ , and every projection $H _ { j }$ , $j = 1 , \dots k$ , we assign
+
+$$
+u _ { H _ { j } ( z _ { i } ) } = 1 .
+$$
+
+Notice that, since $H _ { j }$ has a range between 1 and $m$ , $k \geq 1$ , and $m < d$ , a number of $z _ { i }$ elements may map to the same index of $\mathbf { u }$ . Bloom filters mitigate this by properly choosing $k$ independent hash functions $H$ (see above). Notice furthermore that the process has no space requirements, as $H$ is computed on-the-fly. Finally, notice that the embedding of a set $\textsf { Z }$ is constant time: the process is $O ( c k )$ , with $c$ bounded by the maximum number of non-sparse elements in x, $c \ll d$ , and $k$ being a constant that is set beforehand, $k \ll m < d$ . In practice, this constant time is dominated by the time spent on $H$ to generate a hash. If we want to be faster than that, and at the same time ensure an optimal (uniform) distribution of the outputs of $H$ , we can decide to compromise part of the available memory to pre-compute a hash matrix storing the projections or hash indices for allthe potential elements in $\textsf { Z }$ . We can do it by generating vectors $\mathbf { h } \overset { \cdot } { = } \left[ h _ { 1 } , \ldots h _ { k } \right]$ for each $z _ { i }$ , where $h _ { j }$ is a uniformly randomly chosen integer between 1 and $m$ (without replacement). This way, by pregenerating all projections for all $d$ elements, we end up with a $d \times k$ matrix $\mathbf { H }$ of integers between 1 and $m$ , which we can easily store in random-access memory (RAM), not in the GPU memory.
+
+We now explain how to recover a probability-based ranking of the $d$ elements of $\mathbf { X }$ at the output of the model. Assuming a softmax activation is used, we have a probability vector $\mathbf { v } = [ v _ { 1 } , \dots v _ { m } ]$ that, at training time, is compared to the binary embedding $\mathbf { u }$ of some ground truth set $\textsf { Z }$ (or vector $\mathbf { x } )$ . We can think of $v _ { i }$ as the probability of being the projection of some element $z _ { l }$ , that is, $v _ { i } \sim$ $P ( u _ { i } = 1 ) \sim P ( H _ { j } ( z _ { l } ) = i )$ (see Eq. 1). To unravel the embedding $\mathbf { v }$ and map to the $d$ original elements of $\mathbf { X }$ , we can understand $\mathbf { v }$ as a $k$ -way factorization of every element $x _ { i }$ . Following the idea of Bloom filters, if an element maps to $u _ { i }$ and $v _ { i } = 0$ , then the element is definitely not in the output of the model. Otherwise, if an element maps to $u _ { i }$ and $v _ { i }$ is relatively large, we want the likelihood of that element to reflect that. Specifically, given an element position $z _ { i }$ from $\mathbf { X }$ , we can compute the likelihood of $z _ { i }$ as
+
+$$
+{ \cal L } ( z _ { i } ) = \prod _ { j = 1 } ^ { k } v _ { H _ { j } ( z _ { i } ) } ,
+$$
+
+and assign outputs $x _ { i } = L ( z _ { i } )$ . Alternatively, if a more numerically-stable output is desired, we can compute the negative log-likelihood
+
+$$
+L ( z _ { i } ) = - \sum _ { j = 1 } ^ { k } \log \left( v _ { H _ { j } ( z _ { i } ) } \right) .
+$$
+
+Both operations, when iterated for $i = 1 , \ldots d$ , define a ranking over the elements in $\mathbf { X }$ , which is the most common way to define (and evaluate) sparse high-dimensional outputs. One could potentially also recover a probability distribution by re-normalization, but the problems we consider are information retrieval-type of problems (Manning et al., 2008), which are typically seen as ranking problems, such as ranking recommendations based on user preferences (Weimer et al., 2008).
+
+Note that BE, by construction, already offers a number of the aforementioned desired qualities for sparse high-dimensional embeddings (Sec. 1). Specifically, BE is designed for both inputs and outputs, offering a rank-based mapping between the original instances and the embedded vectors. BE yields a more compact representation of the original instance and requires no disk or memory space (at most some marginal RAM space, not GPU memory). In addition, BE can be performed on-the-fly, without training, and in constant time. In the following, we demonstrate the remaining desirable qualities using a comprehensive experimental setup: we show that the accuracy of the model is not compromised given a reasonable embedding dimension (sometimes it even improves), that no changes in the model architecture nor configuration are required, that training times are faster thanks to the reduction of the number of parameters of the model, that evaluation times do not carry much overhead, and that performance is generally better than a number of alternative approaches.
+
+# 4 EXPERIMENTAL SETUP
+
+# 4.1 GENERAL CONSIDERATIONS
+
+We demonstrate that BE works under several settings and that it can be applied to multiple tasks. We consider a number of data sets, network architectures, configurations, and evaluation measures. In total, we define 7 different setups, which we summarize in Sec. 4.2 and detail in Appendix A. We also demonstrate that BE is competitive with respect to the available alternatives. To this end, we consider 4 different state-of-the-art approaches, which we overview in Sec. 4.3.
+
+Table 1: Data set statistics after data cleaning and splitting. From left to right: data set name, type of modeled interaction, number of instances $n$ , test split size, instance dimensionality $d$ , median number of non-zero components $c$ , and median density $c / d$ .   
+
+<table><tr><td>Data set</td><td>Interaction</td><td>n</td><td>Split</td><td>d</td><td>C</td><td>c/d</td></tr><tr><td>ML</td><td>User-Movies</td><td>138,224</td><td>10,000</td><td>15,405</td><td>18</td><td>1.2·10-3</td></tr><tr><td>PTB</td><td>Sequence-Words</td><td>929,589</td><td>82,430</td><td>10,001</td><td>1</td><td>1.0 · 10-4</td></tr><tr><td>CADE</td><td>Words-Category</td><td>40,983</td><td>13,661</td><td>193,998</td><td>17</td><td>8.8.10-5</td></tr><tr><td>MSD</td><td>User-Songs</td><td>597,155</td><td>50,000</td><td>69,989</td><td>5</td><td>7.1 · 10-5</td></tr><tr><td>AMZ</td><td>User-Books</td><td>916,484</td><td>50,000</td><td>22,561</td><td>1</td><td>4.4 · 10-5</td></tr><tr><td>BC</td><td>User-Books</td><td>25,816</td><td>2,500</td><td>54,069</td><td>2</td><td>3.7 ·10-5</td></tr><tr><td>YC</td><td>Session-Clicks</td><td>1,865,997</td><td>50,000</td><td>35,732</td><td>1</td><td>2.8.10-5</td></tr></table>
+
+Table 2: Experimental setup and baseline scores. From left to right: data set name, network architecture and optimizer, evaluation measure name, random score $S _ { \mathrm { R } }$ , and baseline score $S _ { 0 }$ .   
+
+<table><tr><td>Data set</td><td>Architecture+Optimizer</td><td>Evaluation measure</td><td>SR</td><td>S</td></tr><tr><td>ML</td><td>Feed-forward+Adam</td><td>Mean average precision</td><td>0.003</td><td>0.160</td></tr><tr><td>PTB</td><td>LSTM + SGD</td><td>Reciprocal rank</td><td>0.001</td><td>0.342</td></tr><tr><td>CADE</td><td>Feed-forward +RMSprop</td><td>Accuracy (%)</td><td>8.5</td><td>58.0</td></tr><tr><td>MSD</td><td>Feed-forward + Adam</td><td>Mean average precision</td><td>&lt;0.001</td><td>0.066</td></tr><tr><td>AMZ</td><td>Feed-forward + Adam</td><td>Mean average precision</td><td>&lt;0.001</td><td>0.049</td></tr><tr><td>BC</td><td>Feed-forward+ Adam</td><td>Mean average precision</td><td>&lt;0.001</td><td>0.010</td></tr><tr><td>YC</td><td>GRU + Adagrad</td><td>Reciprocal rank</td><td>&lt;0.001</td><td>0.368</td></tr></table>
+
+Data sets are formed by inputs with $n$ instances, corresponding to either individual instances (or onehot encoded user profiles) or to sequences of instances (or profile lists). Outputs, also of $n$ instances, correspond to individual instances or to class labels. Instances have an original dimensionality $d$ , corresponding to the cardinality of all possible profile items. Given the nature of the considered problems, instances are very sparse, with all but $c$ elements being different from 0, $c \ll d$ , typically with $c / d$ in the order of $1 0 ^ { - 5 }$ (Table 1).
+
+For each data set, and based on the literature, we select an appropriate baseline neural network architecture. We experiment with both feed-forward (autoencoder-like) and recurrent networks, carefully selecting their parameters and configuration to match (or even improve) the state-of-theart results. For the sake of comparison, we also choose appropriate and well-known evaluation measures. Depending on the data set, we work with mean average precision, reciprocal ranks, or accuracy (Manning et al., 2008).
+
+Each combination of data set, network architecture, configuration, and evaluation measure defines a task. For every task, we compute a baseline score $S _ { 0 }$ , corresponding to running the plain neural network model without any embedding. We then report the performance of the $i \cdot$ -th combination of training with a particular embedding on a particular task with respect to the baseline score using $S _ { i } / S _ { 0 }$ . This way, we can compare the performance across different tasks using different evaluation measures, reporting relative improvement/loss with respect to the baseline. Similarly, to compare across different dimensionalities, we report the ratio of embedding dimensionality with respect to the original dimensionality, $m / d$ , and to compare across different training and evaluation times, we report time ratios with respect to the baseline, $T _ { i } / T _ { 0 }$ .
+
+# 4.2 TASKS
+
+We now give a brief summary of the 7 considered tasks (Tables 1 and 2). For a more detailed explanation related to data, network architecture, configuration, or evaluation methodology, we refer the reader to Appendix A. Further references can be also found there. All data sets are publiclyavailable, and for all tasks we use categorical cross-entropy as loss function.
+
+1. Movielens (ML): movie recommendation with the Movielens data set (Harper & Konstan, 2015). We employ a 3-layer feed-forward neural network model and optimize its parameters with Adam. We evaluate the accuracy of the model with mean average precision.   
+2. Penn treebank (PTB): next word prediction with the Penn treebank data set (Mikolov, 2012). We employ a long short-term memory (LSTM) network and optimize its parameters with stochastic gradient descent (SGD). We evaluate the accuracy of the model with the reciprocal rank of the correct prediction.   
+3. CADE web directory (CADE): text categorization with the CADE web directory data set (Cardoso-Cachopo, 2007). We employ a 4-layer feed-forward neural network model and optimize its parameters with RMSprop. This is the only considered task where output embeddings are not required (classification into 12 text categories). We use accuracy as evaluation measure.   
+4. Million song data set (MSD): song recommendation with the Million song data set (BertinMahieux et al., 2011). We employ a 3-layer feed-forward neural network model and optimize its parameters with Adam. We evaluate the accuracy of the model with mean average precision.   
+5. Amazon book reviews (AMZ): book recommendation with the Amazon book reviews data set (McAuley et al., 2015). We employ a 4-layer feed-forward neural network and optimize its parameters with Adam. We evaluate the accuracy of the model with mean average precision.   
+6. Book crossing (BC): book recommendation with the book crossing data set (Ziegler et al., 2005). We employ a 4-layer feed-forward neural network and optimize its parameters with Adam. We evaluate the accuracy of the model with mean average precision.   
+7. YooChoose (YC): session-based recommendation with the YooChoose RecSys15 challenge data set2. We employ a gated recurrent unit (GRU) model and optimize its parameters with Adagrad. We evaluate the accuracy of the model with the reciprocal rank.
+
+# 4.3 ALTERNATIVE APPROACHES
+
+To compare the performance of BE with the state-of-the-art, we consider 4 different embedding alternatives. We base our evaluation on performance, measured at a given input/output compression ratio. It is important to note that, in general, besides performance, alternative approaches do not present some of the other desired qualities (Sec. 1) that BE offers, such as on-the-fly operation, constant-time, no supervision, or no network/configuration changes.
+
+1. Hashing trick (HT). We first consider the popular hashing trick for classifier inputs (Langford et al., 2007; Weinberger et al., 2009). In general, these methodologies only focus on inputs and are not designed to deal with any type of output. Nonetheless, in the case of binary outputs, variants like the one used by Ganchev & Dredze (2008) can be adapted to map to the original items using Eqs. 2 or 3. In fact, considering this adaptation for recovery, the approach can be seen as a special case of BE with $k = 1$ .   
+2. Error-correcting output codes (ECOC). Originally designed for single-class targets (Dietterich & Bakiri, 1995), ECOC can be applied to class sets (inputs and outputs), with its corresponding encoding and decoding strategies (Armano et al., 2012). Yet, in the case of training neural networks, it is not clear which loss function should be used. The obvious choice would be to use the Hamming distance. However, in pre-analysis, a Hamming loss turned out to be significantly inferior than cross-entropy. Therefore, we use the latter in our experiments. We construct the ECOC matrix with the randomized hill-climbing method of Dietterich & Bakiri (1995).   
+3. Pairwise mutual information (PMI). Recently, Chollet (2016) has proposed a PMI approach for embedding sets of image labels into a dense space of real-valued vectors. The approach
+
+![](images/69b3e2c9cc876902ae2c5290ff03553ca983eb4bd21689aebcf62363df8a817c.jpg)  
+Figure 1: Score ratios $S _ { i } / S _ { 0 }$ as a function of dimensionality ratio $m / d$ using $k = 4$ . Qualitatively similar plots are observed for other values of $k$ .
+
+is based on the SVD of a PMI matrix computed from counting pairwise co-occurrences. It uses cosine similarity as the loss function and, at prediction time, it performs KNN (again using cosine similarity) with the projection of individual labels to obtain a ranking.
+
+4. Canonical correlation analysis (CCA). CCA is a common way to learn a joint dense, realvalued embedding for both inputs and outputs at the same time (Hotelling, 1936). CCA can be computed using SVD on a correlation matrix (Hsu et al., 2012) and, similarly to PMI, we can use the KNN trick to rank elements or labels at prediction time. Correlation is now the metric of choice, both for the loss function and for determining the neighbors.
+
+# 5 RESULTS
+
+We start by reporting on the performance of BE. First of all, we focus on performance as a function of the embedding dimension. As mentioned, to facilitate comparisons, we report in relative terms, using score ratios $S _ { i } / S _ { 0 }$ and dimensionality ratios $m / d$ . When plotting the former as a function of the latter, we see several things that are worth noting (Fig. 1). Firstly, we observe that, for most of the tasks, score ratios approach 1 as $m$ approaches $d$ . This indicates that the introduction of BE does not degrade the original score of the Baseline when the embedding dimension $m$ is comparable to the original dimension $d$ . Secondly, we observe that the lower the dimensionality ratio, the lower the score ratio. This is to be expected, as one cannot embed sets of elements with their intrinsic dimensionality to an infinitesimally small $m$ . Importantly, the reduction of $S _ { i } / S _ { 0 }$ should not be linear with $m / d$ , but should maximize $S _ { i }$ for low $m$ (thus getting curves close to the top left corner of Fig. 1). We see that BE fulfills this requirement. In general, we can reduce the size of inputs and outputs 5 times $( m / d = 0 . 2 )$ and still maintain more than $92 \%$ of the value of the original score. The ML task is the only exception, which we think is due to the abnormally high density of the data (Table 1), inhibiting the embedding to low dimensions3. CADE is the task for which BE achieves the highest $S _ { i }$ for low $m$ . Presumably, the CADE task is the easiest one we consider, as only input embeddings are required.
+
+An additional observation is worth noting (Fig. 1). Interestingly, we find that BE can improve the scores over the Baseline for a number of tasks. That is the case for 3 out of the 7 considered tasks: MSD with $m / d \geq 0 . 3$ , AMZ with $m / d \geq 0 . 2$ , and BC with $0 . 3 \leq m / d \leq 0 . 6$ . The fact that an embedding performs better than the original Baseline has been also observed in some other methods for specific data sets (Weston et al., 2002; Langford et al., 2007; Chollet, 2016). For instance, Chollet (2016) has reported increases up to $7 \%$ using the PMI approach on the so-called JFT data set. Here, depending on the task and the embedding dimension, relative increases go from 1 to $12 \%$ . Given that the data sets where we observe these increases are some of the less dense ones (Table 1), we hypothesize that, in the case of BE, such increases come from having $k$ times more active elements in the ground truth output (recall that one output element is projected $k$ times using $k$ independent hash functions, Sec. 3.2). With $k$ more times elements set to 1 in the output, a better estimation of the gradient may be computed (larger errors that propagate back to the rest of the network).
+
+![](images/dcaa89d64ff3aec9c6f9fd1aa57c541c4e4d81898229948fb589391315f6e304.jpg)  
+Figure 2: Score ratios $S _ { i } / S _ { 0 }$ as a function of the number of hash functions $k$ : using $m / d = 0 . 3$ (left) and $m / d = 1$ (right).
+
+We now focus on performance as a function of the number of projections $k$ , reporting score ratios $S _ { i } / S _ { 0 }$ as above (Fig. 2). From repeating the plots for different values of $m / d$ , we observe that $S _ { i } / S _ { 0 }$ is always low for $k = 1$ (Fig. 2, left), except when $m$ approaches $d$ , where we have an almost flat behavior (Fig. 2, right). In general, $S _ { i } / S _ { 0 }$ jumps up for $k \geq 2$ and remains stable until $k \approx 1 0$ , where the decrease of $S _ { i } / S _ { 0 }$ becomes more apparent (Fig. 2, left). The best operating range typically corresponds to $2 \leq k \leq 4$ . The ML task is again an exception, with a best operating range around $7 \leq k \leq 1 0$ .
+
+Besides performance scores, it is interesting to assess whether the reduction of input and output dimensions has an effect to training and evaluation times. To this end, we plot the time ratios $T _ { i } / T _ { 0 }$ as a function of the dimensionality ratio $m / d$ (Fig. 3). Regarding training times, we basically observe a linear decrease with $m / d$ (Fig. 3, left). ML is an exception to the trend, and CADE and AMZ experiment almost no decrease for very low dimensionality ratios $m / d < 0 . 2$ . In general, we confirm faster training times thanks to the reduction of the number of parameters of the model, dominated by input/output matrices (output dimension also affecting the time to compute the loss function). We obtain a 2 times speedup for a 2 times input/output compression and, roughly, a little bit over 3 times speedup for a 5 times input/output compression. Regarding evaluation times, we also observe a linear trend (Fig. 3, right). However, this time, $T _ { i } / T _ { 0 }$ is not as low, with values slightly above 1 but always below 1.5 (with the exception of CADE for $m / d > 0 . 6 )$ . Overall, this indicates that, compared to the Baseline evaluation time, the mapping used by BE when reconstructing the output does not introduce an overwhelming amount of extra computation time. With the exception of ML, extra computation time is below $20 \%$ for $m / d < 0 . 5$ .
+
+Finally, we compare the performance of BE to the one of the considered alternative methods. We do so by establishing a dimensionality ratio $m / d$ and computing the corresponding score ratio $S _ { i } / S _ { 0 }$ for a given task (Table 3). We see that BE is better than the alternative methods in 5 out of the 7 tasks (10 out of the 14 considered test points). PMI is better in one of the tasks (CADE) and CCA is better also in one of the tasks (AMZ). It is relevant to note that, when BE wins, it always does so by a relatively large margin (see, for instance, the ML or YC tasks). Otherwise, when an alternative approach wins, generally it does so by a smaller margin (see, for instance, the AMZ task). These results become more relevant if we realize that PMI and CCA are both SVD-based approaches, introducing a separate degree of supervised learning to the task by exploiting pairwise element co-occurrences and correlations, respectively (Sec. 4.3). In contrast, BE does not require any learning. We formulate a co-occurrence-based version of BE in Appendix B, which achieves moderate performance increments over BE and more closely approaches the performance of PMI and CCA on the two tasks where BE was not already performing best. To conclude, a further interesting thing to note is that we confirm the small variation in the score ratios obtained for $2 \leq$ $k \leq 1 0$ (Fig. 2). Here, score ratios for $3 \le k \le 5$ are often comparable in a statistical significance sense (Table 3).
+
+![](images/cdbcfbb1797bd12ec7387eaf7599dd21717764c40239d19a03ef0ac3680efbd3.jpg)  
+Figure 3: Time ratios $T _ { i } / T _ { 0 }$ as a function of dimensionality ratios $m / d$ with $k = 4$ : training time (left) and evaluation time (right). Qualitatively similar plots are observed for other values of $k$ . Bl. denotes baseline.
+
+Table 3: Comparison of BE with the considered alternatives. Score ratios $S _ { i } / S _ { 0 }$ for different combinations of data set and compression ratio $m / d$ . Best results are highlighted in bold, up to statistical significance (Mann-Whitney U, $p { > } 0 . 0 5 ) ,$ ).   
+
+<table><tr><td colspan="2">Test point</td><td colspan="4">Alternativemethods</td><td colspan="3">BE</td></tr><tr><td>Data set</td><td>m/d</td><td>HT</td><td>ECOC</td><td>PMI</td><td>CCA</td><td>k=3</td><td>k=4</td><td>k=5</td></tr><tr><td>ML</td><td>0.2</td><td>0.234</td><td>0.342</td><td>0.043</td><td>0.209</td><td>0.750</td><td>0.770</td><td>0.722</td></tr><tr><td>ML</td><td>0.3</td><td>0.285</td><td>0.208</td><td>0.045</td><td>0.200</td><td>0.796</td><td>0.813</td><td>0.815</td></tr><tr><td>PTB</td><td>0.2</td><td>0.357</td><td>0.453</td><td>0.837</td><td>0.638</td><td>0.919</td><td>0.908</td><td>0.881</td></tr><tr><td>PTB</td><td>0.4</td><td>0.528</td><td>0.454</td><td>0.836</td><td>0.695</td><td>0.942</td><td>0.920</td><td>0.902</td></tr><tr><td>CADE</td><td>0.01</td><td>0.857</td><td>0.359</td><td>0.984</td><td>0.928</td><td>0.862</td><td>0.853</td><td>0.855</td></tr><tr><td>CADE</td><td>0.03</td><td>0.914</td><td>0.363</td><td>1.002</td><td>0.950</td><td>0.914</td><td>0.925</td><td>0.926</td></tr><tr><td>MSD</td><td>0.05</td><td>0.078</td><td>0.268</td><td>0.216</td><td>0.679</td><td>0.695</td><td>0.738</td><td>0.738</td></tr><tr><td>MSD</td><td>0.1</td><td>0.151</td><td>0.310</td><td>0.321</td><td>0.740</td><td>0.835</td><td>0.841</td><td>0.832</td></tr><tr><td>AMZ</td><td>0.1</td><td>0.166</td><td>0.182</td><td>0.851</td><td>1.030</td><td>0.864</td><td>0.881</td><td>0.861</td></tr><tr><td>AMZ</td><td>0.2</td><td>0.289</td><td>0.185</td><td>0.995</td><td>1.048</td><td>1.016</td><td>1.029</td><td>1.008</td></tr><tr><td>BC</td><td>0.05</td><td>0.189</td><td>0.817</td><td>0.022</td><td>0.313</td><td>0.777</td><td>0.750</td><td>0.837</td></tr><tr><td>BC</td><td>0.1</td><td>0.199</td><td>0.886</td><td>0.025</td><td>0.465</td><td>0.965</td><td>0.919</td><td>0.831</td></tr><tr><td>YC</td><td>0.03</td><td>0.150</td><td>0.076</td><td>0.776</td><td>0.466</td><td>0.841</td><td>0.858</td><td>0.858</td></tr><tr><td>YC</td><td>0.05</td><td>0.240</td><td>0.083</td><td>0.777</td><td>0.517</td><td>0.919</td><td>0.910</td><td>0.928</td></tr></table>
+
+# 6 CONCLUSION
+
+We have proposed the use of Bloom embeddings to represent sparse high-dimensional binary-coded inputs and outputs. We have shown that a compact representation can be obtained without compromising the performance of the original neural network model or, in some cases, even increasing it by a substantial factor. Due to the compact representation, the loss function and the input and output layers deal with less parameters, which results in faster training times. The approach compares favorably with respect to the considered alternatives, and offers a number of further advantages such as on-the-fly operation or zero space requirements, all this without introducing changes to the core network architecture, task configuration, or loss function.
+
+In the future, besides continuing to exploit co-occurrences (Appendix B), one could extend the proposed approach by considering further extensions of Bloom filters such as counting Bloom filters (Bonomi et al., 2006). In theory, those extensions could provide a more compact representation by breaking the binary nature of the embedding. However, they could require the modification of the loss function or the mapping process (Eqs. 2 and 3). A faster mapping process using the sorted probabilities of v could also be studied.
+
+# ACKNOWLEDGMENTS
+
+We thank the curators of the data sets used in this study for making them publicly-available. We also thank Santi Pascual for his comments on a previous version of the paper.
+
+# REFERENCES
+
+Z. Akata, F. Perronnin, Z. Harchaoui, and C. Schmid. Label-embedding for image classification. IEEE Trans. on Pattern Analysis and Machine Intelligence, 38(7):1425–1438, 2015.   
+Y. Amit, M. Fink, N. Srebro, and S. Ullman. Uncovering shared structures in multiclass classification. In Proc. of the Int. Conf. on Machine Learning (ICML), pp. 17–24, 2007.   
+G. Armano, C. Chira, and N. Hatami. Error-correcting output codes for multi-label text categorization. In Proc. of the Italian Information Retrieval Conf. (IIR), pp. 26–37, 2012.   
+S. Bengio, J. Weston, and D. Grangier. Label embedding trees for large multi-class tasks. In Advances in Neural Information Processing Systems (NIPS), volume 23, pp. 163–171. 2010.   
+Y. Bengio, R. Ducharme, and P. Vincent. A neural probabilistic language model. In T. K. Leen, T. G. Dietterich, and V. Tresp (eds.), Advances in Neural Information Processing Systems (NIPS), volume 13, pp. 932–938. 2000.   
+T. Bertin-Mahieux, D. P. W. Ellis, B. Whitman, and P. Lamere. The million song dataset. In Proc. of the Int. Soc. for Music Information Retrieval Conf. (ISMIR), pp. 591–596, 2011.   
+B. H. Bloom. Space/time trade-offs in hash coding with allowable errors. Communications of the ACM, 13(7):422–426, 1970.   
+J. Blustein and A. El-Maazawi. Bloom filters – a tutorial, analysis, and survey. Technical report, Faculty of Computer Science, Dalhousie University, Halifax, Canada, 2002. URL https:// www.cs.dal.ca/research/techreports/cs-2002-10.   
+F. Bonomi, M. Mitzenmacher, R. Panigrahy, S. Singh, and G. Varghese. An improved construction for counting Bloom filters. In Y. Azar and T. Erlebach (eds.), European Symposium on Algorithms (ESA), volume 4168 of Lecture Notes in Computer Science, pp. 684–695. Springer-Verlag, Berlin, Germany, 2006.   
+A. Cardoso-Cachopo. Improving methods for single-label text categorization. PhD thesis, Instituto Superior Tecnico, Universidade Tecnica de Lisboa, 2007.   
+W. Chen, J. Wilson, S. Tyree, K. Weinberger, and Y. Chen. Compressing neural networks with the hashing trick. In Proc. of the Int. Conf. on Machine Learning (ICML), pp. 2285–2294, 2015.   
+H.-T. Cheng, L. Koc, J. Harmsen, T. Shaked, T. Chandra, H. Aradhye, G. Anderson, G. Corrado, W. Chai, M. Ispir, R. Anil, Z. Haque, L. Hong, V. Jain, X. Liu, and H. Shah. Wide & deep learning for recommender systems. In Proc. of the Workshop on Deep Learning for Recommender Systems (DLRS), pp. 7–10, 2016.   
+K. Cho, B. Van Merrienboer, D. Bahdanau, and Y. Bengio. On the properties of neural machine ¨ translation: encoder-decoder approaches. In Proc. of the Workshop on Syntax, Semantics and Structure in Statistical Translation (SSST), pp. 103–111, 2014.   
+F. Chollet. Information-theoretic label embeddings for large-scale image classification. ArXiv: 1607.05691, 2016.   
+M. Cisse, N. Usunier, T. Arti ´ eres, and P. Gallinari. Robust Bloom filters for large multilabel clas- \` sification tasks. In Advances in Neural Information Processing Systems (NIPS), pp. 1851–1859. 2013.   
+M. Courbariaux, Y. Bengio, and J.-P. David. BinaryConnect: training deep neural networks with binary weights during propagations. In C. Cortes, N. D. Lawrence, D. D. Lee, M. Sugiyama, and R. Garnett (eds.), Advances in Neural Information Processing Systems (NIPS), pp. 3123–3131. 2015.   
+T. G. Dietterich and G. Bakiri. Solving multiclass learning problems via error-correcting output codes. Journal of Artificial Intelligence Research, 2:263–286, 1995.   
+P. C. Dillinger and P. Manolios. Bloom filters in probabilistic verification. In Proc. of the Int. Conf. on Formal Methods in Computer-Aided Design (FMCAD), pp. 367–381, 2004.   
+J. Duchi, E. Hazan, and Y. Singer. Adaptive subgradient methods for online learning and stochastic optimization. Journal of Machine Learning Research, 12:2121–2159, 2011.   
+K. Ganchev and M. Dredze. Small statistical models by random feature mixing. In ACL Workshop on Mobile Language Processing (MLP), pp. 19–20, 2008.   
+X. Glorot and Y. Bengio. Understanding the difficulty of training deep feedforward neural networks. In Proc. of the Int. Conf. on Artificial Intelligence and Statistics (AISTATS), pp. 249–256, 2010.   
+X. Glorot, A. Bordes, and Y. Bengio. Deep sparse rectifier neural networks. In Proc. of the Int. Conf. on Artificial Intelligence and Statistics (AISTATS), pp. 315–323, 2011.   
+E. Grave, A. Joulin, M. Cisse, D. Grangier, and H. J ´ egou. Efficient softmax approximation for ´ GPUs. ArXiv: 1609.04309, 2016.   
+A. Graves. Generating sequences with recurrent neural networks. ArXiv: 1308.0850, 2013.   
+S. Han, H. Mao, and W. J. Dally. Deep compression: compressing deep neural networks with pruning, trained quantization and Huffman coding. In Proc. of the Int. Conf. on Learning Representations (ICLR), 2016.   
+F. M. Harper and J. K. Konstan. The MovieLens datasets: history and context. ACM Trans. on Interactive Intelligent Systems, 5(4):19, 2015.   
+B. Hidasi, A. Karatzoglou, L. Baltrunas, and D. Tikk. Session-based recommendations with recurrent neural networks. In Proc. of the Int. Conf. on Learning Representations (ICLR), 2016. URL https://arxiv.org/abs/1511.06939.   
+S. Hochreiter and J. Schmidhuber. Long short-term memory networks. Neural Computation, 9(8): 1735–1780, 1997.   
+H. Hotelling. Relations between two sets of variates. Biometrika, 28(3-4):321–377, 1936.   
+D. Hsu, S. M. Kakade, and T. Zhang. A spectral algorithm for learning hidden Markov models. Journal of Computer and System Sciences, 78(5):1460–1470, 2012.   
+D. J. Hsu, S. M. Kakade, J. Langford, and T. Zhang. Multi-label prediction via compressed sensing. In Y. Bengio, D. Schuurmans, J. D. Lafferty, C. K. I. Williams, and A. Culotta (eds.), Advances in Neural Information Processing Systems (NIPS), volume 22, pp. 772–780. 2009.   
+Y.-D. Kim, E. Park, S. Yoo, T. Choi, L. Yang, and D. Shin. Compression of deep convolutional neural networks for fast and low power mobile applications. In Proc. of the Int. Conf. on Learning Representations (ICLR), 2016. URL https://arxiv.org/abs/1511.06530.   
+D. P. Kingma and J. L. Ba. Adam: a method for stochastic optimization. In Proc. of the Int. Conf. on Learning Representations (ICLR), 2015. URL https://arxiv.org/abs/1412.6980.   
+J. Langford, L. Li, and A. Strehl. Vowpal wabbit online learning project. Technical report, 2007. URL http://hunch.net/ $? { \mathrm { p } } = 3 0 9$ .   
+C. D. Manning, P. Raghavan, and H. Schutze. ¨ Introduction to information retrieval. Cambridge University Press, Cambridge, UK, 2008.   
+M. P. Marcus, B. Santorini, and M. A. Marcinkiewich. Building a large annotated corpus of English: the Penn treebank. Computational Linguisitcs, 19(2):313–330, 1993.   
+J. McAuley, R. Pandey, and J. Leskovec. Inferring networks of substitutable and complementary products. In Proc. of the ACM SIGKDD Int. Conf. on Knowledge Discovery and Data Mining (KDD), pp. 785–794, 2015.   
+T. Mikolov. Statistical language models based on neural networks. PhD thesis, Brno University of Technology, 2012.   
+T. Mikolov, K. Chen, G. S. Corrado, and J. Dean. Efficient estimation of word representations in vector space. ArXiv: 1301.3781, 2013.   
+M. Mitzenmacher and E. Upfal. Probability and computing: randomized algorithms and probabilistic analysis. Cambridge University Press, Cambridge, UK, 2005.   
+F. Morin and Y. Bengio. Hierarchical probabilistic neural network language model. In Proc. of the Int. Workshop on Artificial Intelligence and Statistics (AISTATS), pp. 246–252, 2005.   
+Q. Shi, J. Petterson, G. Dror, J. Langford, A. Smola, and S. V. N. Vishwanathan. Hash kernels for structured data. Journal of Machine Learning Research, 10:2615–2637, 2009.   
+F. Strub, R. Gaudel, and J. Mary. Hybrid recommender system based on autoencoders. In Proc. of the Workshop on Deep Learning for Recommender Systems (DLRS), pp. 11–16, 2016.   
+T. Tieleman and G. Hinton. Lecture 6.5-RMSprop: divide the gradient by a running average of its recent magnitude. COURSERA: Neural Networks for Machine Learning 4, 2, 2012.   
+J. Turian, L. Ratinov, and Y. Bengio. Word representations: a simple and general method for semisupervised learning. In Proc. of the Annual Meeting of the Association for Computational Linguistics (ACL), pp. 384–394, 2010.   
+P. Vincent, A. Brebisson, and X. Bouthilier. Efficient exact gradient update for training deep net- ´ works with very large sparse targets. In Advances in Neural Information Processing Systems (NIPS), pp. 1108–1116. 2015.   
+M. Weimer, A. Karatzoglou, Q. V. Le, and A. J. Smola. COFI RANK - maximum margin matrix factorization for collaborative ranking. In J. C. Platt, D. Koller, Y. Singer, and S. T. Roweis (eds.), Advances in Neural Information Processing Systems (NIPS), volume 20, pp. 1593–1600. 2008.   
+K. Weinberger, A. Dasgupta, J. Attenberg, J. Langford, and A. Smola. Feature hashing for large scale multitask learning. In Proc. of the Int. Conf. on Machine Learning (ICML), pp. 1113–1120, 2009.   
+J. Weston, O. Chapelle, A. Elisseeff, B. Scholkopf, and V. Vapnik. Kernel dependency estimation. ¨ In S. Becker, S. Thrun, and K. Obermayer (eds.), Advances in Neural Information Processing Systems (NIPS), volume 15, pp. 873–880. 2002.
+
+J. Weston, S. Bengio, and N. Usunier. Large scale image annotation: learning to rank with joint word-image embeddings. Machine Learning, 81(1):21–35, 2010.
+
+Y. Wu, C. DuBois, A. X. Zheng, and M. Ester. Collaborative denoising auto-encoders for top-n recommender systems. In Proc. of the ACM Int. Conf. on Web Search and Data Mining (WSDM), pp. 153–162, 2016.
+
+C.-N. Ziegler, S. M. McNee, J. A. Konstan, and G. Lausen. Improving recommendation lists through topic diversification. In Proc. of the Int. World Wide Web Conf. (WWW), pp. 22–32, 2005.
+
+# APPENDIX A TASKS DETAIL
+
+# A.1 MOVIELENS (ML)
+
+We first consider the task of movie recommendation with the Movielens 20M data set4 (Harper & Konstan, 2015). This data set comprises 20 million ratings applied to roughly 27,000 movies by over 138,000 users. To recommend movies that users would like, ratings, originally between 0.5 and 5 stars, were discretized with a threshold of 3.5. Then, movies with less than 5 ratings were removed, resulting in a total of 15,405 movies. User profiles were next built using a chronologically-ordered list of liked movies. We removed users with less than 2 movies and limited profiles to a maximum of 2,000 movies (less than $0 . 1 \%$ fulfilled this condition). Inputs and outputs were built by splitting user profiles uniformly at random, ensuring a minimum of one movie in both input and output. Finally, 10,000 random users were taken out for validation and another 10,000 for testing. The ML data set is the most dense data set we consider, with a median of 18 movies in input/output profiles (Table 1).
+
+To perform recommendations with the ML data set, we build on top of $\mathrm { W u }$ et al. (2016) and consider a 3-layer feed-forward neural network with a softmax output and 150 rectified linear units (Glorot et al., 2011) in the hidden layers. We initialize the weights with uniform random numbers, weighted by the input and output dimensionality of the layer (Glorot & Bengio, 2010). We optimize the weights of the network using cross-entropy and Adam (Kingma & Ba, 2015), with a learning rate of 0.001 and parameters $\beta _ { 1 } ~ = ~ 0 . 9$ and $\beta _ { 2 } ~ = ~ 0 . 9 9 9$ . Training is performed for 15 epochs and with batches of 32 instances. If no improvement is seen on the validation set after one epoch, the learning rate is divided by 5. As done with all the other tasks, we make sure that the network architecture and the number of epochs is sufficient to achieve a state-of-the-art result. As the output probabilities define a ranking of movies that the user may like, the accuracy of the result is measured with mean average precision (Manning et al., 2008). The obtained baseline score $S _ { 0 } = 0 . 1 6 0$ can be considered a state-of-the-art result (Wu et al., 2016). Performing movie rankings at random yields a score $S _ { \mathrm { R } } = 0 . 0 0 3$ .
+
+# A.2 PENN TREEBANK (PTB)
+
+Another task we consider is next-word prediction with the Penn treebank data set (Marcus et al., 1993). We employ the data made available by Mikolov (2012), which contains close to 1 million words and defines validation and test splits of roughly 74,000 and 82,000 words, respectively. The vocabulary is limited to 10,000 words, with all other words mapped to an ‘unknown’ token (Table 1). We consider the end of the sentence as an additional token and form input sequences of length 10.
+
+Inspired by Graves (2013), we perform next word prediction with an LSTM network (Hochreiter & Schmidhuber, 1997). We set the inner dimensionality to 250 and train the network with SGD. We use a learning rate of 0.25, a momentum of 0.99, and clip gradients to have a maximum norm of 1 (Graves, 2013). We use batches of 128 instances and train the model for 10 epochs. As for the rest, we proceed as with the ML task. We evaluate the result using the reciprocal rank of the correct prediction (Manning et al., 2008). We achieve a performance of $S _ { 0 } = 0 . 3 4 2$ , which indicates that, on average, the correct word is ranked on the third position. Predicting words at random yields a score $S _ { \mathrm { R } } = 0 . 0 0 1$ .
+
+# A.3 CADE WEB DIRECTORY (CADE)
+
+We perform single-label text categorization using web pages classified by human experts from the CADE web directory of Brazilian web pages5 (Cardoso-Cachopo, 2007). The data set contains around 40,000 documents assigned to one of 12 categories such as services, education, health, or culture. We use the train and test splits provided by Cardoso-Cachopo (2007), further splitting the train set randomly to obtain a validation set from it. Validation and test splits comprise 5,000 and 13,661 documents, respectively. The size of the vocabulary is close to 200,000 words with a median number of 17 words per document (Table 1).
+
+To perform classification we use a 4-layer feed-forward neural network with a softmax output. The number of units is, from input to output, 400, 200, 100, and 12, and we use rectified linear units as activations for the hidden layers. We train the network for 10 epochs, using batches of 32 instances and RMSprop (Tieleman & Hinton, 2012) with a learning rate of 0.0002 and exponential decay of 0.9. As for the rest, we proceed as with the ML task. We obtain a baseline accuracy of $S _ { 0 } = 5 8 . 0 \%$ , slightly superior than the best baseline reported by Cardoso-Cachopo (2007), and a random accuracy of $S _ { \mathrm { R } } = 8 . 5 \%$ (Table 2). Notice that this is the only data set that does not have a sparse instance or user profile as output.
+
+# A.4 MILLION SONG DATA SET (MSD)
+
+The next task we consider is song recommendation with the million song data set (Bertin-Mahieux et al., 2011). We take the Echo Nest taste profile subset6, which includes over 48 million play counts of around 384,000 songs for roughly 1 million users. We assume that a user likes a song when this has listened to it a minimum of 3 times. We then remove the songs that appear less than 20 times and build user profiles with a minimum of 5 songs. We split the data set as with the ML task, keeping 50,000 user profiles for validation and another 50,000 for testing. The MSD data set has a median of 5 songs in input/output profiles (Table 1).
+
+To recommend future listens to the user we use a 3-layer feed-forward neural network with a softmax output and 300 rectified linear units in the hidden layers. We fit the model for 10 epochs with batches of 64 instances. As for the rest, we proceed as with the ML task. We obtain a baseline mean average precision of $S _ { 0 } = 0 . 0 6 6$ and a random score of $S _ { \mathrm { R } }$ below 0.001.
+
+# A.5 AMAZON BOOK REVIEWS (AMZ)
+
+We also consider book recommendations with the Amazon book reviews data $\mathrm { s e t } ^ { 7 }$ (McAuley et al., 2015). The data set originally contains 22 million ratings of over 2 million books by approximately 3 million users. We proceed as with the ML data set, but this time setting the minimum number of ratings per book to 100 and splitting the data with 50,000 instances for validation and another 50,000 instances for testing.
+
+We here use a 4-layer feed-forward neural network with a softmax output and 300 rectified linear units in the hidden layers. We fit the model for 10 epochs with batches of 64 instances and, as for the rest, we proceed as with the ML task. We obtain a baseline mean average precision of $S _ { 0 } = 0 . 0 4 9$ and a random score of $S _ { \mathrm { R } }$ below 0.001.
+
+# A.6 BOOK CROSSING (BC)
+
+Continuing with book recommendations, we consider the book crossing data set8 (Ziegler et al., 2005). It contains 278,000 users providing over 1 million ratings about a little more than 271,000 books. We remove books with less than 2 ratings, discretize those by a threshold of 4, and proceed as with the ML data set, but keeping 2,500 users for validation and another 2,500 for testing. The BC data set is known to be a very sparse data set, specially after removing users with less than 2 book reviews (Table 1).
+
+To perform recommendations we use the same architecture and configuration as with the MSD task, but this time we use 250 units in the hidden layers. We obtain a baseline mean average precision of $S _ { 0 } = 0 . 0 1 0$ and a random score of $S _ { \mathrm { R } }$ below 0.001.
+
+# A.7 YOOCHOOSE (YC)
+
+We finally study session-based recommendations using the YooChoose RecSys15 challenge9 data. Here, the task is to predict the next click given a sequence of click events for a given session in an e-commerce site (Hidasi et al., 2016). We work with the training set of the challenge and keep only the click events. We take the first 2 million sessions of the data set which have a minimum of 2 clicks, and keep apart 50,000 for validation and another 50,000 for testing. We form sequences of, at most, 13 clicks to the 35,000 possible links (Table 1). Note that this is a sequential data set with one-hot encoded instances of only one event each.
+
+To predict the next click we proceed as in Hidasi et al. (2016) and consider a GRU model (Cho et al., 2014). We set the inner dimensionality to 100 and train the network with Adagrad (Duchi et al., 2011), using a learning rate of 0.01. We use batches of 64 instances and train the model for 10 epochs. As for the rest, we proceed as with the ML task. As with PTB, we evaluate the result using the reciprocal rank of the correct prediction. We achieve a performance of $S _ { 0 } = 0 . 3 6 8$ , which can be assumed to be as good as state-of-the-art models on this data (Hidasi et al., 2016). Predicting clicks at random yields a score $S _ { \mathrm { R } }$ below 0.001.
+
+# APPENDIX B GOING ONE STEP FURTHER WITH CO-OCCURRENCE-BASED COLLISIONS
+
+B.1 CO-OCCURRENCE-BASED BLOOM EMBEDDING (CBE)
+
+In Bloom filters and BE, collisions are unavoidable due to the lower embedding dimensionality and the use of multiple projections (Sec. 3). In addition we have seen that alternative approaches produce embeddings by exploiting co-occurrence information (Secs. 2 and 4.3). Here, we study a variant of BE that takes advantage of co-occurrence information to adjust the collisions that will inevitably take place when performing the embedding. We denote this approach by co-occurrencebased Bloom embedding (CBE).
+
+What we propose is a quite straightforward approach to CBE, which does not add much extra precomputation time. Training and testing times remain the same, as CBE uses a pre-computed hashing matrix H (Sec. 3.2). The general idea of the proposed approach is to ‘re-direct’ the collisions of the co-occurring elements to the same bits or positions of u. Our implementation of this idea is detailed in Algorithm 1, and briefly explained below.
+
+Algorithm 1 Pseudocode for CBE.
+
+Input: Input and/or output instances $\mathbf { X }$ $\cdot n \times d$ sparse binary matrix), embedding dimensionality $m$ , number of projections $k$ , and pre-computed hashing matrix $\mathbf { H }$ ( $d \times k$ integers matrix).
+
+Output: Co-occurrence-based hashing matrix $\mathbf { H } ^ { \prime }$
+
+1: $\mathbf { C } \gets \mathbf { X } ^ { \mathrm { { T } } } \mathbf { X }$   
+2: $\mathbf { C }  \mathbf { C }$ $\odot$ $\operatorname { S G N } ( \mathbf { C } - \operatorname { A V G F R E Q } ( \mathbf { X } ) )$   
+3: cVAL , $\mathbf { c } ^ { \mathrm { R O W } }$ , $\mathbf { c } ^ { \mathrm { { c o L } } } \gets \mathrm { { C O O R D } } \big ( \mathrm { { L O W T R I } } ( \mathbf { C } ) \big )$   
+4: for $i$ in ARGSORT(cVAL)   
+5: a, b ← cROW, cCOL   
+6: $r \gets \mathrm { U R N D } \big ( 1 , m , \mathsf { h } _ { a } \cup \mathsf { h } _ { b } \big )$   
+7: $j _ { a } \gets \mathrm { U R N D } ( 1 , k , \emptyset )$   
+8: $j _ { b } \gets \mathrm { U R N D } ( 1 , k , \emptyset )$   
+9: $h _ { a , j _ { a } } , h _ { b , j _ { b } } \gets r$
+
+Table 4: Co-occurrence statistics and average score increase of CBE over BE. From left to right: data set name, input percent of co-occurrent pairs, input average co-occurrence ratio of co-occurrent pairs, output percent of co-occurrent pairs, output average co-occurrence ratio of co-occurrent pairs, and average score increases of CBE over BE ( $\%$ , calculated using $1 0 0 ( S _ { j } - S _ { i } ) / S _ { 0 }$ and averaging over all $m / d$ points). Co-occurrence values for PTB and YC inputs correspond to considering training sequences, not isolated sequence elements.   
+
+<table><tr><td rowspan="2">Data set</td><td colspan="4">Co-occurrence statistics</td><td colspan="2">Score increase (%)</td></tr><tr><td>Input (%)</td><td>Input (p)</td><td>Output (%)</td><td>Ouput (p)</td><td>k=3</td><td>k=4</td></tr><tr><td>ML</td><td>25.2</td><td>1.3:10-4</td><td>32.9</td><td>1.0.10-4</td><td>+0.9</td><td>+1.7</td></tr><tr><td>PTB</td><td>3.3</td><td>2.4· 10-5</td><td>0</td><td>0</td><td>+0.1</td><td>+0.9</td></tr><tr><td>CADE</td><td>1.3</td><td>8.8.10-5</td><td>N/A</td><td>N/A</td><td>-0.4</td><td>-0.1</td></tr><tr><td>MSD</td><td>1.3</td><td>3.0·10-6</td><td>1.3</td><td>3.1·10-6</td><td>+0.5</td><td>+1.5</td></tr><tr><td>AMZ</td><td>3.0</td><td>1.8. 10-6</td><td>3.0</td><td>1.8.10-6</td><td>+6.6</td><td>+8.4</td></tr><tr><td>BC</td><td>0.8</td><td>4.9.10-5</td><td>0.4</td><td>4.9 · 10-5</td><td>-3.4</td><td>-1.0</td></tr><tr><td>YC</td><td>0.2</td><td>1.5 · 10-6</td><td>0</td><td>0</td><td>+0.4</td><td>+0.3</td></tr></table>
+
+First, we count pairwise co-occurrences and store them in a sparse matrix C (line 1). Next, we threshold C by the average element frequency in $\mathbf { X }$ using the Hadamard product $\odot$ and a componentwise sign function (line 2). We then get the lower triangular part of C and return it in coordinates format, that is, using a tuple of values, row indices, and column indices (line 3). We will use the order in $\mathbf { c } ^ { \mathrm { { V A L } } }$ to update the hash matrix H. To do so, we first loop over the indices of the sorted values of $\mathbf { c } ^ { \mathrm { { V A L } } }$ in increasing order (line 4). After selecting the corresponding elements $a$ and $b$ (line 5), we then draw integers from URND (lines 6–8). The function $\mathrm { U R N D } \left( x , y , z \right)$ is a uniform random integer generator between $x$ and $y$ (both included) such that the output integer is not included in the set $\textsf { Z }$ , that is, $\mathrm { U R N D } ( x , y , z ) \not \in { z }$ . Rows $a$ and $b$ of $\mathbf { H }$ are transformed to sets $\mathsf { h } _ { a }$ and $\mathsf { h } _ { b }$ and its union is computed (line 6). Finally, we use the integers generated by URND to pick projections $j _ { a }$ and $j _ { b }$ from $\mathbf { H }$ , and assign them the same bit $r$ (line 9). By updating the projections in $\mathbf { H }$ in increasing order of co-occurrence (line 4), we give priority to the pairs with largest co-occurrence, setting them to collide to the same bit $r$ (line 9).
+
+# B.2 CBE RESULTS
+
+Overall, the performance of CBE only provides moderate increments over the original BE approach (Fig. 4). With the exception of the BC task, the performance of CBE is always higher than the one of BE. However, with the exception of the AMZ task, we do not observe dramatic increases of CBE over BE. On average, such increases are between $0 . 4 \%$ and $8 . 4 \%$ (Table 4, right). One possible explanation for these moderate performance increases is the low co-occurrence in the considered data (Table 4, left). As it can be seen, typically less than $3 \%$ of all possible pairs show a cooccurrence. Moreover, the average co-occurrence count of such co-occurring pairs is very low, with ratios $\rho$ to the total number of instances $n$ in the order of $1 0 ^ { - 5 }$ or $1 0 ^ { - 6 }$ .
+
+Despite being moderate on average, we observed that the increments provided by CBE were more prominent for low dimensionality ratios $m / d$ . By relating CBE with the best approaches resulting from the comparison of BE with the alternatives, we see that CBE is generally better than BE, sometimes with a statistically significant difference (Table 5). Furthermore, we see that CBE, being based on co-occurrences, more closely approaches PMI and CCA in the tasks where those were performing best, and even outperforms them in one test point (AMZ, $m / d = 0 . 2$ ; compare also with Table 3). Being closer to those co-occurrence-based approaches is an indication that CBE leverages co-occurrence information to some extent.
+
+![](images/14749a2896d6bc9a270dbe84aba6be6f277480ee88a75cec28468e633cbf91bf.jpg)  
+Figure 4: Comparison of score ratios $S _ { i } / S _ { 0 }$ as a function of dimensionality ratio $m / d$ for BE (dashed lines) and CBE (solid lines) using $k \ = \ 4$ . Qualitatively similar plots are observed for other values of $k$ .
+
+Table 5: Comparison of CBE versus the results in Table 3. Score ratios $S _ { i } / S _ { 0 }$ for different combinations of data set and compression ratio $m / d$ . Best results are highlighted in bold, up to statistical significance (Mann-Whitney-U, $p { > } 0 . 0 5 )$ .   
+
+<table><tr><td colspan="2">Test point</td><td colspan="2">Best so far</td><td colspan="2">CBE</td></tr><tr><td>Data set</td><td>m/d</td><td>Method</td><td>Si/So</td><td>k=3</td><td>k=4</td></tr><tr><td>ML</td><td>0.2</td><td>BE</td><td>0.770</td><td>0.760</td><td>0.781</td></tr><tr><td>ML</td><td>0.3</td><td>BE</td><td>0.815</td><td>0.812</td><td>0.867</td></tr><tr><td>PTB</td><td>0.2</td><td>BE</td><td>0.919</td><td>0.915</td><td>0.907</td></tr><tr><td>PTB</td><td>0.4</td><td>BE</td><td>0.942</td><td>0.937</td><td>0.922</td></tr><tr><td>CADE</td><td>0.01</td><td>PMI</td><td>0.984</td><td>0.854</td><td>0.853</td></tr><tr><td>CADE</td><td>0.03</td><td>PMI</td><td>1.002</td><td>0.921</td><td>0.922</td></tr><tr><td>MSD</td><td>0.05</td><td>BE</td><td>0.738</td><td>0.759</td><td>0.756</td></tr><tr><td>MSD</td><td>0.1</td><td>BE</td><td>0.841</td><td>0.856</td><td>0.873</td></tr><tr><td>AMZ</td><td>0.1</td><td>CCA</td><td>1.030</td><td>0.994</td><td>0.991</td></tr><tr><td>AMZ</td><td>0.2</td><td>CCA</td><td>1.048</td><td>1.109</td><td>1.117</td></tr><tr><td>BC</td><td>0.05</td><td>BE</td><td>0.837</td><td>0.774</td><td>0.808</td></tr><tr><td>BC</td><td>0.1</td><td>BE</td><td>0.965</td><td>0.880</td><td>0.878</td></tr><tr><td>YC</td><td>0.03</td><td>BE</td><td>0.858</td><td>0.871</td><td>0.880</td></tr><tr><td>YC</td><td>0.05</td><td>BE</td><td>0.928</td><td>0.933</td><td>0.936</td></tr></table>

parse/train/rkKCdAdgx/rkKCdAdgx_content_list.json

@@ -0,0 +1,1273 @@
+[
+    {
+        "type": "text",
+        "text": "COMPACT EMBEDDING OF BINARY-CODED INPUTS AND OUTPUTS USING BLOOM FILTERS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            99,
+            820,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Joan Serra & Alexandros Karatzoglou\\`   \nTelefonica Research´   \nPl. Ernest Lluch i Mart´ın, 5   \nBarcelona, 08019, Spain   \nfirstname.lastname@telefonica.com ",
+        "bbox": [
+            184,
+            170,
+            509,
+            239
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            276,
+            544,
+            291
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The size of neural network models that deal with sparse inputs and outputs is often dominated by the dimensionality of those inputs and outputs. Large models with high-dimensional inputs and outputs are difficult to train due to the limited memory of graphical processing units, and difficult to deploy on mobile devices with limited hardware. To address these difficulties, we propose Bloom embeddings, a compression technique that can be applied to the input and output of neural network models dealing with sparse high-dimensional binary-coded instances. Bloom embeddings are computationally efficient, and do not seriously compromise the accuracy of the model up to 1/5 compression ratios. In some cases, they even improve over the original accuracy, with relative increases up to $12 \\%$ . We evaluate Bloom embeddings on 7 data sets and compare it against 4 alternative methods, obtaining favorable results. We also discuss a number of further advantages of Bloom embeddings, such as ‘on-the-fly’ constant-time operation, zero or marginal space requirements, training time speedups, or the fact that they do not require any change to the core model architecture or training configuration. ",
+        "bbox": [
+            233,
+            309,
+            764,
+            517
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            546,
+            336,
+            563
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The size of neural network models that deal with sparse inputs and outputs is often dominated by the dimensionality of such inputs and outputs. This is the case, for instance, with recommender systems, where high-dimensional sparse vectors, typically in the order from tens of thousands to hundreds of millions, constitute both the input and the output of the model (e.g., Wu et al., 2016; Hidasi et al., 2016; Cheng et al., 2016; Strub et al., 2016). This results in large models that present a number of difficulties, both at training and prediction stages. Apart from training and prediction times, an obvious bottleneck of such models is space: their size (and even performance) is hampered by the physical memory of graphical processing units (GPUs), and they are difficult to deploy on mobile devices with limited hardware (cf. Han et al., 2016). ",
+        "bbox": [
+            174,
+            579,
+            825,
+            704
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "One option to reduce the size of sparse inputs and outputs is to embed them into a lower-dimensional space. Embedding sparse high-dimensional inputs is commonplace (e.g., Bengio et al., 2000; Turian et al., 2010; Mikolov et al., 2013). However, embedding sparse high-dimensional outputs, or even inputs and outputs at the same time, is much less common (cf. Weston et al., 2002; Bengio et al., 2010; Akata et al., 2015). Importantly, typical embeddings still require the storage and processing of large matrices with the same dimensionality as the input/output (like the original neural network model would do). Thus, the gains in terms of space are limited. As mentioned, the size of such models is dominated by the input/output dimensionality, with input and output layers representing about $9 9 . 9 4 \\%$ of the total amount of weights of the model1. ",
+        "bbox": [
+            174,
+            712,
+            825,
+            837
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In general, an ideal embedding procedure for sparse high-dimensional inputs/outputs should produce compact embeddings, of much lower dimensionality than the original input/output. In addition, it should consume little space, both in terms of storage and memory space. Smaller sizes imply less parameters, thus training the model on embedded vectors would also be faster than with the original instances. The embedding of the output should also lead to a formulation for which the appropriate loss should be clear. Embeddings should not compromise the accuracy of the model nor the required number of training epochs to obtain that accuracy. In addition, no changes to the original core architecture of the model should be required to achieve good performance (obviously, input/output dimensions must change). The embedding should also be fast; if not to be done directly ‘on-the-fly’, at least fast enough so that speed improvements made during training are not lost in the embedding operation. Last, but not least, output embeddings should be easily reversible, so that the output of the model could be mapped to the original items at prediction time. ",
+        "bbox": [
+            176,
+            843,
+            823,
+            872
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            242
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we propose an unsupervised embedding technique that fulfills all the previous requirements. It can be applied to both input and output layers of neural network models that deal with binary (one-hot encoded) inputs and/or outputs. In addition, it produces lower-dimensionality binary embeddings that can be easily mapped to the original instances. Provided that the embedding dimension is not too low, the accuracy is not compromised. Furthermore, in some cases, we show that training with embedded vectors can even increase prediction accuracy. The embedding requires no changes to the core network structure nor to the model configuration, and works with a softmax output, the most common output activation for binary-coded instances. As it is unsupervised, the embedding does not require any preliminary training. Moreover, it is a constant-time operation that can be either performed on-the-fly, requiring no disk or memory space, or can be cached in memory, occupying orders of magnitude less space than a typical embedding matrix. Lower dimensionality of input/output vectors result in faster training, and the mapping from the embedded space to the original one does not add an overwhelming amount of time to the prediction stage. The proposed embedding is based on the idea of Bloom filters (Bloom, 1970), and therefore it inherits part of the theory developed around that idea (Blustein & El-Maazawi, 2002; Dillinger & Manolios, 2004; Mitzenmacher & Upfal, 2005; Bonomi et al., 2006). ",
+        "bbox": [
+            174,
+            250,
+            825,
+            472
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            503,
+            339,
+            518
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "A common approach to embed high-dimensional inputs is the hashing trick (Langford et al., 2007; Shi et al., 2009; Weinberger et al., 2009). However, the hashing trick approach does not deal with outputs, as it offers no explicit way to map back from the (dense) embedding space to the original space. A more elementary version of the hashing trick (Ganchev & Dredze, 2008) can be used at the outputs by considering it as a special case of the Bloom-based methodology proposed here. A framework providing both encoding and decoding strategies is the error-correcting output codes (ECOC) framework (Dietterich & Bakiri, 1995). Originally designed for single-class outputs, it can be also applied to class sets (Armano et al., 2012). The compressed sensing approach of Hsu et al. (2009) builds on top of ECOC to reduce multi-label regression to binary regression problems. Similarly, Cisse et al. (2013) use Bloom filters to reduce multi-label classification to binary classification ´ problems and improve the robustness of individual binary classifiers’ errors. Another example of a framework offering recovery capabilities is kernel dependency estimation (Weston et al., 2002). ",
+        "bbox": [
+            174,
+            541,
+            825,
+            708
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Data-dependent embeddings that require some form of learning also exist. A typical approach is to rely on variants of latent semantic analysis or singular value decomposition (SVD), exploiting similarities or correlations that may be present in the data. Again, the issue of mapping from the embedding space to the original space is left unresolved. Nonetheless, recently, Chollet (2016) has successfully applied a K-nearest neighbors (KNN) algorithm to perform such a mapping and to derive a ranking of the elements in the original space. An SVD decomposition of the pairwise mutual information matrix (PMI) is used to perform the embedding, and cosine similarity is used as loss function and to retrieve neighbors. Using the KNN trick offers the possibility to exploit different types of factorization of similarity-based matrices. Canonical correlation analysis is an example that considers both inputs and outputs at the same time (Hotelling, 1936). Other examples considering output embeddings are nuclear norm regularized learning (Amit et al., 2007), label embedding trees (Bengio et al., 2010), or the WSABIE algorithm (Weston et al., 2010). In the presence of side information, like text descriptions, element or class taxonomies, or manually-collected data, a range of approaches are applicable. Akata et al. (2015) provide a comprehensive list. In our study, we assume no side information is available and focus on input/output-based embeddings. ",
+        "bbox": [
+            174,
+            715,
+            825,
+            922
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "From a more general perspective, reducing the space of (or compressing) neural network models is an active research topic, driven by the need to deploy such models in systems with limited hardware resources. A common approach is to reduce the size of already trained models by some quantization and/or pruning of the connections in dense layers (Courbariaux et al., 2015; Han et al., 2016; Kim et al., 2016). A less frequently used approach is to reduce the model size before training (Chen et al., 2015). These methods typically do not focus on input layers and, to the best of our knowledge, none of them deals with high-dimensional outputs. It is also worth noting that a number of techniques have been proposed to efficiently deal with high-dimensional outputs, specially in the natural language processing domain. The hierarchical softmax approach (Morin & Bengio, 2005) or the more recent adaptive softmax (Grave et al., 2016) are two examples of those. Yet, as mentioned, the focus of these works is on speed, not on space. The work of Vincent et al. (2015) focuses on both aspects of very large sparse outputs but, to the best of our knowledge, cannot be applied to traditional softmax outputs. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            284
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 BLOOM EMBEDDINGS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            305,
+            387,
+            320
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 BLOOM FILTERS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            337,
+            326,
+            352
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Bloom filters (Bloom, 1970) are a compact probabilistic data structure that is used to represent sets of elements, and to efficiently check whether an element is a member of a set (Mitzenmacher & Upfal, 2005). Since the instances we deal with represent sets of one-hot encoded elements, Bloom filters are an interesting option to embed those in a compact space with good recovery (or checking) guarantees. ",
+        "bbox": [
+            174,
+            363,
+            825,
+            433
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In essence, Bloom filters project every element of a set to $k$ different positions of a binary array $\\mathbf { u }$ of size $m$ . Projections are done using a set of $k$ independent hash functions $\\mathsf { H } = \\left\\{ H _ { i } \\right\\} _ { i = 1 } ^ { k }$ , each of which with a range from 1 to $m$ , ideally distributing the projected elements uniformly at random (Mitzenmacher & Upfal, 2005). Proper independent hash functions can be derived using enhanced double hashing or triple hashing (Dillinger & Manolios, 2004). The number of hash functions $k$ is usually a constant, $k \\ll m$ , proportional to the expected number of elements to be projected. ",
+        "bbox": [
+            173,
+            440,
+            825,
+            540
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To check if an element is in $\\mathbf { u }$ , one feeds it to the $k$ hash functions $H$ to get $k$ array positions. If any of the bits at these positions is 0, then the element is definitely not in the set. Thus, element checks return no false negatives, meaning that the structure gives an answer with $100 \\%$ recall (Mitzenmacher & Upfal, 2005). However, if all $k$ bits at the projected positions are 1, then either the element is in the set, or the bits have by chance been set to 1 during the insertion of other set elements. This implies that false positives are possible, due to collisions between projections of different elements (Blustein & El-Maazawi, 2002). The values of $m$ and $k$ can be adjusted to control the probability of such collisions. However, in practice, $m$ is usually constrained by space requirements, and $k \\leq 1 0$ is employed, independent of the number of elements to be projected, and giving less than $1 \\%$ false positive probability (Bonomi et al., 2006). ",
+        "bbox": [
+            174,
+            546,
+            825,
+            686
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2 EMBEDDING AND RECOVERY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            704,
+            415,
+            718
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In the following, we describe the use of Bloom filter techniques in embedding binary highdimensional instances, and the recovery or mapping to such instances from these embeddings. We denote our approach as Bloom embedding (BE). The idea we pursue is to embed both inputs and outputs and to perform training in the embedding space. To do so, only a probability-based output activation is required, together with a loss function that is appropriate for such activations. ",
+        "bbox": [
+            174,
+            729,
+            825,
+            800
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Let $\\mathbf { X }$ be an input or output instance with dimensionality $d$ , such that $\\mathbf { x } = [ x _ { 1 } , \\dots x _ { d } ]$ , $x _ { i } \\in \\{ 0 , 1 \\}$ . Instances $\\mathbf { X }$ are assumed to be sparse, that is, $\\textstyle \\sum _ { i = 1 } ^ { d } x _ { i } \\ll d$ . Because of that, we can more conveniently (and compactly) represent $\\mathbf { X }$ as set $\\boldsymbol { z } = \\left\\{ \\boldsymbol { z } _ { i } \\right\\} _ { i = 1 } ^ { c }$ , $z _ { i } \\in \\mathbb { N } _ { \\leq d }$ , where $c$ is the number of non-zero elements and $z _ { i }$ is the position of such elements in $\\mathbf { X }$ . For every set $\\textsf { Z }$ , we generate an embedded instance $\\mathbf { u }$ of dimensionality $m < d$ , such that $\\mathbf { u } = [ u _ { 1 } , \\dots u _ { m } ]$ , $u _ { i } \\in \\{ 0 , 1 \\}$ . To do so, we first set all $m$ components of $\\mathbf { u }$ to 0. Then, iteratively, for every element $z _ { i }$ , $i = 1 , \\dots c$ , and every projection $H _ { j }$ , $j = 1 , \\dots k$ , we assign ",
+        "bbox": [
+            173,
+            806,
+            825,
+            909
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f6e1c71e52b04c0ff495723084fa6e42fbeec8b63295cca75234ba0692c8ceab.jpg",
+        "text": "$$\nu _ { H _ { j } ( z _ { i } ) } = 1 .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            455,
+            909,
+            542,
+            926
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Notice that, since $H _ { j }$ has a range between 1 and $m$ , $k \\geq 1$ , and $m < d$ , a number of $z _ { i }$ elements may map to the same index of $\\mathbf { u }$ . Bloom filters mitigate this by properly choosing $k$ independent hash functions $H$ (see above). Notice furthermore that the process has no space requirements, as $H$ is computed on-the-fly. Finally, notice that the embedding of a set $\\textsf { Z }$ is constant time: the process is $O ( c k )$ , with $c$ bounded by the maximum number of non-sparse elements in x, $c \\ll d$ , and $k$ being a constant that is set beforehand, $k \\ll m < d$ . In practice, this constant time is dominated by the time spent on $H$ to generate a hash. If we want to be faster than that, and at the same time ensure an optimal (uniform) distribution of the outputs of $H$ , we can decide to compromise part of the available memory to pre-compute a hash matrix storing the projections or hash indices for allthe potential elements in $\\textsf { Z }$ . We can do it by generating vectors $\\mathbf { h } \\overset { \\cdot } { = } \\left[ h _ { 1 } , \\ldots h _ { k } \\right]$ for each $z _ { i }$ , where $h _ { j }$ is a uniformly randomly chosen integer between 1 and $m$ (without replacement). This way, by pregenerating all projections for all $d$ elements, we end up with a $d \\times k$ matrix $\\mathbf { H }$ of integers between 1 and $m$ , which we can easily store in random-access memory (RAM), not in the GPU memory. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            284
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We now explain how to recover a probability-based ranking of the $d$ elements of $\\mathbf { X }$ at the output of the model. Assuming a softmax activation is used, we have a probability vector $\\mathbf { v } = [ v _ { 1 } , \\dots v _ { m } ]$ that, at training time, is compared to the binary embedding $\\mathbf { u }$ of some ground truth set $\\textsf { Z }$ (or vector $\\mathbf { x } )$ . We can think of $v _ { i }$ as the probability of being the projection of some element $z _ { l }$ , that is, $v _ { i } \\sim$ $P ( u _ { i } = 1 ) \\sim P ( H _ { j } ( z _ { l } ) = i )$ (see Eq. 1). To unravel the embedding $\\mathbf { v }$ and map to the $d$ original elements of $\\mathbf { X }$ , we can understand $\\mathbf { v }$ as a $k$ -way factorization of every element $x _ { i }$ . Following the idea of Bloom filters, if an element maps to $u _ { i }$ and $v _ { i } = 0$ , then the element is definitely not in the output of the model. Otherwise, if an element maps to $u _ { i }$ and $v _ { i }$ is relatively large, we want the likelihood of that element to reflect that. Specifically, given an element position $z _ { i }$ from $\\mathbf { X }$ , we can compute the likelihood of $z _ { i }$ as ",
+        "bbox": [
+            173,
+            290,
+            825,
+            429
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/53c8dd291cb7863d699e759b455453b87e69d56530b7b29e99673e843c08af36.jpg",
+        "text": "$$\n{ \\cal L } ( z _ { i } ) = \\prod _ { j = 1 } ^ { k } v _ { H _ { j } ( z _ { i } ) } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            429,
+            429,
+            566,
+            474
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "and assign outputs $x _ { i } = L ( z _ { i } )$ . Alternatively, if a more numerically-stable output is desired, we can compute the negative log-likelihood ",
+        "bbox": [
+            173,
+            479,
+            823,
+            508
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7fd8879ede1eae04830eb42f1f8796250d4dedfd0ab1763161643df4e70ef2b6.jpg",
+        "text": "$$\nL ( z _ { i } ) = - \\sum _ { j = 1 } ^ { k } \\log \\left( v _ { H _ { j } ( z _ { i } ) } \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            400,
+            517,
+            598,
+            563
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Both operations, when iterated for $i = 1 , \\ldots d$ , define a ranking over the elements in $\\mathbf { X }$ , which is the most common way to define (and evaluate) sparse high-dimensional outputs. One could potentially also recover a probability distribution by re-normalization, but the problems we consider are information retrieval-type of problems (Manning et al., 2008), which are typically seen as ranking problems, such as ranking recommendations based on user preferences (Weimer et al., 2008). ",
+        "bbox": [
+            174,
+            570,
+            825,
+            640
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Note that BE, by construction, already offers a number of the aforementioned desired qualities for sparse high-dimensional embeddings (Sec. 1). Specifically, BE is designed for both inputs and outputs, offering a rank-based mapping between the original instances and the embedded vectors. BE yields a more compact representation of the original instance and requires no disk or memory space (at most some marginal RAM space, not GPU memory). In addition, BE can be performed on-the-fly, without training, and in constant time. In the following, we demonstrate the remaining desirable qualities using a comprehensive experimental setup: we show that the accuracy of the model is not compromised given a reasonable embedding dimension (sometimes it even improves), that no changes in the model architecture nor configuration are required, that training times are faster thanks to the reduction of the number of parameters of the model, that evaluation times do not carry much overhead, and that performance is generally better than a number of alternative approaches. ",
+        "bbox": [
+            174,
+            647,
+            825,
+            800
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTAL SETUP ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            823,
+            397,
+            838
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.1 GENERAL CONSIDERATIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            854,
+            410,
+            869
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We demonstrate that BE works under several settings and that it can be applied to multiple tasks. We consider a number of data sets, network architectures, configurations, and evaluation measures. In total, we define 7 different setups, which we summarize in Sec. 4.2 and detail in Appendix A. We also demonstrate that BE is competitive with respect to the available alternatives. To this end, we consider 4 different state-of-the-art approaches, which we overview in Sec. 4.3. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/0edd165e2fa9549343e8f02320e4e8cb441bdf7c42d453e097bcd68144501c1e.jpg",
+        "table_caption": [
+            "Table 1: Data set statistics after data cleaning and splitting. From left to right: data set name, type of modeled interaction, number of instances $n$ , test split size, instance dimensionality $d$ , median number of non-zero components $c$ , and median density $c / d$ . "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Data set</td><td>Interaction</td><td>n</td><td>Split</td><td>d</td><td>C</td><td>c/d</td></tr><tr><td>ML</td><td>User-Movies</td><td>138,224</td><td>10,000</td><td>15,405</td><td>18</td><td>1.2·10-3</td></tr><tr><td>PTB</td><td>Sequence-Words</td><td>929,589</td><td>82,430</td><td>10,001</td><td>1</td><td>1.0 · 10-4</td></tr><tr><td>CADE</td><td>Words-Category</td><td>40,983</td><td>13,661</td><td>193,998</td><td>17</td><td>8.8.10-5</td></tr><tr><td>MSD</td><td>User-Songs</td><td>597,155</td><td>50,000</td><td>69,989</td><td>5</td><td>7.1 · 10-5</td></tr><tr><td>AMZ</td><td>User-Books</td><td>916,484</td><td>50,000</td><td>22,561</td><td>1</td><td>4.4 · 10-5</td></tr><tr><td>BC</td><td>User-Books</td><td>25,816</td><td>2,500</td><td>54,069</td><td>2</td><td>3.7 ·10-5</td></tr><tr><td>YC</td><td>Session-Clicks</td><td>1,865,997</td><td>50,000</td><td>35,732</td><td>1</td><td>2.8.10-5</td></tr></table>",
+        "bbox": [
+            187,
+            161,
+            808,
+            284
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/3dcc5e4d303c1f1445b81427dbff1f56e8b56ab74ba2d4fd767fb597a681b412.jpg",
+        "table_caption": [
+            "Table 2: Experimental setup and baseline scores. From left to right: data set name, network architecture and optimizer, evaluation measure name, random score $S _ { \\mathrm { R } }$ , and baseline score $S _ { 0 }$ . "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Data set</td><td>Architecture+Optimizer</td><td>Evaluation measure</td><td>SR</td><td>S</td></tr><tr><td>ML</td><td>Feed-forward+Adam</td><td>Mean average precision</td><td>0.003</td><td>0.160</td></tr><tr><td>PTB</td><td>LSTM + SGD</td><td>Reciprocal rank</td><td>0.001</td><td>0.342</td></tr><tr><td>CADE</td><td>Feed-forward +RMSprop</td><td>Accuracy (%)</td><td>8.5</td><td>58.0</td></tr><tr><td>MSD</td><td>Feed-forward + Adam</td><td>Mean average precision</td><td>&lt;0.001</td><td>0.066</td></tr><tr><td>AMZ</td><td>Feed-forward + Adam</td><td>Mean average precision</td><td>&lt;0.001</td><td>0.049</td></tr><tr><td>BC</td><td>Feed-forward+ Adam</td><td>Mean average precision</td><td>&lt;0.001</td><td>0.010</td></tr><tr><td>YC</td><td>GRU + Adagrad</td><td>Reciprocal rank</td><td>&lt;0.001</td><td>0.368</td></tr></table>",
+        "bbox": [
+            183,
+            352,
+            815,
+            470
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            506,
+            823,
+            534
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Data sets are formed by inputs with $n$ instances, corresponding to either individual instances (or onehot encoded user profiles) or to sequences of instances (or profile lists). Outputs, also of $n$ instances, correspond to individual instances or to class labels. Instances have an original dimensionality $d$ , corresponding to the cardinality of all possible profile items. Given the nature of the considered problems, instances are very sparse, with all but $c$ elements being different from 0, $c \\ll d$ , typically with $c / d$ in the order of $1 0 ^ { - 5 }$ (Table 1). ",
+        "bbox": [
+            174,
+            541,
+            825,
+            625
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For each data set, and based on the literature, we select an appropriate baseline neural network architecture. We experiment with both feed-forward (autoencoder-like) and recurrent networks, carefully selecting their parameters and configuration to match (or even improve) the state-of-theart results. For the sake of comparison, we also choose appropriate and well-known evaluation measures. Depending on the data set, we work with mean average precision, reciprocal ranks, or accuracy (Manning et al., 2008). ",
+        "bbox": [
+            174,
+            632,
+            825,
+            715
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Each combination of data set, network architecture, configuration, and evaluation measure defines a task. For every task, we compute a baseline score $S _ { 0 }$ , corresponding to running the plain neural network model without any embedding. We then report the performance of the $i \\cdot$ -th combination of training with a particular embedding on a particular task with respect to the baseline score using $S _ { i } / S _ { 0 }$ . This way, we can compare the performance across different tasks using different evaluation measures, reporting relative improvement/loss with respect to the baseline. Similarly, to compare across different dimensionalities, we report the ratio of embedding dimensionality with respect to the original dimensionality, $m / d$ , and to compare across different training and evaluation times, we report time ratios with respect to the baseline, $T _ { i } / T _ { 0 }$ . ",
+        "bbox": [
+            173,
+            722,
+            825,
+            848
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.2 TASKS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            868,
+            261,
+            882
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We now give a brief summary of the 7 considered tasks (Tables 1 and 2). For a more detailed explanation related to data, network architecture, configuration, or evaluation methodology, we refer the reader to Appendix A. Further references can be also found there. All data sets are publiclyavailable, and for all tasks we use categorical cross-entropy as loss function. ",
+        "bbox": [
+            176,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            821,
+            132
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "1. Movielens (ML): movie recommendation with the Movielens data set (Harper & Konstan, 2015). We employ a 3-layer feed-forward neural network model and optimize its parameters with Adam. We evaluate the accuracy of the model with mean average precision.   \n2. Penn treebank (PTB): next word prediction with the Penn treebank data set (Mikolov, 2012). We employ a long short-term memory (LSTM) network and optimize its parameters with stochastic gradient descent (SGD). We evaluate the accuracy of the model with the reciprocal rank of the correct prediction.   \n3. CADE web directory (CADE): text categorization with the CADE web directory data set (Cardoso-Cachopo, 2007). We employ a 4-layer feed-forward neural network model and optimize its parameters with RMSprop. This is the only considered task where output embeddings are not required (classification into 12 text categories). We use accuracy as evaluation measure.   \n4. Million song data set (MSD): song recommendation with the Million song data set (BertinMahieux et al., 2011). We employ a 3-layer feed-forward neural network model and optimize its parameters with Adam. We evaluate the accuracy of the model with mean average precision.   \n5. Amazon book reviews (AMZ): book recommendation with the Amazon book reviews data set (McAuley et al., 2015). We employ a 4-layer feed-forward neural network and optimize its parameters with Adam. We evaluate the accuracy of the model with mean average precision.   \n6. Book crossing (BC): book recommendation with the book crossing data set (Ziegler et al., 2005). We employ a 4-layer feed-forward neural network and optimize its parameters with Adam. We evaluate the accuracy of the model with mean average precision.   \n7. YooChoose (YC): session-based recommendation with the YooChoose RecSys15 challenge data set2. We employ a gated recurrent unit (GRU) model and optimize its parameters with Adagrad. We evaluate the accuracy of the model with the reciprocal rank. ",
+        "bbox": [
+            210,
+            143,
+            825,
+            540
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.3 ALTERNATIVE APPROACHES",
+        "text_level": 1,
+        "bbox": [
+            176,
+            556,
+            408,
+            570
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To compare the performance of BE with the state-of-the-art, we consider 4 different embedding alternatives. We base our evaluation on performance, measured at a given input/output compression ratio. It is important to note that, in general, besides performance, alternative approaches do not present some of the other desired qualities (Sec. 1) that BE offers, such as on-the-fly operation, constant-time, no supervision, or no network/configuration changes. ",
+        "bbox": [
+            176,
+            582,
+            825,
+            652
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "1. Hashing trick (HT). We first consider the popular hashing trick for classifier inputs (Langford et al., 2007; Weinberger et al., 2009). In general, these methodologies only focus on inputs and are not designed to deal with any type of output. Nonetheless, in the case of binary outputs, variants like the one used by Ganchev & Dredze (2008) can be adapted to map to the original items using Eqs. 2 or 3. In fact, considering this adaptation for recovery, the approach can be seen as a special case of BE with $k = 1$ .   \n2. Error-correcting output codes (ECOC). Originally designed for single-class targets (Dietterich & Bakiri, 1995), ECOC can be applied to class sets (inputs and outputs), with its corresponding encoding and decoding strategies (Armano et al., 2012). Yet, in the case of training neural networks, it is not clear which loss function should be used. The obvious choice would be to use the Hamming distance. However, in pre-analysis, a Hamming loss turned out to be significantly inferior than cross-entropy. Therefore, we use the latter in our experiments. We construct the ECOC matrix with the randomized hill-climbing method of Dietterich & Bakiri (1995).   \n3. Pairwise mutual information (PMI). Recently, Chollet (2016) has proposed a PMI approach for embedding sets of image labels into a dense space of real-valued vectors. The approach ",
+        "bbox": [
+            210,
+            665,
+            825,
+            898
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/69b3e2c9cc876902ae2c5290ff03553ca983eb4bd21689aebcf62363df8a817c.jpg",
+        "image_caption": [
+            "Figure 1: Score ratios $S _ { i } / S _ { 0 }$ as a function of dimensionality ratio $m / d$ using $k = 4$ . Qualitatively similar plots are observed for other values of $k$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            192,
+            101,
+            805,
+            372
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "is based on the SVD of a PMI matrix computed from counting pairwise co-occurrences. It uses cosine similarity as the loss function and, at prediction time, it performs KNN (again using cosine similarity) with the projection of individual labels to obtain a ranking. ",
+        "bbox": [
+            228,
+            448,
+            823,
+            489
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4. Canonical correlation analysis (CCA). CCA is a common way to learn a joint dense, realvalued embedding for both inputs and outputs at the same time (Hotelling, 1936). CCA can be computed using SVD on a correlation matrix (Hsu et al., 2012) and, similarly to PMI, we can use the KNN trick to rank elements or labels at prediction time. Correlation is now the metric of choice, both for the loss function and for determining the neighbors. ",
+        "bbox": [
+            214,
+            494,
+            823,
+            564
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5 RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            583,
+            281,
+            599
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We start by reporting on the performance of BE. First of all, we focus on performance as a function of the embedding dimension. As mentioned, to facilitate comparisons, we report in relative terms, using score ratios $S _ { i } / S _ { 0 }$ and dimensionality ratios $m / d$ . When plotting the former as a function of the latter, we see several things that are worth noting (Fig. 1). Firstly, we observe that, for most of the tasks, score ratios approach 1 as $m$ approaches $d$ . This indicates that the introduction of BE does not degrade the original score of the Baseline when the embedding dimension $m$ is comparable to the original dimension $d$ . Secondly, we observe that the lower the dimensionality ratio, the lower the score ratio. This is to be expected, as one cannot embed sets of elements with their intrinsic dimensionality to an infinitesimally small $m$ . Importantly, the reduction of $S _ { i } / S _ { 0 }$ should not be linear with $m / d$ , but should maximize $S _ { i }$ for low $m$ (thus getting curves close to the top left corner of Fig. 1). We see that BE fulfills this requirement. In general, we can reduce the size of inputs and outputs 5 times $( m / d = 0 . 2 )$ and still maintain more than $92 \\%$ of the value of the original score. The ML task is the only exception, which we think is due to the abnormally high density of the data (Table 1), inhibiting the embedding to low dimensions3. CADE is the task for which BE achieves the highest $S _ { i }$ for low $m$ . Presumably, the CADE task is the easiest one we consider, as only input embeddings are required. ",
+        "bbox": [
+            173,
+            614,
+            825,
+            837
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "An additional observation is worth noting (Fig. 1). Interestingly, we find that BE can improve the scores over the Baseline for a number of tasks. That is the case for 3 out of the 7 considered tasks: MSD with $m / d \\geq 0 . 3$ , AMZ with $m / d \\geq 0 . 2$ , and BC with $0 . 3 \\leq m / d \\leq 0 . 6$ . The fact that an embedding performs better than the original Baseline has been also observed in some other methods for specific data sets (Weston et al., 2002; Langford et al., 2007; Chollet, 2016). For instance, Chollet (2016) has reported increases up to $7 \\%$ using the PMI approach on the so-called JFT data set. Here, depending on the task and the embedding dimension, relative increases go from 1 to $12 \\%$ . Given that the data sets where we observe these increases are some of the less dense ones (Table 1), we hypothesize that, in the case of BE, such increases come from having $k$ times more active elements in the ground truth output (recall that one output element is projected $k$ times using $k$ independent hash functions, Sec. 3.2). With $k$ more times elements set to 1 in the output, a better estimation of the gradient may be computed (larger errors that propagate back to the rest of the network). ",
+        "bbox": [
+            174,
+            844,
+            823,
+            901
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/dcaa89d64ff3aec9c6f9fd1aa57c541c4e4d81898229948fb589391315f6e304.jpg",
+        "image_caption": [
+            "Figure 2: Score ratios $S _ { i } / S _ { 0 }$ as a function of the number of hash functions $k$ : using $m / d = 0 . 3$ (left) and $m / d = 1$ (right). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            189,
+            99,
+            825,
+            301
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            387,
+            825,
+            500
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We now focus on performance as a function of the number of projections $k$ , reporting score ratios $S _ { i } / S _ { 0 }$ as above (Fig. 2). From repeating the plots for different values of $m / d$ , we observe that $S _ { i } / S _ { 0 }$ is always low for $k = 1$ (Fig. 2, left), except when $m$ approaches $d$ , where we have an almost flat behavior (Fig. 2, right). In general, $S _ { i } / S _ { 0 }$ jumps up for $k \\geq 2$ and remains stable until $k \\approx 1 0$ , where the decrease of $S _ { i } / S _ { 0 }$ becomes more apparent (Fig. 2, left). The best operating range typically corresponds to $2 \\leq k \\leq 4$ . The ML task is again an exception, with a best operating range around $7 \\leq k \\leq 1 0$ . ",
+        "bbox": [
+            174,
+            507,
+            825,
+            604
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Besides performance scores, it is interesting to assess whether the reduction of input and output dimensions has an effect to training and evaluation times. To this end, we plot the time ratios $T _ { i } / T _ { 0 }$ as a function of the dimensionality ratio $m / d$ (Fig. 3). Regarding training times, we basically observe a linear decrease with $m / d$ (Fig. 3, left). ML is an exception to the trend, and CADE and AMZ experiment almost no decrease for very low dimensionality ratios $m / d < 0 . 2$ . In general, we confirm faster training times thanks to the reduction of the number of parameters of the model, dominated by input/output matrices (output dimension also affecting the time to compute the loss function). We obtain a 2 times speedup for a 2 times input/output compression and, roughly, a little bit over 3 times speedup for a 5 times input/output compression. Regarding evaluation times, we also observe a linear trend (Fig. 3, right). However, this time, $T _ { i } / T _ { 0 }$ is not as low, with values slightly above 1 but always below 1.5 (with the exception of CADE for $m / d > 0 . 6 )$ . Overall, this indicates that, compared to the Baseline evaluation time, the mapping used by BE when reconstructing the output does not introduce an overwhelming amount of extra computation time. With the exception of ML, extra computation time is below $20 \\%$ for $m / d < 0 . 5$ . ",
+        "bbox": [
+            173,
+            611,
+            825,
+            805
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Finally, we compare the performance of BE to the one of the considered alternative methods. We do so by establishing a dimensionality ratio $m / d$ and computing the corresponding score ratio $S _ { i } / S _ { 0 }$ for a given task (Table 3). We see that BE is better than the alternative methods in 5 out of the 7 tasks (10 out of the 14 considered test points). PMI is better in one of the tasks (CADE) and CCA is better also in one of the tasks (AMZ). It is relevant to note that, when BE wins, it always does so by a relatively large margin (see, for instance, the ML or YC tasks). Otherwise, when an alternative approach wins, generally it does so by a smaller margin (see, for instance, the AMZ task). These results become more relevant if we realize that PMI and CCA are both SVD-based approaches, introducing a separate degree of supervised learning to the task by exploiting pairwise element co-occurrences and correlations, respectively (Sec. 4.3). In contrast, BE does not require any learning. We formulate a co-occurrence-based version of BE in Appendix B, which achieves moderate performance increments over BE and more closely approaches the performance of PMI and CCA on the two tasks where BE was not already performing best. To conclude, a further interesting thing to note is that we confirm the small variation in the score ratios obtained for $2 \\leq$ $k \\leq 1 0$ (Fig. 2). Here, score ratios for $3 \\le k \\le 5$ are often comparable in a statistical significance sense (Table 3). ",
+        "bbox": [
+            174,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/cdbcfbb1797bd12ec7387eaf7599dd21717764c40239d19a03ef0ac3680efbd3.jpg",
+        "image_caption": [
+            "Figure 3: Time ratios $T _ { i } / T _ { 0 }$ as a function of dimensionality ratios $m / d$ with $k = 4$ : training time (left) and evaluation time (right). Qualitatively similar plots are observed for other values of $k$ . Bl. denotes baseline. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            189,
+            99,
+            820,
+            361
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/53f6fe9af1de0811be80eb8be85581dfaef1d17e7940086c4a2bbe0a7a929d15.jpg",
+        "table_caption": [
+            "Table 3: Comparison of BE with the considered alternatives. Score ratios $S _ { i } / S _ { 0 }$ for different combinations of data set and compression ratio $m / d$ . Best results are highlighted in bold, up to statistical significance (Mann-Whitney U, $p { > } 0 . 0 5 ) ,$ ). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"2\">Test point</td><td colspan=\"4\">Alternativemethods</td><td colspan=\"3\">BE</td></tr><tr><td>Data set</td><td>m/d</td><td>HT</td><td>ECOC</td><td>PMI</td><td>CCA</td><td>k=3</td><td>k=4</td><td>k=5</td></tr><tr><td>ML</td><td>0.2</td><td>0.234</td><td>0.342</td><td>0.043</td><td>0.209</td><td>0.750</td><td>0.770</td><td>0.722</td></tr><tr><td>ML</td><td>0.3</td><td>0.285</td><td>0.208</td><td>0.045</td><td>0.200</td><td>0.796</td><td>0.813</td><td>0.815</td></tr><tr><td>PTB</td><td>0.2</td><td>0.357</td><td>0.453</td><td>0.837</td><td>0.638</td><td>0.919</td><td>0.908</td><td>0.881</td></tr><tr><td>PTB</td><td>0.4</td><td>0.528</td><td>0.454</td><td>0.836</td><td>0.695</td><td>0.942</td><td>0.920</td><td>0.902</td></tr><tr><td>CADE</td><td>0.01</td><td>0.857</td><td>0.359</td><td>0.984</td><td>0.928</td><td>0.862</td><td>0.853</td><td>0.855</td></tr><tr><td>CADE</td><td>0.03</td><td>0.914</td><td>0.363</td><td>1.002</td><td>0.950</td><td>0.914</td><td>0.925</td><td>0.926</td></tr><tr><td>MSD</td><td>0.05</td><td>0.078</td><td>0.268</td><td>0.216</td><td>0.679</td><td>0.695</td><td>0.738</td><td>0.738</td></tr><tr><td>MSD</td><td>0.1</td><td>0.151</td><td>0.310</td><td>0.321</td><td>0.740</td><td>0.835</td><td>0.841</td><td>0.832</td></tr><tr><td>AMZ</td><td>0.1</td><td>0.166</td><td>0.182</td><td>0.851</td><td>1.030</td><td>0.864</td><td>0.881</td><td>0.861</td></tr><tr><td>AMZ</td><td>0.2</td><td>0.289</td><td>0.185</td><td>0.995</td><td>1.048</td><td>1.016</td><td>1.029</td><td>1.008</td></tr><tr><td>BC</td><td>0.05</td><td>0.189</td><td>0.817</td><td>0.022</td><td>0.313</td><td>0.777</td><td>0.750</td><td>0.837</td></tr><tr><td>BC</td><td>0.1</td><td>0.199</td><td>0.886</td><td>0.025</td><td>0.465</td><td>0.965</td><td>0.919</td><td>0.831</td></tr><tr><td>YC</td><td>0.03</td><td>0.150</td><td>0.076</td><td>0.776</td><td>0.466</td><td>0.841</td><td>0.858</td><td>0.858</td></tr><tr><td>YC</td><td>0.05</td><td>0.240</td><td>0.083</td><td>0.777</td><td>0.517</td><td>0.919</td><td>0.910</td><td>0.928</td></tr></table>",
+        "bbox": [
+            173,
+            523,
+            825,
+            752
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            318,
+            117
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We have proposed the use of Bloom embeddings to represent sparse high-dimensional binary-coded inputs and outputs. We have shown that a compact representation can be obtained without compromising the performance of the original neural network model or, in some cases, even increasing it by a substantial factor. Due to the compact representation, the loss function and the input and output layers deal with less parameters, which results in faster training times. The approach compares favorably with respect to the considered alternatives, and offers a number of further advantages such as on-the-fly operation or zero space requirements, all this without introducing changes to the core network architecture, task configuration, or loss function. ",
+        "bbox": [
+            174,
+            133,
+            825,
+            244
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In the future, besides continuing to exploit co-occurrences (Appendix B), one could extend the proposed approach by considering further extensions of Bloom filters such as counting Bloom filters (Bonomi et al., 2006). In theory, those extensions could provide a more compact representation by breaking the binary nature of the embedding. However, they could require the modification of the loss function or the mapping process (Eqs. 2 and 3). A faster mapping process using the sorted probabilities of v could also be studied. ",
+        "bbox": [
+            174,
+            252,
+            825,
+            335
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            357,
+            356,
+            372
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We thank the curators of the data sets used in this study for making them publicly-available. We also thank Santi Pascual for his comments on a previous version of the paper. ",
+        "bbox": [
+            173,
+            387,
+            823,
+            416
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            438,
+            285,
+            452
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Z. Akata, F. Perronnin, Z. Harchaoui, and C. Schmid. Label-embedding for image classification. IEEE Trans. on Pattern Analysis and Machine Intelligence, 38(7):1425–1438, 2015.   \nY. Amit, M. Fink, N. Srebro, and S. Ullman. Uncovering shared structures in multiclass classification. In Proc. of the Int. Conf. on Machine Learning (ICML), pp. 17–24, 2007.   \nG. Armano, C. Chira, and N. Hatami. Error-correcting output codes for multi-label text categorization. In Proc. of the Italian Information Retrieval Conf. (IIR), pp. 26–37, 2012.   \nS. Bengio, J. Weston, and D. Grangier. Label embedding trees for large multi-class tasks. In Advances in Neural Information Processing Systems (NIPS), volume 23, pp. 163–171. 2010.   \nY. Bengio, R. Ducharme, and P. Vincent. A neural probabilistic language model. In T. K. Leen, T. G. Dietterich, and V. Tresp (eds.), Advances in Neural Information Processing Systems (NIPS), volume 13, pp. 932–938. 2000.   \nT. Bertin-Mahieux, D. P. W. Ellis, B. Whitman, and P. Lamere. The million song dataset. In Proc. of the Int. Soc. for Music Information Retrieval Conf. (ISMIR), pp. 591–596, 2011.   \nB. H. Bloom. Space/time trade-offs in hash coding with allowable errors. Communications of the ACM, 13(7):422–426, 1970.   \nJ. Blustein and A. El-Maazawi. Bloom filters – a tutorial, analysis, and survey. Technical report, Faculty of Computer Science, Dalhousie University, Halifax, Canada, 2002. URL https:// www.cs.dal.ca/research/techreports/cs-2002-10.   \nF. Bonomi, M. Mitzenmacher, R. Panigrahy, S. Singh, and G. Varghese. An improved construction for counting Bloom filters. In Y. Azar and T. Erlebach (eds.), European Symposium on Algorithms (ESA), volume 4168 of Lecture Notes in Computer Science, pp. 684–695. Springer-Verlag, Berlin, Germany, 2006.   \nA. Cardoso-Cachopo. Improving methods for single-label text categorization. PhD thesis, Instituto Superior Tecnico, Universidade Tecnica de Lisboa, 2007.   \nW. Chen, J. Wilson, S. Tyree, K. Weinberger, and Y. Chen. Compressing neural networks with the hashing trick. In Proc. of the Int. Conf. on Machine Learning (ICML), pp. 2285–2294, 2015.   \nH.-T. Cheng, L. Koc, J. Harmsen, T. Shaked, T. Chandra, H. Aradhye, G. Anderson, G. Corrado, W. Chai, M. Ispir, R. Anil, Z. Haque, L. Hong, V. Jain, X. Liu, and H. Shah. Wide & deep learning for recommender systems. In Proc. of the Workshop on Deep Learning for Recommender Systems (DLRS), pp. 7–10, 2016.   \nK. Cho, B. Van Merrienboer, D. Bahdanau, and Y. Bengio. On the properties of neural machine ¨ translation: encoder-decoder approaches. In Proc. of the Workshop on Syntax, Semantics and Structure in Statistical Translation (SSST), pp. 103–111, 2014.   \nF. Chollet. Information-theoretic label embeddings for large-scale image classification. ArXiv: 1607.05691, 2016.   \nM. Cisse, N. Usunier, T. Arti ´ eres, and P. Gallinari. Robust Bloom filters for large multilabel clas- \\` sification tasks. In Advances in Neural Information Processing Systems (NIPS), pp. 1851–1859. 2013.   \nM. Courbariaux, Y. Bengio, and J.-P. David. BinaryConnect: training deep neural networks with binary weights during propagations. In C. Cortes, N. D. Lawrence, D. D. Lee, M. Sugiyama, and R. Garnett (eds.), Advances in Neural Information Processing Systems (NIPS), pp. 3123–3131. 2015.   \nT. G. Dietterich and G. Bakiri. Solving multiclass learning problems via error-correcting output codes. Journal of Artificial Intelligence Research, 2:263–286, 1995.   \nP. C. Dillinger and P. Manolios. Bloom filters in probabilistic verification. In Proc. of the Int. Conf. on Formal Methods in Computer-Aided Design (FMCAD), pp. 367–381, 2004.   \nJ. Duchi, E. Hazan, and Y. Singer. Adaptive subgradient methods for online learning and stochastic optimization. Journal of Machine Learning Research, 12:2121–2159, 2011.   \nK. Ganchev and M. Dredze. Small statistical models by random feature mixing. In ACL Workshop on Mobile Language Processing (MLP), pp. 19–20, 2008.   \nX. Glorot and Y. Bengio. Understanding the difficulty of training deep feedforward neural networks. In Proc. of the Int. Conf. on Artificial Intelligence and Statistics (AISTATS), pp. 249–256, 2010.   \nX. Glorot, A. Bordes, and Y. Bengio. Deep sparse rectifier neural networks. In Proc. of the Int. Conf. on Artificial Intelligence and Statistics (AISTATS), pp. 315–323, 2011.   \nE. Grave, A. Joulin, M. Cisse, D. Grangier, and H. J ´ egou. Efficient softmax approximation for ´ GPUs. ArXiv: 1609.04309, 2016.   \nA. Graves. Generating sequences with recurrent neural networks. ArXiv: 1308.0850, 2013.   \nS. Han, H. Mao, and W. J. Dally. Deep compression: compressing deep neural networks with pruning, trained quantization and Huffman coding. In Proc. of the Int. Conf. on Learning Representations (ICLR), 2016.   \nF. M. Harper and J. K. Konstan. The MovieLens datasets: history and context. ACM Trans. on Interactive Intelligent Systems, 5(4):19, 2015.   \nB. Hidasi, A. Karatzoglou, L. Baltrunas, and D. Tikk. Session-based recommendations with recurrent neural networks. In Proc. of the Int. Conf. on Learning Representations (ICLR), 2016. URL https://arxiv.org/abs/1511.06939.   \nS. Hochreiter and J. Schmidhuber. Long short-term memory networks. Neural Computation, 9(8): 1735–1780, 1997.   \nH. Hotelling. Relations between two sets of variates. Biometrika, 28(3-4):321–377, 1936.   \nD. Hsu, S. M. Kakade, and T. Zhang. A spectral algorithm for learning hidden Markov models. Journal of Computer and System Sciences, 78(5):1460–1470, 2012.   \nD. J. Hsu, S. M. Kakade, J. Langford, and T. Zhang. Multi-label prediction via compressed sensing. In Y. Bengio, D. Schuurmans, J. D. Lafferty, C. K. I. Williams, and A. Culotta (eds.), Advances in Neural Information Processing Systems (NIPS), volume 22, pp. 772–780. 2009.   \nY.-D. Kim, E. Park, S. Yoo, T. Choi, L. Yang, and D. Shin. Compression of deep convolutional neural networks for fast and low power mobile applications. In Proc. of the Int. Conf. on Learning Representations (ICLR), 2016. URL https://arxiv.org/abs/1511.06530.   \nD. P. Kingma and J. L. Ba. Adam: a method for stochastic optimization. In Proc. of the Int. Conf. on Learning Representations (ICLR), 2015. URL https://arxiv.org/abs/1412.6980.   \nJ. Langford, L. Li, and A. Strehl. Vowpal wabbit online learning project. Technical report, 2007. URL http://hunch.net/ $? { \\mathrm { p } } = 3 0 9$ .   \nC. D. Manning, P. Raghavan, and H. Schutze. ¨ Introduction to information retrieval. Cambridge University Press, Cambridge, UK, 2008.   \nM. P. Marcus, B. Santorini, and M. A. Marcinkiewich. Building a large annotated corpus of English: the Penn treebank. Computational Linguisitcs, 19(2):313–330, 1993.   \nJ. McAuley, R. Pandey, and J. Leskovec. Inferring networks of substitutable and complementary products. In Proc. of the ACM SIGKDD Int. Conf. on Knowledge Discovery and Data Mining (KDD), pp. 785–794, 2015.   \nT. Mikolov. Statistical language models based on neural networks. PhD thesis, Brno University of Technology, 2012.   \nT. Mikolov, K. Chen, G. S. Corrado, and J. Dean. Efficient estimation of word representations in vector space. ArXiv: 1301.3781, 2013.   \nM. Mitzenmacher and E. Upfal. Probability and computing: randomized algorithms and probabilistic analysis. Cambridge University Press, Cambridge, UK, 2005.   \nF. Morin and Y. Bengio. Hierarchical probabilistic neural network language model. In Proc. of the Int. Workshop on Artificial Intelligence and Statistics (AISTATS), pp. 246–252, 2005.   \nQ. Shi, J. Petterson, G. Dror, J. Langford, A. Smola, and S. V. N. Vishwanathan. Hash kernels for structured data. Journal of Machine Learning Research, 10:2615–2637, 2009.   \nF. Strub, R. Gaudel, and J. Mary. Hybrid recommender system based on autoencoders. In Proc. of the Workshop on Deep Learning for Recommender Systems (DLRS), pp. 11–16, 2016.   \nT. Tieleman and G. Hinton. Lecture 6.5-RMSprop: divide the gradient by a running average of its recent magnitude. COURSERA: Neural Networks for Machine Learning 4, 2, 2012.   \nJ. Turian, L. Ratinov, and Y. Bengio. Word representations: a simple and general method for semisupervised learning. In Proc. of the Annual Meeting of the Association for Computational Linguistics (ACL), pp. 384–394, 2010.   \nP. Vincent, A. Brebisson, and X. Bouthilier. Efficient exact gradient update for training deep net- ´ works with very large sparse targets. In Advances in Neural Information Processing Systems (NIPS), pp. 1108–1116. 2015.   \nM. Weimer, A. Karatzoglou, Q. V. Le, and A. J. Smola. COFI RANK - maximum margin matrix factorization for collaborative ranking. In J. C. Platt, D. Koller, Y. Singer, and S. T. Roweis (eds.), Advances in Neural Information Processing Systems (NIPS), volume 20, pp. 1593–1600. 2008.   \nK. Weinberger, A. Dasgupta, J. Attenberg, J. Langford, and A. Smola. Feature hashing for large scale multitask learning. In Proc. of the Int. Conf. on Machine Learning (ICML), pp. 1113–1120, 2009.   \nJ. Weston, O. Chapelle, A. Elisseeff, B. Scholkopf, and V. Vapnik. Kernel dependency estimation. ¨ In S. Becker, S. Thrun, and K. Obermayer (eds.), Advances in Neural Information Processing Systems (NIPS), volume 15, pp. 873–880. 2002. ",
+        "bbox": [
+            171,
+            454,
+            826,
+            928
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            169,
+            90,
+            826,
+            934
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            70,
+            828,
+            933
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "J. Weston, S. Bengio, and N. Usunier. Large scale image annotation: learning to rank with joint word-image embeddings. Machine Learning, 81(1):21–35, 2010. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Y. Wu, C. DuBois, A. X. Zheng, and M. Ester. Collaborative denoising auto-encoders for top-n recommender systems. In Proc. of the ACM Int. Conf. on Web Search and Data Mining (WSDM), pp. 153–162, 2016. ",
+        "bbox": [
+            174,
+            147,
+            823,
+            190
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "C.-N. Ziegler, S. M. McNee, J. A. Konstan, and G. Lausen. Improving recommendation lists through topic diversification. In Proc. of the Int. World Wide Web Conf. (WWW), pp. 22–32, 2005. ",
+        "bbox": [
+            176,
+            207,
+            823,
+            236
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX A TASKS DETAIL ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            268,
+            423,
+            285
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A.1 MOVIELENS (ML) ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            301,
+            346,
+            316
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We first consider the task of movie recommendation with the Movielens 20M data set4 (Harper & Konstan, 2015). This data set comprises 20 million ratings applied to roughly 27,000 movies by over 138,000 users. To recommend movies that users would like, ratings, originally between 0.5 and 5 stars, were discretized with a threshold of 3.5. Then, movies with less than 5 ratings were removed, resulting in a total of 15,405 movies. User profiles were next built using a chronologically-ordered list of liked movies. We removed users with less than 2 movies and limited profiles to a maximum of 2,000 movies (less than $0 . 1 \\%$ fulfilled this condition). Inputs and outputs were built by splitting user profiles uniformly at random, ensuring a minimum of one movie in both input and output. Finally, 10,000 random users were taken out for validation and another 10,000 for testing. The ML data set is the most dense data set we consider, with a median of 18 movies in input/output profiles (Table 1). ",
+        "bbox": [
+            174,
+            330,
+            825,
+            469
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "To perform recommendations with the ML data set, we build on top of $\\mathrm { W u }$ et al. (2016) and consider a 3-layer feed-forward neural network with a softmax output and 150 rectified linear units (Glorot et al., 2011) in the hidden layers. We initialize the weights with uniform random numbers, weighted by the input and output dimensionality of the layer (Glorot & Bengio, 2010). We optimize the weights of the network using cross-entropy and Adam (Kingma & Ba, 2015), with a learning rate of 0.001 and parameters $\\beta _ { 1 } ~ = ~ 0 . 9$ and $\\beta _ { 2 } ~ = ~ 0 . 9 9 9$ . Training is performed for 15 epochs and with batches of 32 instances. If no improvement is seen on the validation set after one epoch, the learning rate is divided by 5. As done with all the other tasks, we make sure that the network architecture and the number of epochs is sufficient to achieve a state-of-the-art result. As the output probabilities define a ranking of movies that the user may like, the accuracy of the result is measured with mean average precision (Manning et al., 2008). The obtained baseline score $S _ { 0 } = 0 . 1 6 0$ can be considered a state-of-the-art result (Wu et al., 2016). Performing movie rankings at random yields a score $S _ { \\mathrm { R } } = 0 . 0 0 3$ . ",
+        "bbox": [
+            174,
+            476,
+            825,
+            656
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A.2 PENN TREEBANK (PTB) ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            678,
+            385,
+            691
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Another task we consider is next-word prediction with the Penn treebank data set (Marcus et al., 1993). We employ the data made available by Mikolov (2012), which contains close to 1 million words and defines validation and test splits of roughly 74,000 and 82,000 words, respectively. The vocabulary is limited to 10,000 words, with all other words mapped to an ‘unknown’ token (Table 1). We consider the end of the sentence as an additional token and form input sequences of length 10. ",
+        "bbox": [
+            176,
+            705,
+            823,
+            775
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Inspired by Graves (2013), we perform next word prediction with an LSTM network (Hochreiter & Schmidhuber, 1997). We set the inner dimensionality to 250 and train the network with SGD. We use a learning rate of 0.25, a momentum of 0.99, and clip gradients to have a maximum norm of 1 (Graves, 2013). We use batches of 128 instances and train the model for 10 epochs. As for the rest, we proceed as with the ML task. We evaluate the result using the reciprocal rank of the correct prediction (Manning et al., 2008). We achieve a performance of $S _ { 0 } = 0 . 3 4 2$ , which indicates that, on average, the correct word is ranked on the third position. Predicting words at random yields a score $S _ { \\mathrm { R } } = 0 . 0 0 1$ . ",
+        "bbox": [
+            174,
+            781,
+            825,
+            893
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A.3 CADE WEB DIRECTORY (CADE) ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            103,
+            449,
+            117
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We perform single-label text categorization using web pages classified by human experts from the CADE web directory of Brazilian web pages5 (Cardoso-Cachopo, 2007). The data set contains around 40,000 documents assigned to one of 12 categories such as services, education, health, or culture. We use the train and test splits provided by Cardoso-Cachopo (2007), further splitting the train set randomly to obtain a validation set from it. Validation and test splits comprise 5,000 and 13,661 documents, respectively. The size of the vocabulary is close to 200,000 words with a median number of 17 words per document (Table 1). ",
+        "bbox": [
+            174,
+            130,
+            825,
+            227
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "To perform classification we use a 4-layer feed-forward neural network with a softmax output. The number of units is, from input to output, 400, 200, 100, and 12, and we use rectified linear units as activations for the hidden layers. We train the network for 10 epochs, using batches of 32 instances and RMSprop (Tieleman & Hinton, 2012) with a learning rate of 0.0002 and exponential decay of 0.9. As for the rest, we proceed as with the ML task. We obtain a baseline accuracy of $S _ { 0 } = 5 8 . 0 \\%$ , slightly superior than the best baseline reported by Cardoso-Cachopo (2007), and a random accuracy of $S _ { \\mathrm { R } } = 8 . 5 \\%$ (Table 2). Notice that this is the only data set that does not have a sparse instance or user profile as output. ",
+        "bbox": [
+            174,
+            234,
+            825,
+            347
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A.4 MILLION SONG DATA SET (MSD) ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            364,
+            447,
+            378
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "The next task we consider is song recommendation with the million song data set (Bertin-Mahieux et al., 2011). We take the Echo Nest taste profile subset6, which includes over 48 million play counts of around 384,000 songs for roughly 1 million users. We assume that a user likes a song when this has listened to it a minimum of 3 times. We then remove the songs that appear less than 20 times and build user profiles with a minimum of 5 songs. We split the data set as with the ML task, keeping 50,000 user profiles for validation and another 50,000 for testing. The MSD data set has a median of 5 songs in input/output profiles (Table 1). ",
+        "bbox": [
+            174,
+            390,
+            825,
+            488
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "To recommend future listens to the user we use a 3-layer feed-forward neural network with a softmax output and 300 rectified linear units in the hidden layers. We fit the model for 10 epochs with batches of 64 instances. As for the rest, we proceed as with the ML task. We obtain a baseline mean average precision of $S _ { 0 } = 0 . 0 6 6$ and a random score of $S _ { \\mathrm { R } }$ below 0.001. ",
+        "bbox": [
+            174,
+            494,
+            825,
+            550
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A.5 AMAZON BOOK REVIEWS (AMZ) ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            569,
+            449,
+            583
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We also consider book recommendations with the Amazon book reviews data $\\mathrm { s e t } ^ { 7 }$ (McAuley et al., 2015). The data set originally contains 22 million ratings of over 2 million books by approximately 3 million users. We proceed as with the ML data set, but this time setting the minimum number of ratings per book to 100 and splitting the data with 50,000 instances for validation and another 50,000 instances for testing. ",
+        "bbox": [
+            174,
+            595,
+            823,
+            665
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We here use a 4-layer feed-forward neural network with a softmax output and 300 rectified linear units in the hidden layers. We fit the model for 10 epochs with batches of 64 instances and, as for the rest, we proceed as with the ML task. We obtain a baseline mean average precision of $S _ { 0 } = 0 . 0 4 9$ and a random score of $S _ { \\mathrm { R } }$ below 0.001. ",
+        "bbox": [
+            174,
+            672,
+            825,
+            728
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A.6 BOOK CROSSING (BC) ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            746,
+            375,
+            761
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Continuing with book recommendations, we consider the book crossing data set8 (Ziegler et al., 2005). It contains 278,000 users providing over 1 million ratings about a little more than 271,000 books. We remove books with less than 2 ratings, discretize those by a threshold of 4, and proceed as with the ML data set, but keeping 2,500 users for validation and another 2,500 for testing. The BC data set is known to be a very sparse data set, specially after removing users with less than 2 book reviews (Table 1). ",
+        "bbox": [
+            173,
+            772,
+            825,
+            857
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "To perform recommendations we use the same architecture and configuration as with the MSD task, but this time we use 250 units in the hidden layers. We obtain a baseline mean average precision of $S _ { 0 } = 0 . 0 1 0$ and a random score of $S _ { \\mathrm { R } }$ below 0.001. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            146
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "A.7 YOOCHOOSE (YC) ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            166,
+            351,
+            181
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "We finally study session-based recommendations using the YooChoose RecSys15 challenge9 data. Here, the task is to predict the next click given a sequence of click events for a given session in an e-commerce site (Hidasi et al., 2016). We work with the training set of the challenge and keep only the click events. We take the first 2 million sessions of the data set which have a minimum of 2 clicks, and keep apart 50,000 for validation and another 50,000 for testing. We form sequences of, at most, 13 clicks to the 35,000 possible links (Table 1). Note that this is a sequential data set with one-hot encoded instances of only one event each. ",
+        "bbox": [
+            174,
+            194,
+            825,
+            291
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "To predict the next click we proceed as in Hidasi et al. (2016) and consider a GRU model (Cho et al., 2014). We set the inner dimensionality to 100 and train the network with Adagrad (Duchi et al., 2011), using a learning rate of 0.01. We use batches of 64 instances and train the model for 10 epochs. As for the rest, we proceed as with the ML task. As with PTB, we evaluate the result using the reciprocal rank of the correct prediction. We achieve a performance of $S _ { 0 } = 0 . 3 6 8$ , which can be assumed to be as good as state-of-the-art models on this data (Hidasi et al., 2016). Predicting clicks at random yields a score $S _ { \\mathrm { R } }$ below 0.001. ",
+        "bbox": [
+            173,
+            299,
+            825,
+            396
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX B GOING ONE STEP FURTHER WITH CO-OCCURRENCE-BASED COLLISIONS ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            421,
+            789,
+            454
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "B.1 CO-OCCURRENCE-BASED BLOOM EMBEDDING (CBE) ",
+        "bbox": [
+            174,
+            472,
+            591,
+            487
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "In Bloom filters and BE, collisions are unavoidable due to the lower embedding dimensionality and the use of multiple projections (Sec. 3). In addition we have seen that alternative approaches produce embeddings by exploiting co-occurrence information (Secs. 2 and 4.3). Here, we study a variant of BE that takes advantage of co-occurrence information to adjust the collisions that will inevitably take place when performing the embedding. We denote this approach by co-occurrencebased Bloom embedding (CBE). ",
+        "bbox": [
+            174,
+            500,
+            825,
+            584
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "What we propose is a quite straightforward approach to CBE, which does not add much extra precomputation time. Training and testing times remain the same, as CBE uses a pre-computed hashing matrix H (Sec. 3.2). The general idea of the proposed approach is to ‘re-direct’ the collisions of the co-occurring elements to the same bits or positions of u. Our implementation of this idea is detailed in Algorithm 1, and briefly explained below. ",
+        "bbox": [
+            174,
+            590,
+            825,
+            660
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 Pseudocode for CBE. ",
+        "bbox": [
+            176,
+            680,
+            405,
+            694
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Input: Input and/or output instances $\\mathbf { X }$ $\\cdot n \\times d$ sparse binary matrix), embedding dimensionality $m$ , number of projections $k$ , and pre-computed hashing matrix $\\mathbf { H }$ ( $d \\times k$ integers matrix). ",
+        "bbox": [
+            169,
+            700,
+            823,
+            728
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Output: Co-occurrence-based hashing matrix $\\mathbf { H } ^ { \\prime }$ ",
+        "bbox": [
+            176,
+            729,
+            503,
+            743
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "1: $\\mathbf { C } \\gets \\mathbf { X } ^ { \\mathrm { { T } } } \\mathbf { X }$   \n2: $\\mathbf { C }  \\mathbf { C }$ $\\odot$ $\\operatorname { S G N } ( \\mathbf { C } - \\operatorname { A V G F R E Q } ( \\mathbf { X } ) )$   \n3: cVAL , $\\mathbf { c } ^ { \\mathrm { R O W } }$ , $\\mathbf { c } ^ { \\mathrm { { c o L } } } \\gets \\mathrm { { C O O R D } } \\big ( \\mathrm { { L O W T R I } } ( \\mathbf { C } ) \\big )$   \n4: for $i$ in ARGSORT(cVAL)   \n5: a, b ← cROW, cCOL   \n6: $r \\gets \\mathrm { U R N D } \\big ( 1 , m , \\mathsf { h } _ { a } \\cup \\mathsf { h } _ { b } \\big )$   \n7: $j _ { a } \\gets \\mathrm { U R N D } ( 1 , k , \\emptyset )$   \n8: $j _ { b } \\gets \\mathrm { U R N D } ( 1 , k , \\emptyset )$   \n9: $h _ { a , j _ { a } } , h _ { b , j _ { b } } \\gets r$ ",
+        "bbox": [
+            179,
+            748,
+            470,
+            877
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/6a36e6d43dc7976a4972a48f3e64e5d83c8ad11cc8d5a7f5fb30ef43a4e0ce03.jpg",
+        "table_caption": [
+            "Table 4: Co-occurrence statistics and average score increase of CBE over BE. From left to right: data set name, input percent of co-occurrent pairs, input average co-occurrence ratio of co-occurrent pairs, output percent of co-occurrent pairs, output average co-occurrence ratio of co-occurrent pairs, and average score increases of CBE over BE ( $\\%$ , calculated using $1 0 0 ( S _ { j } - S _ { i } ) / S _ { 0 }$ and averaging over all $m / d$ points). Co-occurrence values for PTB and YC inputs correspond to considering training sequences, not isolated sequence elements. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Data set</td><td colspan=\"4\">Co-occurrence statistics</td><td colspan=\"2\">Score increase (%)</td></tr><tr><td>Input (%)</td><td>Input (p)</td><td>Output (%)</td><td>Ouput (p)</td><td>k=3</td><td>k=4</td></tr><tr><td>ML</td><td>25.2</td><td>1.3:10-4</td><td>32.9</td><td>1.0.10-4</td><td>+0.9</td><td>+1.7</td></tr><tr><td>PTB</td><td>3.3</td><td>2.4· 10-5</td><td>0</td><td>0</td><td>+0.1</td><td>+0.9</td></tr><tr><td>CADE</td><td>1.3</td><td>8.8.10-5</td><td>N/A</td><td>N/A</td><td>-0.4</td><td>-0.1</td></tr><tr><td>MSD</td><td>1.3</td><td>3.0·10-6</td><td>1.3</td><td>3.1·10-6</td><td>+0.5</td><td>+1.5</td></tr><tr><td>AMZ</td><td>3.0</td><td>1.8. 10-6</td><td>3.0</td><td>1.8.10-6</td><td>+6.6</td><td>+8.4</td></tr><tr><td>BC</td><td>0.8</td><td>4.9.10-5</td><td>0.4</td><td>4.9 · 10-5</td><td>-3.4</td><td>-1.0</td></tr><tr><td>YC</td><td>0.2</td><td>1.5 · 10-6</td><td>0</td><td>0</td><td>+0.4</td><td>+0.3</td></tr></table>",
+        "bbox": [
+            210,
+            202,
+            787,
+            338
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "First, we count pairwise co-occurrences and store them in a sparse matrix C (line 1). Next, we threshold C by the average element frequency in $\\mathbf { X }$ using the Hadamard product $\\odot$ and a componentwise sign function (line 2). We then get the lower triangular part of C and return it in coordinates format, that is, using a tuple of values, row indices, and column indices (line 3). We will use the order in $\\mathbf { c } ^ { \\mathrm { { V A L } } }$ to update the hash matrix H. To do so, we first loop over the indices of the sorted values of $\\mathbf { c } ^ { \\mathrm { { V A L } } }$ in increasing order (line 4). After selecting the corresponding elements $a$ and $b$ (line 5), we then draw integers from URND (lines 6–8). The function $\\mathrm { U R N D } \\left( x , y , z \\right)$ is a uniform random integer generator between $x$ and $y$ (both included) such that the output integer is not included in the set $\\textsf { Z }$ , that is, $\\mathrm { U R N D } ( x , y , z ) \\not \\in { z }$ . Rows $a$ and $b$ of $\\mathbf { H }$ are transformed to sets $\\mathsf { h } _ { a }$ and $\\mathsf { h } _ { b }$ and its union is computed (line 6). Finally, we use the integers generated by URND to pick projections $j _ { a }$ and $j _ { b }$ from $\\mathbf { H }$ , and assign them the same bit $r$ (line 9). By updating the projections in $\\mathbf { H }$ in increasing order of co-occurrence (line 4), we give priority to the pairs with largest co-occurrence, setting them to collide to the same bit $r$ (line 9). ",
+        "bbox": [
+            173,
+            369,
+            825,
+            551
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "B.2 CBE RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            568,
+            316,
+            582
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Overall, the performance of CBE only provides moderate increments over the original BE approach (Fig. 4). With the exception of the BC task, the performance of CBE is always higher than the one of BE. However, with the exception of the AMZ task, we do not observe dramatic increases of CBE over BE. On average, such increases are between $0 . 4 \\%$ and $8 . 4 \\%$ (Table 4, right). One possible explanation for these moderate performance increases is the low co-occurrence in the considered data (Table 4, left). As it can be seen, typically less than $3 \\%$ of all possible pairs show a cooccurrence. Moreover, the average co-occurrence count of such co-occurring pairs is very low, with ratios $\\rho$ to the total number of instances $n$ in the order of $1 0 ^ { - 5 }$ or $1 0 ^ { - 6 }$ . ",
+        "bbox": [
+            173,
+            593,
+            825,
+            705
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Despite being moderate on average, we observed that the increments provided by CBE were more prominent for low dimensionality ratios $m / d$ . By relating CBE with the best approaches resulting from the comparison of BE with the alternatives, we see that CBE is generally better than BE, sometimes with a statistically significant difference (Table 5). Furthermore, we see that CBE, being based on co-occurrences, more closely approaches PMI and CCA in the tasks where those were performing best, and even outperforms them in one test point (AMZ, $m / d = 0 . 2$ ; compare also with Table 3). Being closer to those co-occurrence-based approaches is an indication that CBE leverages co-occurrence information to some extent. ",
+        "bbox": [
+            174,
+            712,
+            825,
+            824
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/14749a2896d6bc9a270dbe84aba6be6f277480ee88a75cec28468e633cbf91bf.jpg",
+        "image_caption": [
+            "Figure 4: Comparison of score ratios $S _ { i } / S _ { 0 }$ as a function of dimensionality ratio $m / d$ for BE (dashed lines) and CBE (solid lines) using $k \\ = \\ 4$ . Qualitatively similar plots are observed for other values of $k$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            191,
+            114,
+            800,
+            515
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "table",
+        "img_path": "images/cf124ea0586f8974d9d6d721bcb9118565a55024eaf827cb865006e80f039c29.jpg",
+        "table_caption": [
+            "Table 5: Comparison of CBE versus the results in Table 3. Score ratios $S _ { i } / S _ { 0 }$ for different combinations of data set and compression ratio $m / d$ . Best results are highlighted in bold, up to statistical significance (Mann-Whitney-U, $p { > } 0 . 0 5 )$ . "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"2\">Test point</td><td colspan=\"2\">Best so far</td><td colspan=\"2\">CBE</td></tr><tr><td>Data set</td><td>m/d</td><td>Method</td><td>Si/So</td><td>k=3</td><td>k=4</td></tr><tr><td>ML</td><td>0.2</td><td>BE</td><td>0.770</td><td>0.760</td><td>0.781</td></tr><tr><td>ML</td><td>0.3</td><td>BE</td><td>0.815</td><td>0.812</td><td>0.867</td></tr><tr><td>PTB</td><td>0.2</td><td>BE</td><td>0.919</td><td>0.915</td><td>0.907</td></tr><tr><td>PTB</td><td>0.4</td><td>BE</td><td>0.942</td><td>0.937</td><td>0.922</td></tr><tr><td>CADE</td><td>0.01</td><td>PMI</td><td>0.984</td><td>0.854</td><td>0.853</td></tr><tr><td>CADE</td><td>0.03</td><td>PMI</td><td>1.002</td><td>0.921</td><td>0.922</td></tr><tr><td>MSD</td><td>0.05</td><td>BE</td><td>0.738</td><td>0.759</td><td>0.756</td></tr><tr><td>MSD</td><td>0.1</td><td>BE</td><td>0.841</td><td>0.856</td><td>0.873</td></tr><tr><td>AMZ</td><td>0.1</td><td>CCA</td><td>1.030</td><td>0.994</td><td>0.991</td></tr><tr><td>AMZ</td><td>0.2</td><td>CCA</td><td>1.048</td><td>1.109</td><td>1.117</td></tr><tr><td>BC</td><td>0.05</td><td>BE</td><td>0.837</td><td>0.774</td><td>0.808</td></tr><tr><td>BC</td><td>0.1</td><td>BE</td><td>0.965</td><td>0.880</td><td>0.878</td></tr><tr><td>YC</td><td>0.03</td><td>BE</td><td>0.858</td><td>0.871</td><td>0.880</td></tr><tr><td>YC</td><td>0.05</td><td>BE</td><td>0.928</td><td>0.933</td><td>0.936</td></tr></table>",
+        "bbox": [
+            250,
+            672,
+            746,
+            900
+        ],
+        "page_idx": 16
+    }
+]